Variable exprConst

Type Declaration

• abs: (input: NumberInput) => Expr<number>

• accumulated: () => Expr<ExprValue>

• acos: (input: NumberInput) => Expr<number>

• add: (...inputs: NumberInput[]) => Expr<number>

• all: (...inputs: BooleanInput[]) => Expr<boolean>

• any: (...inputs: BooleanInput[]) => Expr<boolean>

• asin: (input: NumberInput) => Expr<number>

• at: (index: NumberInput, array: Expr<unknown>) => Expr<ExprValue>

• atan: (input: NumberInput) => Expr<number>

• Readonlycase: (...args: (Resolvable | [BooleanInput, Resolvable])[]) => Expr<ExprValue>

• ceil: (input: NumberInput) => Expr<number>

• coalesce: (...inputs: Resolvable[]) => Expr<ExprValue>

• collator: (options?: CollatorOptions) => Expr<ExprCollator>

• concat: (...inputs: Resolvable[]) => Expr<string>

• contains: (needle: Resolvable, haystack: Resolvable) => Expr<boolean>

• cos: (input: NumberInput) => Expr<number>

• cubicBezier: (x1: number, y1: number, x2: number, y2: number) => InterpolationMethod

• distance: (geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<number>

• distanceFromCenter: () => Expr<number>

• divide: (a: NumberInput, b: NumberInput) => Expr<number>

• downcase: (input: StringInput) => Expr<string>

• e: () => Expr<number>

• eq: (left: Resolvable, right: Resolvable) => Expr<boolean>

• exponential: (base: number) => InterpolationMethod

• featureState: (property: string) => Expr<ExprValue>

• floor: (input: NumberInput) => Expr<number>

• format: (...segments: [StringInput, FormatSegmentOptions?][]) => Expr<ExprFormatted>

• geometryType: () => Expr<string>

• get: (property: string, object?: Expr<unknown>) => Expr<ExprValue>

• gt: (left: Resolvable, right: Resolvable) => Expr<boolean>

• gte: (left: Resolvable, right: Resolvable) => Expr<boolean>

• has: (property: string, object?: Expr<unknown>) => Expr<boolean>

• heatmapDensity: () => Expr<number>

• hsl: (
      hue: NumberInput,
      saturation: NumberInput,
      lightness: NumberInput,
  ) => Expr<ExprColor>

• hsla: (
      hue: NumberInput,
      saturation: NumberInput,
      lightness: NumberInput,
      alpha: NumberInput,
  ) => Expr<ExprColor>

• id: () => Expr<ExprValue>

• image: (name: StringInput) => Expr<ExprImage>

• indexOf: (
      needle: Resolvable,
      haystack: Resolvable,
      fromIndex?: NumberInput,
  ) => Expr<number>

• interpolate: (
      method: InterpolationMethod,
      input: Resolvable,
      ...stops: [number, Resolvable][],
  ) => Expr<ExprValue>

• interpolateHcl: (
      method: InterpolationMethod,
      input: Resolvable,
      ...stops: [number, ColorInput][],
  ) => Expr<ExprColor>

• interpolateLab: (
      method: InterpolationMethod,
      input: Resolvable,
      ...stops: [number, ColorInput][],
  ) => Expr<ExprColor>

• intersects: (geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<boolean>

• length: (input: Resolvable) => Expr<number>

• Readonlylet: (bindings: Record<string, Resolvable>, result: Resolvable) => Expr<ExprValue>

• linear: () => InterpolationMethod

• lineProgress: () => Expr<number>

• literal: (value: Record<string, unknown> | unknown[]) => Expr<ExprValue>

• ln: (input: NumberInput) => Expr<number>

• Readonlyln2: () => Expr<number>

• log10: (input: NumberInput) => Expr<number>

• log2: (input: NumberInput) => Expr<number>

• lt: (left: Resolvable, right: Resolvable) => Expr<boolean>

• lte: (left: Resolvable, right: Resolvable) => Expr<boolean>

• Readonlymatch: (
      input: Resolvable,
      ...casesAndFallback: (
          Resolvable
          | [(Resolvable | Resolvable[]), Resolvable]
      )[],
  ) => Expr<ExprValue>

• max: (...inputs: NumberInput[]) => Expr<number>

• min: (...inputs: NumberInput[]) => Expr<number>

• mod: (a: NumberInput, b: NumberInput) => Expr<number>

• multiply: (...inputs: NumberInput[]) => Expr<number>

• neq: (left: Resolvable, right: Resolvable) => Expr<boolean>

• not: (input: BooleanInput) => Expr<boolean>

• numberFormat: (input: NumberInput, options?: NumberFormatOptions) => Expr<string>

• pi: () => Expr<number>

• pitch: () => Expr<number>

• pow: (base: NumberInput, exponent: NumberInput) => Expr<number>

• properties: () => Expr<Record<string, unknown>>

• resolvedLocale: (input: Expr<ExprCollator>) => Expr<string>

• rgb: (red: NumberInput, green: NumberInput, blue: NumberInput) => Expr<ExprColor>

• rgba: (
      red: NumberInput,
      green: NumberInput,
      blue: NumberInput,
      alpha: NumberInput,
  ) => Expr<ExprColor>

• round: (input: NumberInput) => Expr<number>

• sin: (input: NumberInput) => Expr<number>

• slice: (input: Resolvable, start: NumberInput, end?: NumberInput) => Expr<ExprValue>

• sqrt: (input: NumberInput) => Expr<number>

• step: (
      input: Resolvable,
      defaultOutput: Resolvable,
      ...stops: [number, Resolvable][],
  ) => Expr<ExprValue>

• subtract: (a: NumberInput, b?: NumberInput) => Expr<number>

• tan: (input: NumberInput) => Expr<number>

• toBoolean: (input: Resolvable) => Expr<boolean>

• toColor: (...inputs: Resolvable[]) => Expr<ExprColor>

• toNumber: (...inputs: Resolvable[]) => Expr<number>

• toRgba: (color: ColorInput) => Expr<number[]>

• ReadonlytoString: (input: Resolvable) => Expr<string>

• typeOf: (input: Resolvable) => Expr<string>

• upcase: (input: StringInput) => Expr<string>

• Readonlyvar: (name: string) => Expr<ExprValue>

• within: (geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<boolean>

• zoom: () => Expr<number>