@feltmaps/js-sdk 1.5.0-next.1 → 1.5.0-next.10

package/dist/types-CWwhAtt1.d.ts

@@ -0,0 +1,3385 @@
+import { ZodRawShape, objectOutputType, ZodTypeAny, z } from 'zod';
+
+/**
+ * A selection of generic utility types
+ */
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PromiseOrNot<T> = T | Promise<T>;
+/**
+ * A better type inference for zod schemas that retains the TSDoc comments
+ * from the members in the compiled output.
+ */
+type zInfer<T extends {
+    shape: ZodRawShape;
+}> = objectOutputType<T["shape"], ZodTypeAny, "strip">;
+
+declare const PlaceCreateSchema: z.ZodObject<Omit<{
+    symbol: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Place">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    frame: z.ZodOptional<z.ZodNullable<z.ZodEnum<["frame-circle", "frame-square"]>>>;
+    hideLabel: z.ZodOptional<z.ZodBoolean>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Place";
+    coordinates: [number, number];
+    symbol?: string | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    frame?: "frame-circle" | "frame-square" | null | undefined;
+    hideLabel?: boolean | undefined;
+}, {
+    type: "Place";
+    coordinates: [number, number];
+    symbol?: string | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    frame?: "frame-circle" | "frame-square" | null | undefined;
+    hideLabel?: boolean | undefined;
+}>;
+declare const PathCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Path">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    distanceMarker: z.ZodOptional<z.ZodBoolean>;
+    endCaps: z.ZodOptional<z.ZodBoolean>;
+    routingMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<["driving", "cycling", "walking", "flying"]>>>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Path";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    distanceMarker?: boolean | undefined;
+    endCaps?: boolean | undefined;
+    routingMode?: "driving" | "cycling" | "walking" | "flying" | null | undefined;
+}, {
+    type: "Path";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    distanceMarker?: boolean | undefined;
+    endCaps?: boolean | undefined;
+    routingMode?: "driving" | "cycling" | "walking" | "flying" | null | undefined;
+}>;
+declare const PolygonCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
+    areaMarker: z.ZodOptional<z.ZodBoolean>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    areaMarker?: boolean | undefined;
+}, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    areaMarker?: boolean | undefined;
+}>;
+declare const CircleCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Circle">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
+    radius: z.ZodNumber;
+    radiusDisplayAngle: z.ZodOptional<z.ZodNumber>;
+    radiusDisplayUnit: z.ZodOptional<z.ZodNullable<z.ZodEnum<["meter", "kilometer", "foot", "mile"]>>>;
+    radiusMarker: z.ZodOptional<z.ZodBoolean>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Circle";
+    coordinates: [number, number];
+    radius: number;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    radiusDisplayAngle?: number | undefined;
+    radiusDisplayUnit?: "meter" | "kilometer" | "foot" | "mile" | null | undefined;
+    radiusMarker?: boolean | undefined;
+}, {
+    type: "Circle";
+    coordinates: [number, number];
+    radius: number;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    radiusDisplayAngle?: number | undefined;
+    radiusDisplayUnit?: "meter" | "kilometer" | "foot" | "mile" | null | undefined;
+    radiusMarker?: boolean | undefined;
+}>;
+declare const MarkerCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Marker">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    size: z.ZodOptional<z.ZodNumber>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Marker";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+    size?: number | undefined;
+    zoom?: number | undefined;
+}, {
+    type: "Marker";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+    size?: number | undefined;
+    zoom?: number | undefined;
+}>;
+declare const HighlighterCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Highlighter">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Highlighter";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}, {
+    type: "Highlighter";
+    coordinates: [number, number][][];
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}>;
+declare const TextCreateSchema: z.ZodObject<Omit<Omit<{
+    type: z.ZodLiteral<"Text">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    text: z.ZodString;
+    align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+    style: z.ZodOptional<z.ZodEnum<["italic", "light", "regular", "caps"]>>;
+}, "id">, "coordinates" | "name">, "strip", z.ZodTypeAny, {
+    type: "Text";
+    text: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+}, {
+    type: "Text";
+    text: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+}>;
+declare const NoteCreateSchema: z.ZodObject<Omit<Omit<{
+    type: z.ZodLiteral<"Note">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    text: z.ZodString;
+    align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+    style: z.ZodOptional<z.ZodEnum<["italic", "light", "regular", "caps"]>>;
+    widthScale: z.ZodOptional<z.ZodNumber>;
+}, "id">, "coordinates" | "name">, "strip", z.ZodTypeAny, {
+    type: "Note";
+    text: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+    widthScale?: number | undefined;
+}, {
+    type: "Note";
+    text: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+    widthScale?: number | undefined;
+}>;
+declare const ImageCreateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Image">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    id: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodString;
+    opacity: z.ZodOptional<z.ZodNumber>;
+}, "id">, "strip", z.ZodTypeAny, {
+    type: "Image";
+    coordinates: [number, number][][];
+    imageUrl: string;
+    groupId?: string | null | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}, {
+    type: "Image";
+    coordinates: [number, number][][];
+    imageUrl: string;
+    groupId?: string | null | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}>;
+declare const PlaceReadSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    imageUrl: z.ZodNullable<z.ZodString>;
+}>, {
+    type: z.ZodLiteral<"Place">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    symbol: z.ZodString;
+    frame: z.ZodNullable<z.ZodEnum<["frame-circle", "frame-square"]>>;
+    hideLabel: z.ZodBoolean;
+}>, "strip", z.ZodTypeAny, {
+    symbol: string;
+    type: "Place";
+    coordinates: [number, number];
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    frame: "frame-circle" | "frame-square" | null;
+    hideLabel: boolean;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    symbol: string;
+    type: "Place";
+    coordinates: [number, number];
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    frame: "frame-circle" | "frame-square" | null;
+    hideLabel: boolean;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const PathReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    imageUrl: z.ZodNullable<z.ZodString>;
+}>, {
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+}>, {
+    type: z.ZodLiteral<"Path">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    distanceMarker: z.ZodBoolean;
+    endCaps: z.ZodBoolean;
+    routingMode: z.ZodNullable<z.ZodEnum<["driving", "cycling", "walking", "flying"]>>;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Path";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+    endCaps: boolean;
+    routingMode: "driving" | "cycling" | "walking" | "flying" | null;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Path";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+    endCaps: boolean;
+    routingMode: "driving" | "cycling" | "walking" | "flying" | null;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const PolygonReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    imageUrl: z.ZodNullable<z.ZodString>;
+}>, {
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+}>, {
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    fillOpacity: z.ZodNumber;
+    areaMarker: z.ZodBoolean;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Polygon";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    areaMarker: boolean;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Polygon";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    areaMarker: boolean;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const CircleReadSchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    imageUrl: z.ZodNullable<z.ZodString>;
+}>, {
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+}>, {
+    type: z.ZodLiteral<"Circle">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    radius: z.ZodNumber;
+    radiusDisplayAngle: z.ZodNumber;
+    radiusDisplayUnit: z.ZodNullable<z.ZodEnum<["meter", "kilometer", "foot", "mile"]>>;
+    fillOpacity: z.ZodNumber;
+    radiusMarker: z.ZodBoolean;
+}>, "strip", z.ZodTypeAny, {
+    type: "Circle";
+    coordinates: [number, number];
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    radius: number;
+    radiusDisplayAngle: number;
+    radiusDisplayUnit: "meter" | "kilometer" | "foot" | "mile" | null;
+    radiusMarker: boolean;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Circle";
+    coordinates: [number, number];
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string | null;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    radius: number;
+    radiusDisplayAngle: number;
+    radiusDisplayUnit: "meter" | "kilometer" | "foot" | "mile" | null;
+    radiusMarker: boolean;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const MarkerReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    type: z.ZodLiteral<"Marker">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    opacity: z.ZodNumber;
+    size: z.ZodNumber;
+    zoom: z.ZodNumber;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Marker";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    opacity: number;
+    size: number;
+    zoom: number;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Marker";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    opacity: number;
+    size: number;
+    zoom: number;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const HighlighterReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    type: z.ZodLiteral<"Highlighter">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    opacity: z.ZodNumber;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Highlighter";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    opacity: number;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Highlighter";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    opacity: number;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const TextReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rotation: z.ZodNumber;
+    scale: z.ZodNumber;
+    zoom: z.ZodNumber;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+}>, {
+    text: z.ZodString;
+    align: z.ZodEnum<["left", "center", "right"]>;
+    style: z.ZodEnum<["italic", "light", "regular", "caps"]>;
+    name: z.ZodString;
+}>, {
+    type: z.ZodLiteral<"Text">;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Text";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    zoom: number;
+    position: [number, number];
+    rotation: number;
+    scale: number;
+    text: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Text";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    zoom: number;
+    position: [number, number];
+    rotation: number;
+    scale: number;
+    text: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const NoteReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    rotation: z.ZodNumber;
+    scale: z.ZodNumber;
+    zoom: z.ZodNumber;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+}>, {
+    text: z.ZodString;
+    align: z.ZodEnum<["left", "center", "right"]>;
+    style: z.ZodEnum<["italic", "light", "regular", "caps"]>;
+    name: z.ZodString;
+}>, {
+    type: z.ZodLiteral<"Note">;
+    widthScale: z.ZodNumber;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Note";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    zoom: number;
+    position: [number, number];
+    rotation: number;
+    scale: number;
+    text: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+    widthScale: number;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Note";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    zoom: number;
+    position: [number, number];
+    rotation: number;
+    scale: number;
+    text: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+    widthScale: number;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const ImageReadSchema: z.ZodObject<Omit<Omit<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    type: z.ZodLiteral<"Image">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    imageUrl: z.ZodString;
+    opacity: z.ZodNumber;
+}>, "color">, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Image";
+    id: string;
+    groupId: string | null;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string;
+    opacity: number;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Image";
+    id: string;
+    groupId: string | null;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    imageUrl: string;
+    opacity: number;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const LinkReadSchema: z.ZodObject<Omit<z.objectUtil.extendShape<{
+    id: z.ZodString;
+    groupId: z.ZodNullable<z.ZodString>;
+    color: z.ZodString;
+    name: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    description: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    interaction: z.ZodOptional<z.ZodEnum<["default", "locked"]>>;
+}, {
+    type: z.ZodLiteral<"Link">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    url: z.ZodString;
+}>, "coordinates">, "strip", z.ZodTypeAny, {
+    type: "Link";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    url: string;
+    interaction?: "default" | "locked" | undefined;
+}, {
+    type: "Link";
+    id: string;
+    groupId: string | null;
+    color: string;
+    name: string | null;
+    description: string | null;
+    attributes: Record<string, unknown>;
+    url: string;
+    interaction?: "default" | "locked" | undefined;
+}>;
+declare const PlaceUpdateSchema: z.ZodObject<{
+    symbol: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"Place">;
+    coordinates: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    frame: z.ZodOptional<z.ZodNullable<z.ZodEnum<["frame-circle", "frame-square"]>>>;
+    hideLabel: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "Place";
+    id: string;
+    symbol?: string | undefined;
+    coordinates?: [number, number] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    frame?: "frame-circle" | "frame-square" | null | undefined;
+    hideLabel?: boolean | undefined;
+}, {
+    type: "Place";
+    id: string;
+    symbol?: string | undefined;
+    coordinates?: [number, number] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    frame?: "frame-circle" | "frame-square" | null | undefined;
+    hideLabel?: boolean | undefined;
+}>;
+declare const PathUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Path">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    distanceMarker: z.ZodOptional<z.ZodBoolean>;
+    endCaps: z.ZodOptional<z.ZodBoolean>;
+    routingMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<["driving", "cycling", "walking", "flying"]>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Path";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    distanceMarker?: boolean | undefined;
+    endCaps?: boolean | undefined;
+    routingMode?: "driving" | "cycling" | "walking" | "flying" | null | undefined;
+}, {
+    type: "Path";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    distanceMarker?: boolean | undefined;
+    endCaps?: boolean | undefined;
+    routingMode?: "driving" | "cycling" | "walking" | "flying" | null | undefined;
+}>;
+declare const PolygonUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
+    areaMarker: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "Polygon";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    areaMarker?: boolean | undefined;
+}, {
+    type: "Polygon";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    areaMarker?: boolean | undefined;
+}>;
+declare const CircleUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Circle">;
+    coordinates: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strokeOpacity: z.ZodOptional<z.ZodNumber>;
+    strokeWidth: z.ZodOptional<z.ZodNumber>;
+    strokeStyle: z.ZodOptional<z.ZodEnum<["solid", "dashed", "dotted"]>>;
+    fillOpacity: z.ZodOptional<z.ZodNumber>;
+    radius: z.ZodOptional<z.ZodNumber>;
+    radiusDisplayAngle: z.ZodOptional<z.ZodNumber>;
+    radiusDisplayUnit: z.ZodOptional<z.ZodNullable<z.ZodEnum<["meter", "kilometer", "foot", "mile"]>>>;
+    radiusMarker: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "Circle";
+    id: string;
+    coordinates?: [number, number] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    radius?: number | undefined;
+    radiusDisplayAngle?: number | undefined;
+    radiusDisplayUnit?: "meter" | "kilometer" | "foot" | "mile" | null | undefined;
+    radiusMarker?: boolean | undefined;
+}, {
+    type: "Circle";
+    id: string;
+    coordinates?: [number, number] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | null | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeStyle?: "solid" | "dashed" | "dotted" | undefined;
+    fillOpacity?: number | undefined;
+    radius?: number | undefined;
+    radiusDisplayAngle?: number | undefined;
+    radiusDisplayUnit?: "meter" | "kilometer" | "foot" | "mile" | null | undefined;
+    radiusMarker?: boolean | undefined;
+}>;
+declare const MarkerUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Marker">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+    size: z.ZodOptional<z.ZodNumber>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "Marker";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+    size?: number | undefined;
+    zoom?: number | undefined;
+}, {
+    type: "Marker";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+    size?: number | undefined;
+    zoom?: number | undefined;
+}>;
+declare const HighlighterUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Highlighter">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "Highlighter";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}, {
+    type: "Highlighter";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    opacity?: number | undefined;
+}>;
+declare const TextUpdateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Text">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    text: z.ZodOptional<z.ZodString>;
+    align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+    style: z.ZodOptional<z.ZodEnum<["italic", "light", "regular", "caps"]>>;
+}, "coordinates" | "name">, "strip", z.ZodTypeAny, {
+    type: "Text";
+    id: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+}, {
+    type: "Text";
+    id: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+}>;
+declare const NoteUpdateSchema: z.ZodObject<Omit<{
+    type: z.ZodLiteral<"Note">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    text: z.ZodOptional<z.ZodString>;
+    align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+    style: z.ZodOptional<z.ZodEnum<["italic", "light", "regular", "caps"]>>;
+    widthScale: z.ZodOptional<z.ZodNumber>;
+}, "coordinates" | "name">, "strip", z.ZodTypeAny, {
+    type: "Note";
+    id: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+    widthScale?: number | undefined;
+}, {
+    type: "Note";
+    id: string;
+    groupId?: string | null | undefined;
+    color?: string | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    zoom?: number | undefined;
+    position?: [number, number] | undefined;
+    rotation?: number | undefined;
+    scale?: number | undefined;
+    text?: string | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    style?: "italic" | "light" | "regular" | "caps" | undefined;
+    widthScale?: number | undefined;
+}>;
+declare const ImageUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Image">;
+    coordinates: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">>;
+    id: z.ZodString;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    interaction: z.ZodOptional<z.ZodOptional<z.ZodEnum<["default", "locked"]>>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+    opacity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "Image";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | undefined;
+    opacity?: number | undefined;
+}, {
+    type: "Image";
+    id: string;
+    coordinates?: [number, number][][] | undefined;
+    groupId?: string | null | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    attributes?: Record<string, unknown> | undefined;
+    interaction?: "default" | "locked" | undefined;
+    imageUrl?: string | undefined;
+    opacity?: number | undefined;
+}>;
+interface PlaceElementCreate extends zInfer<typeof PlaceCreateSchema> {
+}
+interface PathElementCreate extends zInfer<typeof PathCreateSchema> {
+}
+interface PolygonElementCreate extends zInfer<typeof PolygonCreateSchema> {
+}
+interface CircleElementCreate extends zInfer<typeof CircleCreateSchema> {
+}
+interface MarkerElementCreate extends zInfer<typeof MarkerCreateSchema> {
+}
+interface HighlighterElementCreate extends zInfer<typeof HighlighterCreateSchema> {
+}
+interface TextElementCreate extends zInfer<typeof TextCreateSchema> {
+}
+interface NoteElementCreate extends zInfer<typeof NoteCreateSchema> {
+}
+interface ImageElementCreate extends zInfer<typeof ImageCreateSchema> {
+}
+interface PlaceElementRead extends zInfer<typeof PlaceReadSchema> {
+}
+interface PathElementRead extends zInfer<typeof PathReadSchema> {
+}
+interface PolygonElementRead extends zInfer<typeof PolygonReadSchema> {
+}
+interface CircleElementRead extends zInfer<typeof CircleReadSchema> {
+}
+interface MarkerElementRead extends zInfer<typeof MarkerReadSchema> {
+}
+interface HighlighterElementRead extends zInfer<typeof HighlighterReadSchema> {
+}
+interface TextElementRead extends zInfer<typeof TextReadSchema> {
+}
+interface NoteElementRead extends zInfer<typeof NoteReadSchema> {
+}
+interface ImageElementRead extends zInfer<typeof ImageReadSchema> {
+}
+interface LinkElementRead extends zInfer<typeof LinkReadSchema> {
+}
+interface PlaceElementUpdate extends zInfer<typeof PlaceUpdateSchema> {
+}
+interface PathElementUpdate extends zInfer<typeof PathUpdateSchema> {
+}
+interface PolygonElementUpdate extends zInfer<typeof PolygonUpdateSchema> {
+}
+interface CircleElementUpdate extends zInfer<typeof CircleUpdateSchema> {
+}
+interface MarkerElementUpdate extends zInfer<typeof MarkerUpdateSchema> {
+}
+interface HighlighterElementUpdate extends zInfer<typeof HighlighterUpdateSchema> {
+}
+interface TextElementUpdate extends zInfer<typeof TextUpdateSchema> {
+}
+interface NoteElementUpdate extends zInfer<typeof NoteUpdateSchema> {
+}
+interface ImageElementUpdate extends zInfer<typeof ImageUpdateSchema> {
+}
+type ElementCreate = PlaceElementCreate | PathElementCreate | PolygonElementCreate | CircleElementCreate | MarkerElementCreate | HighlighterElementCreate | ImageElementCreate | TextElementCreate | NoteElementCreate;
+type ElementUpdate = PlaceElementUpdate | PathElementUpdate | PolygonElementUpdate | CircleElementUpdate | MarkerElementUpdate | HighlighterElementUpdate | TextElementUpdate | NoteElementUpdate | ImageElementUpdate;
+/**
+ * @group Elements
+ */
+type Element = PlaceElementRead | PathElementRead | PolygonElementRead | CircleElementRead | MarkerElementRead | HighlighterElementRead | TextElementRead | NoteElementRead | ImageElementRead | LinkElementRead;
+/**
+ * @group Element Groups
+ */
+interface ElementGroup {
+    /**
+     * A string identifying the element group.
+     */
+    id: string;
+    /**
+     * The name of the element group. This is shown in the legend.
+     */
+    name: string;
+    /**
+     * The caption of the element group. This is shown in the legend.
+     */
+    caption: string | null;
+    /**
+     * The ids of the elements in the element group.
+     *
+     * @remarks
+     * You can use these ids to get the full element objects via the `getElements` method.
+     */
+    elementIds: Array<string>;
+    /**
+     * Whether the element group is visible or not.
+     */
+    visible: boolean;
+    /**
+     * Whether the element group is shown in the legend or not.
+     */
+    shownInLegend: boolean;
+}
+/**
+ * The constraints to apply when getting elements.
+ *
+ * @group Elements
+ */
+interface GetElementsConstraint extends zInfer<typeof GetElementsConstraintSchema> {
+}
+declare const GetElementsConstraintSchema: z.ZodObject<{
+    /**
+     * The ids of the elements to get.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: string[] | undefined;
+}, {
+    ids?: string[] | undefined;
+}>;
+/**
+ * The constraints to apply when getting element groups.
+ *
+ * @group Element Groups
+ */
+interface GetElementGroupsConstraint extends zInfer<typeof GetElementGroupsConstraintSchema> {
+}
+/**
+ * @ignore
+ */
+declare const GetElementGroupsConstraintSchema: z.ZodObject<{
+    /**
+     * The ids of the element groups to get.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: string[] | undefined;
+}, {
+    ids?: string[] | undefined;
+}>;
+/**
+ * The parameters for the `onElementChange` and the `onElementCreate` listeners.
+ *
+ * @group Elements
+ */
+interface ElementChangeCallbackParams {
+    /**
+     * The new data for the element or null if the element was removed.
+     */
+    element: Element | null;
+    /**
+     * Whether or not this element is still being created by a drawing tool.
+     *
+     * For example, if the user begins drawing a polygon, they need to place
+     * multiple points until they've ultimately completed the polygon. All
+     * the time they are still placing points, this will be true.
+     *
+     * For elements that require text entry (such as Places, Text and Notes)
+     * this will be true all the time the user is typing text until the point
+     * at which the user finishes, by pressing Escape for example.
+     *
+     * If the user is editing an existing element, this will be false.
+     *
+     * For elements that are created programatically, this will be false.
+     */
+    isBeingCreated: boolean;
+}
+/**
+ * The parameters for the `onElementGroupChange` listener.
+ *
+ * @group Element Groups
+ */
+interface ElementGroupChangeCallbackParams {
+    elementGroup: ElementGroup | null;
+}
+
+/**
+ * Represents a point in world coordinates.
+ */
+interface LatLng {
+    latitude: number;
+    longitude: number;
+}
+/**
+ * A tuple representing a longitude and latitude coordinate.
+ *
+ * This is used hen serializing geometry because that's the standard used in
+ * GeoJSON.
+ */
+type LngLatTuple = [longitude: number, latitude: number];
+/**
+ * A GeoJSON properties object.
+ */
+type GeoJsonProperties = Record<string, unknown>;
+/**
+ * A GeoJSON feature object, compliant with:
+ * https://datatracker.ietf.org/doc/html/rfc7946#section-3.2
+ *
+ * @interface
+ */
+type GeoJsonFeature = {
+    type: "Feature";
+    /**
+     * The bounding box of the feature.
+     */
+    bbox?: FeltBoundary;
+    /**
+     * The feature's geometry
+     */
+    geometry: GeoJsonGeometry;
+    /**
+     * A value that uniquely identifies this feature in a
+     * https://tools.ietf.org/html/rfc7946#section-3.2.
+     */
+    id?: string | number | undefined;
+    /**
+     * Properties associated with this feature.
+     */
+    properties: GeoJsonProperties;
+};
+interface PointGeometry extends zInfer<typeof PointGeometrySchema> {
+}
+/**
+ * A GeoJSON point geometry.
+ */
+declare const PointGeometrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"Point">;
+    coordinates: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+}, "strip", z.ZodTypeAny, {
+    type: "Point";
+    coordinates: [number, number];
+}, {
+    type: "Point";
+    coordinates: [number, number];
+}>;
+/**
+ * A GeoJSON multi-point geometry.
+ *
+ * @remarks
+ * You shouldn't expect this to come from Felt - it is here for completeness
+ * of the GeoJSON spec.
+ */
+interface MultiPointGeometry {
+    type: "MultiPoint";
+    coordinates: PointGeometry["coordinates"][];
+}
+interface PolygonGeometry extends zInfer<typeof PolygonGeometrySchema> {
+}
+/**
+ * A GeoJSON polygon geometry.
+ */
+declare const PolygonGeometrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"Polygon">;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}, {
+    type: "Polygon";
+    coordinates: [number, number][][];
+}>;
+/**
+ * A GeoJSON multi-polygon geometry.
+ *
+ * @interface
+ */
+type MultiPolygonGeometry = {
+    type: "MultiPolygon";
+    coordinates: PolygonGeometry["coordinates"][];
+};
+/**
+ * A GeoJSON line string geometry.
+ *
+ * @interface
+ */
+type LineStringGeometry = {
+    type: "LineString";
+    coordinates: LngLatTuple[];
+};
+/**
+ * A GeoJSON multi-line string geometry.
+ *
+ * @interface
+ */
+type MultiLineStringGeometry = {
+    type: "MultiLineString";
+    coordinates: LineStringGeometry["coordinates"][];
+};
+/**
+ * A GeoJSON geometry of any type
+ */
+type GeoJsonGeometry = PointGeometry | PolygonGeometry | LineStringGeometry | MultiLineStringGeometry | MultiPolygonGeometry | MultiPointGeometry;
+/**
+ * @ignore
+ * @internal
+ */
+declare const FeltZoomSchema: z.ZodNumber;
+/**
+ * The zoom level of the map.
+ *
+ * It is a floating-point number between 1 and 23, where 1 is the most
+ * zoomed out and 23 is the most zoomed in.
+ *
+ * @group Types
+ * @public
+ */
+type FeltZoom = z.infer<typeof FeltZoomSchema>;
+/**
+ * @ignore
+ * @internal
+ */
+declare const FeltBoundarySchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+/**
+ * The edges of the map in the form of a bounding box.
+ *
+ * The boundary is a tuple of the form `[west, south, east, north]`.
+ *
+ * @group Types
+ * @public
+ */
+type FeltBoundary = z.infer<typeof FeltBoundarySchema>;
+/**
+ * The parameters for the methods that change the visibility of entities.
+ *
+ * @public
+ * @category Visibility
+ */
+interface SetVisibilityRequest extends zInfer<typeof SetVisibilityRequestSchema> {
+}
+/**
+ * @internal
+ */
+declare const SetVisibilityRequestSchema: z.ZodObject<{
+    /**
+     * The ids of the entities you want to change the visibility of.
+     */
+    show: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    hide: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    show?: string[] | undefined;
+    hide?: string[] | undefined;
+}, {
+    show?: string[] | undefined;
+    hide?: string[] | undefined;
+}>;
+/**
+ * Specifies the direction to sort data in
+ *
+ * @group Types
+ */
+type SortDirection = z.infer<typeof SortDirectionSchema>;
+/** @ignore */
+declare const SortDirectionSchema: z.ZodEnum<["asc", "desc"]>;
+/**
+ * Configuration for sorting data by a specific attribute
+ *
+ * @group Types
+ */
+interface SortConfig extends zInfer<typeof SortConfigSchema> {
+}
+/** @ignore */
+declare const SortConfigSchema: z.ZodObject<{
+    /**
+     * The attribute to sort by. What this represents depends on the context.
+     * For instance, when sorting features in a data table, the attribute is
+     * the column to sort by.
+     */
+    attribute: z.ZodString;
+    /**
+     * The direction to sort in
+     */
+    direction: z.ZodEnum<["asc", "desc"]>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    direction: "asc" | "desc";
+}, {
+    attribute: string;
+    direction: "asc" | "desc";
+}>;
+
+/**
+ * A LayerFeature is a single geographical item in a layer.
+ *
+ * It is intended to be a lightweight object that contains the properties of a
+ * feature, but not the geometry. It is returned by methods like
+ * {@link FeltController.getRenderedFeatures} and {@link FeltController.getFeature},
+ * and as part of the methods in the {@link SelectionController}
+ *
+ * The geometry can be obtained via the {@link FeltController.getGeoJsonFeature}
+ * method, which returns a {@link GeoJsonFeature} object.
+ */
+interface LayerFeature {
+    /**
+     * The identifier of the feature, unique within the layer.
+     */
+    id: string | number;
+    /**
+     * The identifier of the layer that the feature belongs to.
+     */
+    layerId: string;
+    /**
+     * The type of geometry of the feature.
+     *
+     * @remarks Because LayerFeatures are read from tiled features, it's
+     * possible that this `geometryType` won't match the `geometry.type` of the
+     * {@link GeoJsonFeature} returned by {@link FeltController.getGeoJsonFeature}.
+     *
+     * For example, this may return `LineString` but the full feature is a `MultiLineString`,
+     * or, similarly `Polygon` here may be a `MultiPolygon` in the full feature.
+     *
+     * As a result, you should treat this property as being indicative only.
+     */
+    geometryType: GeoJsonGeometry["type"] | (string & {});
+    /**
+     * The properties of the feature, as a bag of attributes.
+     */
+    properties: GeoJsonProperties;
+}
+/**
+ * A raster pixel value for a specific layer.
+ *
+ * @interface
+ */
+type RasterValue = {
+    /**
+     * The value of the pixel.
+     */
+    value: number;
+    /**
+     * The ID of the layer that the pixel belongs to.
+     */
+    layerId: string;
+    /**
+     * The name of the category that the pixel belongs to.
+     */
+    categoryName: null | string;
+    /**
+     * The color of the pixel. Each value is between 0 and 255.
+     */
+    color: null | {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+};
+
+/**
+ * This describes the processing status of a layer.
+ *
+ * The various values are:
+ * - `processing`: The layer has been uploaded or updated and is still processing.
+ * - `completed`: The layer has been processed and can be viewed on the map.
+ * - `failed`: The layer failed to process and cannot be viewed on the map.
+ * - `incomplete`: The layer has not been processed.
+ *
+ * @group Layers
+ */
+type LayerProcessingStatus = z.infer<typeof LayerProcessingStatusSchema>;
+declare const LayerProcessingStatusSchema: z.ZodEnum<["processing", "completed", "failed", "incomplete"]>;
+/**
+ * @group Layers
+ */
+interface Layer {
+    /**
+     * The string identifying the layer
+     */
+    id: string;
+    /**
+     * The ID of the layer group that the layer belongs to.
+     *
+     * Layers that appear at the root level in Felt will not have a group ID.
+     */
+    groupId: string | null;
+    /**
+     * The name of the layer can be displayed in the Legend, depending
+     * on how the layer's legend is configured in its style.
+     */
+    name: string;
+    /**
+     * The layer's caption is shown in the legend.
+     */
+    caption: string | null;
+    /**
+     * The layer description forms part of the layer's metadata. This is visible
+     * to users via the layer info button in the legend.
+     */
+    description: string | null;
+    /**
+     * Whether the layer is visible or not.
+     */
+    visible: boolean;
+    /**
+     * Whether the layer is shown in the legend or not.
+     */
+    shownInLegend: boolean;
+    /**
+     * The FSL style for the layer.
+     *
+     * See the [FSL documentation](https://developers.felt.com/felt-style-language) for details
+     * on how to read and write styles.
+     *
+     * As the types of the styles are very complex, we return `object` here and advise that you
+     * program defensively while reading the styles.
+     */
+    style: object;
+    /**
+     * The current processing status of the layer.
+     */
+    status: LayerProcessingStatus;
+    /**
+     * The geometry type of the layer.
+     *
+     * @remarks
+     * This will generally be one of:
+     * - `"Point"`
+     * - `"Line"`
+     * - `"Polygon"`
+     * - `"Raster"`
+     * - `null`
+     *
+     * When the layer is processing, or it is a data-only layer, it will be null. You should
+     * expect this to be able to be any string, however, as more geometry types can be added
+     * in the future.
+     */
+    geometryType: string | null;
+    /**
+     * The bounding box of the layer. If the layer is processing, or the bounds have otherwise
+     * not been calculated or are not available, this will be `null`.
+     *
+     * {@link FeltBoundary}
+     */
+    bounds: FeltBoundary | null;
+}
+/**
+ * @group Layer Groups
+ */
+interface LayerGroup {
+    /**
+     * A string identifying the layer group.
+     */
+    id: string;
+    /**
+     * The name of the layer group. This is shown in the legend.
+     */
+    name: string;
+    /**
+     * The caption of the layer group. This is shown in the legend.
+     */
+    caption: string | null;
+    /**
+     * The ids of the layers in the layer group.
+     *
+     * @remarks
+     * You can use these ids to get the full layer objects via the `getLayers` method.
+     */
+    layerIds: Array<string>;
+    /**
+     * Whether the layer group is visible or not.
+     */
+    visible: boolean;
+    /**
+     * Whether the layer group is shown in the legend or not.
+     */
+    shownInLegend: boolean;
+    /**
+     * The bounding box of the layer group.
+     *
+     * {@link FeltBoundary}
+     */
+    bounds: FeltBoundary | null;
+}
+/**
+ * The constraints to apply when getting layers.
+ *
+ * @group Layers
+ */
+interface GetLayersConstraint extends zInfer<typeof GetLayersConstraintSchema> {
+}
+/**
+ * @ignore
+ */
+declare const GetLayersConstraintSchema: z.ZodObject<{
+    /**
+     * The ids of the layers to get.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: string[] | undefined;
+}, {
+    ids?: string[] | undefined;
+}>;
+/**
+ * The constraints to apply when getting layer groups.
+ *
+ * @group Layer Groups
+ */
+interface GetLayerGroupsConstraint extends zInfer<typeof GetLayerGroupsFilterSchema> {
+}
+/**
+ * @ignore
+ */
+declare const GetLayerGroupsFilterSchema: z.ZodObject<{
+    /**
+     * The ids of the layer groups to get.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: string[] | undefined;
+}, {
+    ids?: string[] | undefined;
+}>;
+/**
+ * The parameters for the `onLayerChange` listener.
+ *
+ * @group Layers
+ */
+interface LayerChangeCallbackParams {
+    /**
+     * The new data for the layer or null if the layer was removed.
+     */
+    layer: Layer | null;
+}
+/**
+ * The parameters for the `onLayerGroupChange` listener.
+ *
+ * @group Layer Groups
+ */
+interface LayerGroupChangeCallbackParams {
+    layerGroup: LayerGroup | null;
+}
+/**
+ * A legend item, which often represents a sub-class of features in a
+ * layer in the case of categorical or classed layers.
+ *
+ * @group Legend Items
+ */
+interface LegendItem extends LegendItemIdentifier {
+    /**
+     * The title of the legend item.
+     */
+    title: string | Array<string>;
+    /**
+     * Whether the title depends on the zoom level or not. If it does, you
+     * need to call `getLegendItem` when the zoom level changes.
+     *
+     * Note that as the zoom level changes, the `onLegendItemChange` handler
+     * will not be called, so you need to call `getLegendItem` yourself.
+     */
+    titleDependsOnZoom: boolean;
+    /**
+     * Whether the legend item is visible or not.
+     */
+    visible: boolean;
+}
+/**
+ * The identifier for a legend item. It is a compound key of the layer to
+ * which the legend item belongs and the legend item's own id.
+ *
+ * @group Legend Items
+ */
+interface LegendItemIdentifier extends zInfer<typeof LegendItemIdentifierSchema> {
+}
+/** @ignore */
+declare const LegendItemIdentifierSchema: z.ZodObject<{
+    /**
+     * The id of the legend item.
+     */
+    id: z.ZodString;
+    /**
+     * The id of the layer the legend item belongs to.
+     */
+    layerId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    layerId: string;
+}, {
+    id: string;
+    layerId: string;
+}>;
+/**
+ * Constraints for legend items. If nothing is passed, all legend items will be returned.
+ *
+ * @group Legend Items
+ */
+interface LegendItemsConstraint extends zInfer<typeof LegendItemsConstraintSchema> {
+}
+/** @ignore */
+declare const LegendItemsConstraintSchema: z.ZodObject<{
+    /**
+     * Array of legend item identifiers to constrain by.
+     */
+    ids: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * The id of the legend item.
+         */
+        id: z.ZodString;
+        /**
+         * The id of the layer the legend item belongs to.
+         */
+        layerId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        layerId: string;
+    }, {
+        id: string;
+        layerId: string;
+    }>, "many">>;
+    /**
+     * Array of layer ids to constrain legend items by.
+     */
+    layerIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ids?: {
+        id: string;
+        layerId: string;
+    }[] | undefined;
+    layerIds?: string[] | undefined;
+}, {
+    ids?: {
+        id: string;
+        layerId: string;
+    }[] | undefined;
+    layerIds?: string[] | undefined;
+}>;
+/**
+ * The parameters for the `onLegendItemChange` listener.
+ *
+ * @group Legend Items
+ */
+interface LegendItemChangeCallbackParams {
+    /**
+     * The new data for the legend item or null if the legend item was removed.
+     */
+    legendItem: LegendItem | null;
+}
+/**
+ * Constraints for the `getRenderedFeatures` method. This can include layer constriants, spatial constraints, or both. If no constraints are
+ * provided, all rendered features will be returned.
+ *
+ * @group Layers
+ */
+interface GetRenderedFeaturesConstraint extends zInfer<typeof GetRenderedFeaturesConstraintSchema> {
+    /**
+     * The area to query for rendered features. This can be specific coordinates or a {@link FeltBoundary}. If omitted, the entire viewport will be queried.
+     */
+    areaQuery?: {
+        coordinates: LatLng;
+    } | {
+        boundary: FeltBoundary;
+    };
+}
+/** @ignore */
+declare const GetRenderedFeaturesConstraintSchema: z.ZodObject<{
+    /**
+     * The ids of the layers to get rendered features for.
+     */
+    layerIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    areaQuery: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        coordinates: z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            latitude: number;
+            longitude: number;
+        }, {
+            latitude: number;
+            longitude: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+    }, {
+        coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+    }>, z.ZodObject<{
+        boundary: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, "strip", z.ZodTypeAny, {
+        boundary: [number, number, number, number];
+    }, {
+        boundary: [number, number, number, number];
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    layerIds?: string[] | undefined;
+    areaQuery?: {
+        coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+    } | {
+        boundary: [number, number, number, number];
+    } | undefined;
+}, {
+    layerIds?: string[] | undefined;
+    areaQuery?: {
+        coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+    } | {
+        boundary: [number, number, number, number];
+    } | undefined;
+}>;
+
+/**
+ * @group Filters
+ */
+type FilterLogicGate = z.infer<typeof FilterLogicGateSchema>;
+declare const FilterLogicGateSchema: z.ZodEnum<["and", "or"]>;
+/**
+ * @group Filters
+ */
+type FilterExpression = z.infer<typeof FilterExpressionSchema>;
+declare const FilterExpressionSchema: z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>;
+/**
+ * A `FilterTernary` is a tree structure for combining expressions with logical operators.
+ *
+ * When combining three or more conditions, you must use proper nesting rather than a flat list.
+ *
+ * @example
+ * ```typescript
+ * // A simple filter with a single condition
+ * const filter = [
+ *   ["AREA", "gt", 30_000],
+ *   "and",
+ *   ["COLOR", "eq", "red"]
+ * ]
+ *
+ * // A complex filter with multiple conditions
+ * const filter = [
+ *   ["AREA", "gt", 30_000],
+ *   "and",
+ *   [
+ *     ["COLOR", "eq", "red"],
+ *     "or",
+ *     ["TYPE", "eq", "residential"]
+ *   ]
+ * ]
+ * ```
+ *
+ * @group Filters
+ */
+type FilterTernary = [
+    FilterTernary | FilterExpression | null | boolean,
+    FilterLogicGate,
+    FilterTernary | FilterExpression | null | boolean
+];
+/**
+ *
+ * Filters can be used to change which features in a layer are rendered. Filters can be
+ * applied to a layer by the `setLayerFilters` method on the Felt controller.
+ *
+ * Filters use a tree structure for combining expressions with logical operators, called a
+ * {@link FilterTernary}. When combining three or more conditions, you must use proper nesting
+ * rather than a flat list.
+ *
+ * See the examples below for the correct structure to use when building complex filters.
+ *
+ * @remarks
+ * The possible operators are:
+ * - `lt`: Less than
+ * - `gt`: Greater than
+ * - `le`: Less than or equal to
+ * - `ge`: Greater than or equal to
+ * - `eq`: Equal to
+ * - `ne`: Not equal to
+ * - `cn`: Contains
+ * - `nc`: Does not contain
+ *
+ * The allowed boolean operators are:
+ * - `and`: Logical AND
+ * - `or`: Logical OR
+ *
+ * @example
+ * ```typescript
+ * // 1. Simple filter: single condition
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: ["AREA", "gt", 30_000],
+ * });
+ *
+ * // 2. Basic compound filter: two conditions with AND
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],  // First condition
+ *     "and",                   // Logic operator
+ *     ["COLOR", "eq", "red"]   // Second condition
+ *   ]
+ * });
+ *
+ * // 3. Complex filter: three or more conditions require nesting
+ * // ⚠️ IMPORTANT: Filters use a tree structure, not a flat list
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // First condition
+ *     "and",                                 // First logic operator
+ *     [                                      // Nested group starts
+ *       ["COLOR", "eq", "red"],              //   Second condition
+ *       "and",                               //   Second logic operator
+ *       ["TYPE", "eq", "residential"]        //   Third condition
+ *     ]                                      // Nested group ends
+ *   ]
+ * });
+ *
+ * // 4. Even more complex: four conditions with proper nesting
+ * // Visual structure:
+ * //          AND
+ * //         /   \
+ * //    condition  AND
+ * //              /   \
+ * //        condition  AND
+ * //                  /   \
+ * //            condition  condition
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // First condition
+ *     "and",
+ *     [
+ *       ["COLOR", "eq", "red"],              // Second condition
+ *       "and",
+ *       [
+ *         ["TYPE", "eq", "residential"],     // Third condition
+ *         "and",
+ *         ["YEAR", "gt", 2000]               // Fourth condition
+ *       ]
+ *     ]
+ *   ]
+ * });
+ *
+ * // 5. Mixed operators: combining AND and OR
+ * // Visual structure:
+ * //          AND
+ * //         /   \
+ * //    condition  OR
+ * //              /  \
+ * //        condition condition
+ * felt.setLayerFilters({
+ *   layerId: "layer-1",
+ *   filters: [
+ *     ["AREA", "gt", 30_000],                // Must have large area
+ *     "and",
+ *     [
+ *       ["COLOR", "eq", "red"],              // Must be either red
+ *       "or",
+ *       ["TYPE", "eq", "residential"]        // OR residential type
+ *     ]
+ *   ]
+ * });
+ * ```
+ *
+ * @group Filters
+ */
+type Filters = FilterTernary | FilterExpression | null | boolean;
+/**
+ * The filters that are currently set on a layer.
+ *
+ * A layer's filters are the combination of various different places
+ * in which filters can be applied.
+ *
+ * @group Filters
+ */
+interface LayerFilters {
+    /**
+     * Filters that are set in the layer's style. These are the lowest level
+     * of filters, and can only be set by editing the map.
+     */
+    style: Filters;
+    /**
+     * Filters that are set in the layer's components, which are interactive
+     * elements in the legend. These can be set by viewers for their own session,
+     * but their default value can be set by the map creator.
+     */
+    components: Filters;
+    /**
+     * Filters that are set ephemerally by viewers in their own session.
+     *
+     * These are the filters that are set when the `setLayerFilters` method is
+     * called. There is no way to set these in the Felt UI - they can only be
+     * set using the SDK.
+     */
+    ephemeral: Filters;
+    /**
+     * The combined result of all the filters set on the layer.
+     */
+    combined: Filters;
+}
+
+declare const AggregateMethodSchema: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+declare const AggregationConfigSchema: z.ZodObject<{
+    /**
+     * The operation to use on the values from the features in the layer
+     */
+    method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+    /**
+     * The attribute to use for the aggregation. This must be a numeric attribute.
+     */
+    attribute: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    method: "avg" | "max" | "min" | "sum" | "median";
+}, {
+    attribute: string;
+    method: "avg" | "max" | "min" | "sum" | "median";
+}>;
+declare const MutliAggregationConfigSchema: z.ZodObject<{
+    /**
+     * The operations to use on the values from the features in the layer
+     */
+    methods: z.ZodArray<z.ZodUnion<[z.ZodEnum<["avg", "max", "min", "sum", "median"]>, z.ZodLiteral<"count">]>, "many">;
+    /**
+     * The attribute to use for the aggregation. This must be a numeric attribute.
+     */
+    attribute: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+    attribute?: string | undefined;
+}, {
+    methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+    attribute?: string | undefined;
+}>;
+/**
+ * Defines how to aggregate a value across features in a layer.
+ */
+interface AggregationConfig extends zInfer<typeof AggregationConfigSchema> {
+    /**
+     * The method to use for the aggregation.
+     */
+    method: AggregationMethod;
+}
+/**
+ * The method to use for the aggregation.
+ */
+type AggregationMethod = z.infer<typeof AggregateMethodSchema>;
+/**
+ * Defines how to aggregate a value across features in a layer with multiple aggregations
+ * returned at once.
+ */
+interface MultiAggregationConfig<T extends AggregationMethod | "count"> extends zInfer<typeof MutliAggregationConfigSchema> {
+    methods: T[];
+    /**
+     * The attribute to use for the aggregation when aggregations other than "count" are used.
+     *
+     * This can be omitted if the only aggregation is "count", but must be a numeric attribute
+     * otherwise.
+     */
+    attribute?: string;
+}
+declare const ValueConfigurationSchema: z.ZodObject<{
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    aggregation: z.ZodOptional<z.ZodObject<{
+        /**
+         * The operation to use on the values from the features in the layer
+         */
+        method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+        /**
+         * The attribute to use for the aggregation. This must be a numeric attribute.
+         */
+        attribute: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    }, {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+    aggregation?: {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    } | undefined;
+}, {
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+    aggregation?: {
+        attribute: string;
+        method: "avg" | "max" | "min" | "sum" | "median";
+    } | undefined;
+}>;
+/**
+ * Configuration for filtering and aggregating values across features.
+ *
+ * This can be used to restrict the features considered for aggregation via the `boundary`
+ * and `filters` properties.
+ *
+ * It can also be used to specify how to aggregate the values via the `aggregation` property.
+ */
+interface ValueConfiguration extends zInfer<typeof ValueConfigurationSchema> {
+    /**
+     * A spatial boundary to filter what gets counted or aggregated, while still including
+     * all possible categories or bin ranges in the results.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Attribute filters to determine what gets counted or aggregated, while still including
+     * all possible categories or bin ranges in the results.
+     */
+    filters?: Filters;
+    /**
+     * Specifies how to aggregate values within each category or bin. When omitted,
+     * features are counted. When specified, the chosen calculation (avg, sum, etc.)
+     * is performed on the specified attribute.
+     *
+     * For example, instead of counting buildings in each category, you might want
+     * to sum their square footage or average their assessed values.
+     */
+    aggregation?: AggregationConfig;
+}
+declare const GetLayerCategoriesParamsSchema: z.ZodObject<{
+    /**
+     * The ID of the layer to get categories from.
+     */
+    layerId: z.ZodString;
+    /**
+     * The attribute to use for categorization.
+     */
+    attribute: z.ZodString;
+    /**
+     * The maximum number of categories to return.
+     */
+    limit: z.ZodOptional<z.ZodNumber>;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    values: z.ZodOptional<z.ZodObject<{
+        boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            type: z.ZodLiteral<"Polygon">;
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+        filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+        aggregation: z.ZodOptional<z.ZodObject<{
+            /**
+             * The operation to use on the values from the features in the layer
+             */
+            method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+            /**
+             * The attribute to use for the aggregation. This must be a numeric attribute.
+             */
+            attribute: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }, {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    layerId: string;
+    values?: {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+    limit?: number | undefined;
+}, {
+    attribute: string;
+    layerId: string;
+    values?: {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * The parameters for getting categories from a layer, passed to
+ * the {@link LayersController.getCategoryData} method.
+ */
+interface GetLayerCategoriesParams extends zInfer<typeof GetLayerCategoriesParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Configuration for filtering and aggregating values while preserving the full set of
+     * categories in the results.
+     *
+     * This is particularly useful when you want to compare different subsets of data while
+     * maintaining consistent categories. For example:
+     *
+     * - Show all building types in a city, but only count recent buildings in each type
+     * - Keep all neighborhood categories but only sum up residential square footage
+     *
+     * Unlike top-level filters which affect both what categories appear AND their values,
+     * filters in this configuration only affect the values while keeping all possible
+     * categories in the results.
+     */
+    values?: ValueConfiguration;
+}
+declare const GetLayerCategoriesGroupSchema: z.ZodObject<{
+    /**
+     * The category for which the value was calculated.
+     */
+    key: z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+    /**
+     * The value calculated for the category, whether a count, sum, average, etc.
+     *
+     * `null` is returned if there are no features in the category as opposed to zero,
+     * so as not to confuse with a real zero value from some aggregation.
+     */
+    value: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    value: number | null;
+    key: string | number | boolean;
+}, {
+    value: number | null;
+    key: string | number | boolean;
+}>;
+/**
+ * A single category from the response from the {@link LayersController.getCategoryData} method.
+ */
+interface GetLayerCategoriesGroup extends zInfer<typeof GetLayerCategoriesGroupSchema> {
+}
+declare const GetLayerHistogramParamsSchema: z.ZodObject<{
+    layerId: z.ZodString;
+    attribute: z.ZodString;
+    steps: z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"equal-intervals">;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "equal-intervals";
+        count: number;
+    }, {
+        type: "equal-intervals";
+        count: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"time-interval">;
+        interval: z.ZodEnum<["hour", "day", "week", "month", "year"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    }, {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    }>, z.ZodArray<z.ZodNumber, "many">]>;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    /**
+     * Configuration for filtering and aggregating values while preserving the full set of
+     * bin ranges in the results.
+     *
+     * This is particularly useful when you want to compare different subsets of data while
+     * maintaining consistent ranges. For example:
+     *
+     * - Use the same height ranges for comparing old vs new buildings
+     *
+     * Unlike top-level filters which affect both what ranges appear AND their values,
+     * filters in this configuration only affect the values while keeping all possible
+     * ranges in the results.
+     */
+    values: z.ZodOptional<z.ZodObject<{
+        boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+            type: z.ZodLiteral<"Polygon">;
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }, {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+        filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+        aggregation: z.ZodOptional<z.ZodObject<{
+            /**
+             * The operation to use on the values from the features in the layer
+             */
+            method: z.ZodEnum<["avg", "max", "min", "sum", "median"]>;
+            /**
+             * The attribute to use for the aggregation. This must be a numeric attribute.
+             */
+            attribute: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }, {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }, {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    attribute: string;
+    layerId: string;
+    steps: number[] | {
+        type: "equal-intervals";
+        count: number;
+    } | {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    };
+    values?: {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+}, {
+    attribute: string;
+    layerId: string;
+    steps: number[] | {
+        type: "equal-intervals";
+        count: number;
+    } | {
+        type: "time-interval";
+        interval: "hour" | "day" | "week" | "month" | "year";
+    };
+    values?: {
+        filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+        boundary?: [number, number, number, number] | [number, number][] | {
+            type: "Polygon";
+            coordinates: [number, number][][];
+        } | undefined;
+        aggregation?: {
+            attribute: string;
+            method: "avg" | "max" | "min" | "sum" | "median";
+        } | undefined;
+    } | undefined;
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+}>;
+/**
+ * The params used to request a histogram of values from a layer, passed to
+ * the {@link LayersController.getHistogramData} method.
+ */
+interface GetLayerHistogramParams extends zInfer<typeof GetLayerHistogramParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+}
+declare const GetLayerHistogramBinSchema: z.ZodObject<{
+    /**
+     * The left edge of the bin.
+     */
+    min: z.ZodNumber;
+    /**
+     * The right edge of the bin.
+     */
+    max: z.ZodNumber;
+    /**
+     * The number of features in the bin.
+     */
+    value: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    value: number;
+    max: number;
+    min: number;
+}, {
+    value: number;
+    max: number;
+    min: number;
+}>;
+/**
+ * One bin from the response from the {@link LayersController.getHistogramData} method.
+ */
+interface GetLayerHistogramBin extends zInfer<typeof GetLayerHistogramBinSchema> {
+}
+declare const GetLayerCalculationParamsSchema: z.ZodObject<{
+    /**
+     * The ID of the layer to calculate an aggregate value for.
+     */
+    layerId: z.ZodString;
+    boundary: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        type: z.ZodLiteral<"Polygon">;
+        coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }, {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    }>, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">]>>;
+    filters: z.ZodOptional<z.ZodUnion<[z.ZodType<FilterTernary, z.ZodTypeDef, FilterTernary>, z.ZodUnion<[z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["in", "ni"]>, z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>, "many">, z.ZodNull]>], null>, z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodNull]>, z.ZodEnum<["lt", "gt", "le", "ge", "eq", "ne", "cn", "nc", "is", "isnt"]>, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodNull]>], null>]>, z.ZodNull, z.ZodBoolean]>>;
+    aggregation: z.ZodObject<{
+        /**
+         * The operations to use on the values from the features in the layer
+         */
+        methods: z.ZodArray<z.ZodUnion<[z.ZodEnum<["avg", "max", "min", "sum", "median"]>, z.ZodLiteral<"count">]>, "many">;
+        /**
+         * The attribute to use for the aggregation. This must be a numeric attribute.
+         */
+        attribute: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    }, {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    layerId: string;
+    aggregation: {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    };
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+}, {
+    layerId: string;
+    aggregation: {
+        methods: ("avg" | "max" | "min" | "sum" | "median" | "count")[];
+        attribute?: string | undefined;
+    };
+    filters?: boolean | FilterTernary | [string | null, "in" | "ni", (string | number | boolean | null)[] | null] | [string | null, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", string | number | boolean | null] | null | undefined;
+    boundary?: [number, number, number, number] | [number, number][] | {
+        type: "Polygon";
+        coordinates: [number, number][][];
+    } | undefined;
+}>;
+/**
+ * The parameters for calculating a single aggregate value for a layer, passed to
+ * the {@link LayersController.getAggregates} method.
+ */
+interface GetLayerCalculationParams<T extends AggregationMethod | "count"> extends z.infer<typeof GetLayerCalculationParamsSchema> {
+    /**
+     * Attribute filters to determine what gets counted or aggregated.
+     */
+    filters?: Filters;
+    /**
+     * A spatial boundary to filter what gets counted or aggregated. This can be either
+     * a [w, s, e, n] bounding box, a GeoJSON Polygon geometry, or a list of coordinates
+     * that form a polyline.
+     */
+    boundary?: PolygonGeometry | LngLatTuple[] | FeltBoundary;
+    /**
+     * Specifies how to aggregate values within each category or bin. When omitted,
+     * features are counted. When specified, the chosen calculation (avg, sum, etc.)
+     * is performed on the specified attribute.
+     */
+    aggregation: MultiAggregationConfig<T>;
+}
+
+/**
+ * The event object passed to the interaction listeners.
+ */
+interface MapInteractionEvent {
+    /**
+     * The cursor position in world coordinates.
+     */
+    coordinate: LatLng;
+    /**
+     * The vector features that are under the cursor.
+     */
+    features: Array<LayerFeature>;
+    /**
+     * The raster pixel values that are under the cursor.
+     */
+    rasterValues: Array<RasterValue>;
+}
+
+/**
+ * The details of a map.
+ *
+ * @group Types
+ */
+type MapDetails = {
+    /**
+     * The id of the map.
+     */
+    id: string;
+    /**
+     * The title of the map.
+     */
+    title: string;
+    /**
+     * The description of the map.
+     */
+    description: string | null;
+};
+
+/**
+ * A reference to any kind of entity in the map.
+ *
+ * @remarks
+ * EntityNodes are used when you have some collection of entities and you need to
+ *
+ * @group Entity Node
+ */
+type EntityNode = ElementNode | ElementGroupNode | LayerNode | LayerGroupNode | FeatureNode;
+/**
+ * References an element on the map.
+ *
+ * @interface
+ * @group Entity Nodes
+ */
+type ElementNode = {
+    type: "element";
+    entity: Element;
+};
+/**
+ * References an element group.
+ *
+ * @interface
+ * @group Entity Nodes
+ */
+type ElementGroupNode = {
+    type: "elementGroup";
+    entity: ElementGroup;
+};
+/**
+ * References a layer on the map.
+ *
+ * @interface
+ * @group Entity Nodes
+ */
+type LayerNode = {
+    type: "layer";
+    entity: Layer;
+};
+/**
+ * References a layer group on the map.
+ *
+ * @interface
+ * @group Entity Nodes
+ */
+type LayerGroupNode = {
+    type: "layerGroup";
+    entity: LayerGroup;
+};
+/**
+ * References a feature on the map.
+ *
+ * @interface
+ * @group Entity Nodes
+ */
+type FeatureNode = {
+    type: "feature";
+    entity: LayerFeature;
+};
+/**
+ * The options for selecting a feature in a layer.
+ */
+interface FeatureSelection extends zInfer<typeof FeatureSelectionSchema> {
+}
+/**
+ * @ignore
+ */
+declare const FeatureSelectionSchema: z.ZodObject<{
+    /**
+     * The id of the feature to select.
+     */
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    /**
+     * The id of the layer that the feature belongs to.
+     */
+    layerId: z.ZodString;
+    /**
+     * Whether to show the feature's popup, if it is configured in the layer's style.
+     *
+     * @default true
+     */
+    showPopup: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether to center the view on the feature after selecting it.
+     *
+     * When true, the viewport will be centered on the feature and zoomed to fit the feature
+     * in the viewport. If you need to control the zoom level to prevent it zooming in too
+     * far, you can pass an object with a `maxZoom` property.
+     *
+     * This is useful for avoiding zooming in too far on point features, or if you want
+     * to maintain the current zoom level.
+     *
+     * @default true
+     */
+    fitViewport: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+        maxZoom: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        maxZoom: number;
+    }, {
+        maxZoom: number;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string | number;
+    layerId: string;
+    showPopup?: boolean | undefined;
+    fitViewport?: boolean | {
+        maxZoom: number;
+    } | undefined;
+}, {
+    id: string | number;
+    layerId: string;
+    showPopup?: boolean | undefined;
+    fitViewport?: boolean | {
+        maxZoom: number;
+    } | undefined;
+}>;
+
+declare const ToolSchema: z.ZodEnum<["pin", "line", "route", "polygon", "circle", "marker", "highlighter", "text", "note", "link"]>;
+type ToolType = z.infer<typeof ToolSchema>;
+type ConfigurableToolType = keyof ToolSettingsMap;
+declare const PinToolSettingsSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    color: z.ZodString;
+    frame: z.ZodNullable<z.ZodEnum<["frame-circle", "frame-square"]>>;
+    afterCreation: z.ZodEnum<["enter name", "add another", "select"]>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    color: string;
+    frame: "frame-circle" | "frame-square" | null;
+    afterCreation: "enter name" | "add another" | "select";
+}, {
+    symbol: string;
+    color: string;
+    frame: "frame-circle" | "frame-square" | null;
+    afterCreation: "enter name" | "add another" | "select";
+}>;
+interface PinToolSettings extends zInfer<typeof PinToolSettingsSchema> {
+    symbol: PlaceSymbol;
+    /**
+     * What to do after creating the Place element.
+     *
+     * - `"enter name"`: Enter a name for the Place, focusing the name input.
+     * - `"add another"`: Add another Place, leaving the tool still selected.
+     * - `"none"`: Puts the tool down and selects the new Place element.
+     *
+     * @defaultValue `"enter name"`
+     */
+    afterCreation: "enter name" | "add another" | "select";
+}
+declare const LineToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+    distanceMarker: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+}, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+}>;
+interface LineToolSettings extends zInfer<typeof LineToolSettingsSchema> {
+}
+declare const RouteToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+    distanceMarker: z.ZodBoolean;
+    endCaps: z.ZodBoolean;
+    routingMode: z.ZodNullable<z.ZodEnum<["driving", "cycling", "walking", "flying"]>>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+    endCaps: boolean;
+    routingMode: "driving" | "cycling" | "walking" | "flying" | null;
+}, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    distanceMarker: boolean;
+    endCaps: boolean;
+    routingMode: "driving" | "cycling" | "walking" | "flying" | null;
+}>;
+interface RouteToolSettings extends zInfer<typeof RouteToolSettingsSchema> {
+}
+declare const PolygonToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+    fillOpacity: z.ZodNumber;
+    areaMarker: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    areaMarker: boolean;
+}, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    areaMarker: boolean;
+}>;
+interface PolygonToolSettings extends zInfer<typeof PolygonToolSettingsSchema> {
+}
+declare const CircleToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    strokeOpacity: z.ZodNumber;
+    strokeWidth: z.ZodNumber;
+    strokeStyle: z.ZodEnum<["solid", "dashed", "dotted"]>;
+    fillOpacity: z.ZodNumber;
+    radiusMarker: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    radiusMarker: boolean;
+}, {
+    color: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeStyle: "solid" | "dashed" | "dotted";
+    fillOpacity: number;
+    radiusMarker: boolean;
+}>;
+interface CircleToolSettings extends zInfer<typeof CircleToolSettingsSchema> {
+}
+declare const MarkerToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    opacity: z.ZodNumber;
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    opacity: number;
+    size: number;
+}, {
+    color: string;
+    opacity: number;
+    size: number;
+}>;
+interface MarkerToolSettings extends zInfer<typeof MarkerToolSettingsSchema> {
+}
+declare const HighlighterToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    opacity: z.ZodNumber;
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    opacity: number;
+    size: number;
+}, {
+    color: string;
+    opacity: number;
+    size: number;
+}>;
+interface HighlighterToolSettings extends zInfer<typeof HighlighterToolSettingsSchema> {
+}
+declare const TextToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    align: z.ZodEnum<["left", "center", "right"]>;
+    style: z.ZodEnum<["italic", "light", "regular", "caps"]>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+}, {
+    color: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+}>;
+interface TextToolSettings extends zInfer<typeof TextToolSettingsSchema> {
+}
+declare const NoteToolSettingsSchema: z.ZodObject<{
+    color: z.ZodString;
+    align: z.ZodEnum<["left", "center", "right"]>;
+    style: z.ZodEnum<["italic", "light", "regular", "caps"]>;
+}, "strip", z.ZodTypeAny, {
+    color: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+}, {
+    color: string;
+    align: "left" | "center" | "right";
+    style: "italic" | "light" | "regular" | "caps";
+}>;
+interface NoteToolSettings extends zInfer<typeof NoteToolSettingsSchema> {
+}
+/**
+ * The parameters for changing the settings of each tool.
+ */
+type InputToolSettings = ({
+    tool: "pin";
+} & Partial<PinToolSettings>) | ({
+    tool: "line";
+} & Partial<LineToolSettings>) | ({
+    tool: "route";
+} & Partial<RouteToolSettings>) | ({
+    tool: "polygon";
+} & Partial<PolygonToolSettings>) | ({
+    tool: "circle";
+} & Partial<CircleToolSettings>) | ({
+    tool: "marker";
+} & Partial<MarkerToolSettings>) | ({
+    tool: "highlighter";
+} & Partial<HighlighterToolSettings>) | ({
+    tool: "text";
+} & Partial<TextToolSettings>) | ({
+    tool: "note";
+} & Partial<NoteToolSettings>);
+/**
+ * The result of listening for changes to the settings of each tool.
+ */
+type ToolSettingsChangeEvent = ({
+    tool: "pin";
+} & PinToolSettings) | ({
+    tool: "line";
+} & LineToolSettings) | ({
+    tool: "route";
+} & RouteToolSettings) | ({
+    tool: "polygon";
+} & PolygonToolSettings) | ({
+    tool: "circle";
+} & CircleToolSettings) | ({
+    tool: "marker";
+} & MarkerToolSettings) | ({
+    tool: "highlighter";
+} & HighlighterToolSettings) | ({
+    tool: "text";
+} & TextToolSettings) | ({
+    tool: "note";
+} & NoteToolSettings);
+type ToolSettingsMap = {
+    pin: PinToolSettings;
+    line: LineToolSettings;
+    route: RouteToolSettings;
+    polygon: PolygonToolSettings;
+    circle: CircleToolSettings;
+    marker: MarkerToolSettings;
+    highlighter: HighlighterToolSettings;
+    text: TextToolSettings;
+    note: NoteToolSettings;
+};
+type PlaceFrame = "frame-circle" | "frame-square" | null;
+type PlaceSymbol = "dot" | "square" | "diamond" | "triangle" | "x" | "plus" | "circle-line" | "circle-slash" | "star" | "heart" | "hexagon" | "octagon" | "pedestrian" | "bicycle" | "wheelchair" | "airport" | "car" | "bus" | "train" | "truck" | "ferry" | "sailboat" | "electric-service" | "gas-service" | "blood-clinic" | "badge" | "traffic-light" | "traffic-cone" | "road-sign-caution" | "person" | "restroom" | "house" | "work" | "letter" | "hotel" | "factory" | "hospital" | "religious-facility" | "school" | "government" | "university" | "bank" | "landmark" | "museum" | "clothing" | "shopping" | "store" | "bar" | "pub" | "cafe" | "food" | "park" | "amusement-park" | "camping-tent" | "cabin" | "picnic" | "water-refill" | "trailhead" | "guidepost" | "viewpoint" | "camera" | "us-football" | "football" | "tennis" | "binoculars" | "swimming" | "zap" | "battery-full" | "battery-half" | "battery-low" | "boom" | "radar" | "wind-turbine" | "solar-panel" | "antenna" | "telephone-pole" | "oil-well" | "oil-barrel" | "railroad-track" | "bridge" | "lighthouse" | "lock-closed" | "lock-open" | "wifi" | "trash" | "recycle" | "tree" | "flower" | "leaf" | "fire" | "mountain" | "snowy-mountain" | "volcano" | "island" | "wave" | "hot-springs" | "water" | "lake" | "ocean" | "animal" | "bird" | "duck" | "dog" | "fish" | "beach" | "wetland" | "sun" | "moon" | "cloud" | "partial-sun" | "rain" | "lightning" | "snowflake" | "wind" | "snow" | "fog" | "sleet" | "hurricane" | "warning" | "parking" | "info" | "circle-exclamation" | "circle-triangle" | "circle-x" | "circle-plus" | (`:${string}:` & {});
+
+/**
+ * The input type for setting the viewport to a particular center and zoom.
+ *
+ * @group Types
+ */
+interface ViewportCenterZoom extends zInfer<typeof ViewportCenterZoomSchema> {
+    /**
+     * The center of the viewport in latitude and longitude.
+     */
+    center: LatLng;
+    /**
+     * The zoom level of the viewport.
+     */
+    zoom: FeltZoom;
+}
+declare const ViewportCenterZoomSchema: z.ZodObject<{
+    center: z.ZodObject<{
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        latitude: number;
+        longitude: number;
+    }, {
+        latitude: number;
+        longitude: number;
+    }>;
+    zoom: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    zoom: number;
+    center: {
+        latitude: number;
+        longitude: number;
+    };
+}, {
+    zoom: number;
+    center: {
+        latitude: number;
+        longitude: number;
+    };
+}>;
+/**
+ * The current state of the viewport, including the derived bounds.
+ *
+ * @group Types
+ */
+interface ViewportState {
+    /**
+     * The center of the viewport in latitude and longitude.
+     *
+     * {@link LatLng}
+     */
+    center: LatLng;
+    /**
+     * The zoom level of the viewport.
+     *
+     * {@link FeltZoom}
+     */
+    zoom: FeltZoom;
+    /**
+     * The bounding box of the viewport.
+     *
+     * This is derived, and depends on the center and zoom of the viewport, as
+     * well as its size.
+     *
+     * {@link FeltBoundary}
+     */
+    bounds: FeltBoundary;
+}
+/**
+ * The parameters for the `setViewport` method.
+ *
+ * @group Types
+ */
+interface SetViewportCenterZoomParams extends zInfer<typeof SetViewportCenterZoomParamsSchema> {
+}
+declare const SetViewportCenterZoomParamsSchema: z.ZodObject<{
+    center: z.ZodOptional<z.ZodObject<{
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        latitude: number;
+        longitude: number;
+    }, {
+        latitude: number;
+        longitude: number;
+    }>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    zoom?: number | undefined;
+    center?: {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+}, {
+    zoom?: number | undefined;
+    center?: {
+        latitude: number;
+        longitude: number;
+    } | undefined;
+}>;
+/**
+ * The constraints for the viewport. Used to ensure that the viewport stays
+ * within certain bounds and zoom levels.
+ *
+ * @group Types
+ */
+interface ViewportConstraints {
+    /**
+     * The minimum zoom level for the viewport.
+     *
+     * {@link FeltZoom}
+     */
+    minZoom: FeltZoom | null;
+    /**
+     * The maximum zoom level for the viewport.
+     *
+     * {@link FeltZoom}
+     */
+    maxZoom: FeltZoom | null;
+    /**
+     * The bounds for the viewport.
+     *
+     * {@link FeltBoundary}
+     */
+    bounds: FeltBoundary | null;
+}
+/**
+ * The parameters for the `fitViewportToBounds` method.
+ *
+ * @group Types
+ */
+interface ViewportFitBoundsParams extends zInfer<typeof ViewportFitBoundsParamsSchema> {
+    /**
+     * The bounds to fit the viewport to.
+     *
+     * {@link FeltBoundary}
+     */
+    bounds: FeltBoundary;
+}
+declare const ViewportFitBoundsParamsSchema: z.ZodObject<{
+    bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, "strip", z.ZodTypeAny, {
+    bounds: [number, number, number, number];
+}, {
+    bounds: [number, number, number, number];
+}>;
+
+export type { ImageElementCreate as $, AggregationMethod as A, EntityNode as B, FeatureSelection as C, ConfigurableToolType as D, Element as E, Filters as F, GeoJsonGeometry as G, ToolSettingsMap as H, InputToolSettings as I, ToolSettingsChangeEvent as J, zInfer as K, Layer as L, MapInteractionEvent as M, SortConfig as N, SetViewportCenterZoomParams as O, ViewportConstraints as P, ViewportFitBoundsParams as Q, ViewportCenterZoom as R, SetVisibilityRequest as S, ToolType as T, CircleElementCreate as U, ViewportState as V, CircleElementRead as W, CircleElementUpdate as X, HighlighterElementCreate as Y, HighlighterElementRead as Z, HighlighterElementUpdate as _, GetElementsConstraint as a, ImageElementRead as a0, ImageElementUpdate as a1, LinkElementRead as a2, MarkerElementCreate as a3, MarkerElementRead as a4, MarkerElementUpdate as a5, NoteElementCreate as a6, NoteElementRead as a7, NoteElementUpdate as a8, PathElementCreate as a9, GeoJsonProperties as aA, LatLng as aB, LineStringGeometry as aC, LngLatTuple as aD, MultiLineStringGeometry as aE, MultiPointGeometry as aF, MultiPolygonGeometry as aG, PointGeometry as aH, PolygonGeometry as aI, SortDirection as aJ, CircleToolSettings as aK, HighlighterToolSettings as aL, LineToolSettings as aM, MarkerToolSettings as aN, NoteToolSettings as aO, PinToolSettings as aP, PlaceFrame as aQ, PlaceSymbol as aR, PolygonToolSettings as aS, RouteToolSettings as aT, TextToolSettings as aU, UnionToIntersection as aV, PromiseOrNot as aW, PathElementRead as aa, PathElementUpdate as ab, PlaceElementCreate as ac, PlaceElementRead as ad, PlaceElementUpdate as ae, PolygonElementCreate as af, PolygonElementRead as ag, PolygonElementUpdate as ah, TextElementCreate as ai, TextElementRead as aj, TextElementUpdate as ak, LayerProcessingStatus as al, RasterValue as am, FilterExpression as an, FilterLogicGate as ao, FilterTernary as ap, AggregationConfig as aq, MultiAggregationConfig as ar, ValueConfiguration as as, ElementGroupNode as at, ElementNode as au, FeatureNode as av, LayerGroupNode as aw, LayerNode as ax, FeltBoundary as ay, FeltZoom as az, ElementGroup as b, GetElementGroupsConstraint as c, ElementChangeCallbackParams as d, ElementGroupChangeCallbackParams as e, ElementCreate as f, ElementUpdate as g, GetLayersConstraint as h, LayerChangeCallbackParams as i, LayerGroup as j, GetLayerGroupsConstraint as k, LayerGroupChangeCallbackParams as l, LegendItemIdentifier as m, LegendItem as n, LegendItemsConstraint as o, LegendItemChangeCallbackParams as p, LayerFilters as q, GetRenderedFeaturesConstraint as r, LayerFeature as s, GeoJsonFeature as t, GetLayerCategoriesParams as u, GetLayerCategoriesGroup as v, GetLayerHistogramParams as w, GetLayerHistogramBin as x, GetLayerCalculationParams as y, MapDetails as z };