@carto/api-client 0.5.0-alpha.1 → 0.5.0-alpha.13

package/build/api-client.d.cts

@@ -0,0 +1,1399 @@
+import { Polygon, MultiPolygon, Feature, BBox, FeatureCollection, Geometry } from 'geojson';
+import { BinaryFeatureCollection, BinaryFeature } from '@loaders.gl/schema';
+
+/**
+ * Returns current client ID, used to categorize API requests. For internal use only.
+ *
+ * @internal
+ * @privateRemarks Source: @carto/react-core
+ */
+declare function getClient(): string;
+/**
+ * Sets current client ID, used to categorize API requests. For internal use only.
+ *
+ * @internal
+ * @privateRemarks Source: @carto/react-core
+ */
+declare function setClient(c: string): void;
+
+/**
+ * Defines a comparator used when matching a column's values against given filter values.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { FilterType } from '@carto/api-client';
+ * const filters = {
+ *   column_name: { [FilterType.IN]: { values: ['a', 'b', 'c'] } }
+ * };
+ * ```
+ *
+ * @privateRemarks Source: @carto/react-api, @deck.gl/carto
+ */
+declare enum FilterType {
+    IN = "in",
+    /** [a, b] both are included. */
+    BETWEEN = "between",
+    /** [a, b) a is included, b is not. */
+    CLOSED_OPEN = "closed_open",
+    TIME = "time",
+    STRING_SEARCH = "stringSearch"
+}
+/** @privateRemarks Source: @carto/constants */
+declare enum ApiVersion {
+    V1 = "v1",
+    V2 = "v2",
+    V3 = "v3"
+}
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
+declare const DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
+/** @privateRemarks Source: @carto/react-core */
+declare enum TileFormat {
+    MVT = "mvt",
+    JSON = "json",
+    GEOJSON = "geojson",
+    BINARY = "binary"
+}
+/** @privateRemarks Source: @carto/react-core */
+declare enum SpatialIndex {
+    H3 = "h3",
+    S2 = "s2",
+    QUADBIN = "quadbin"
+}
+/** @privateRemarks Source: @carto/react-core */
+declare enum Provider {
+    BIGQUERY = "bigquery",
+    REDSHIFT = "redshift",
+    POSTGRES = "postgres",
+    SNOWFLAKE = "snowflake",
+    DATABRICKS = "databricks",
+    DATABRICKS_REST = "databricksRest"
+}
+
+/******************************************************************************
+ * MAPS AND TILES
+ */
+/** @privateRemarks Source: @deck.gl/carto */
+type Format = 'json' | 'geojson' | 'tilejson';
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
+type MapType = 'boundary' | 'query' | 'table' | 'tileset' | 'raster';
+/**
+ * Alias for GeoJSON 'BBox' type, semantically representing a viewport.
+ * Order of values is "west", "south", "east", "north".
+ */
+type Viewport = [number, number, number, number];
+/**
+ * Subset of deck.gl's Tile2DHeader type, containing only the properties
+ * required for local widget calculations. Deeper dependencies on deck.gl
+ * APIs should be minimized within this library: @deck.gl/carto depends
+ * on the API client, not the other way around.
+ * @privateRemarks Source: @deck.gl/geo-layers
+ */
+type Tile = {
+    index: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    id: string;
+    content: unknown;
+    zoom: number;
+    bbox: {
+        west: number;
+        east: number;
+        north: number;
+        south: number;
+    };
+    isVisible: boolean;
+    data?: BinaryFeatureCollection;
+};
+/** Subset of deck.gl's Tile2DHeader type, for spatial indexes. */
+type SpatialIndexTile = Tile & {
+    data?: (Feature & {
+        id: bigint;
+    })[];
+};
+/** @privateRemarks Source: @deck.gl/carto */
+type Raster = {
+    blockSize: number;
+    cells: {
+        numericProps: BinaryFeature['numericProps'];
+        properties: BinaryFeature['properties'];
+    };
+};
+/******************************************************************************
+ * AGGREGATION
+ */
+/**
+ * Enum for the different types of aggregations available for widgets.
+ *
+ * @privateRemarks Source: @carto/constants
+ * @privateRemarks Converted from enum to type union, for improved declarative API.
+ */
+type AggregationType = 'count' | 'avg' | 'min' | 'max' | 'sum' | 'custom';
+/******************************************************************************
+ * FILTERS
+ */
+/** @privateRemarks Source: @carto/react-api */
+type SpatialFilter = Polygon | MultiPolygon;
+/** @privateRemarks Source: @deck.gl/carto */
+interface Filters {
+    [column: string]: Filter;
+}
+/** @privateRemarks Source: @carto/react-api, @deck.gl/carto */
+interface Filter {
+    [FilterType.IN]?: {
+        owner?: string;
+        values: number[] | string[];
+    };
+    /** [a, b] both are included. */
+    [FilterType.BETWEEN]?: {
+        owner?: string;
+        values: number[][];
+    };
+    /** [a, b) a is included, b is not. */
+    [FilterType.CLOSED_OPEN]?: {
+        owner?: string;
+        values: number[][];
+    };
+    [FilterType.TIME]?: {
+        owner?: string;
+        values: number[][];
+    };
+    [FilterType.STRING_SEARCH]?: {
+        owner?: string;
+        values: string[];
+        params?: StringSearchOptions;
+    };
+}
+/** @privateRemarks Source: @carto/react-core */
+type FilterLogicalOperator = 'and' | 'or';
+/**
+ * Type for minimum or maximum value of an interval. Values 'null' and
+ * 'undefined' are intentionally allowed, and represent an unbounded value.
+ */
+type FilterIntervalExtremum = number | null | undefined;
+type FilterInterval = [FilterIntervalExtremum, FilterIntervalExtremum];
+type FilterIntervalComplete = [number, number];
+type StringSearchOptions = {
+    useRegExp?: boolean;
+    mustStart?: boolean;
+    mustEnd?: boolean;
+    caseSensitive?: boolean;
+    keepSpecialCharacters?: boolean;
+};
+/******************************************************************************
+ * GROUPING
+ */
+/**
+ * Defines a step size increment for use with {@link TimeSeriesRequestOptions}.
+ *
+ * @privateRemarks Source: @carto/react-core
+ */
+type GroupDateType = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
+/******************************************************************************
+ * SORTING
+ */
+type SortDirection = 'asc' | 'desc';
+type SortColumnType = 'number' | 'string' | 'date';
+/******************************************************************************
+ * SQL QUERY PARAMETERS
+ */
+/** @privateRemarks Source: @deck.gl/carto */
+type QueryParameterValue = string | number | boolean | Array<QueryParameterValue> | object;
+/** @privateRemarks Source: @deck.gl/carto */
+type NamedQueryParameter = Record<string, QueryParameterValue>;
+/** @privateRemarks Source: @deck.gl/carto */
+type PositionalQueryParameter = QueryParameterValue[];
+/** @privateRemarks Source: @deck.gl/carto */
+type QueryParameters = NamedQueryParameter | PositionalQueryParameter;
+
+/******************************************************************************
+ * COMMON
+ */
+
+/******************************************************************************
+ * LOCAL CALCULATIONS
+ */
+type FeatureData = Record<string, unknown>;
+
+/** @experimental Prefer type definition from deck.gl. */
+type _DataFilterExtensionProps = {
+    filterRange: number[][];
+    updateTriggers: Record<string, string>;
+    getFilterValue: (feature: Feature | FeatureData) => number[];
+};
+/**
+ * Creates props for DataFilterExtension, from `@deck.gl/extensions`, given
+ * a set of filters. Requires that DataFilterExtension is initialized with
+ * filterSize=4, where the CARTO filters will occupy the first two slots.
+ *
+ * @example To create a deck.gl layer with GPU data filtering:
+ * ```typescript
+ * import {DataFilterExtension} from '@deck.gl/extensions';
+ * import {VectorTileLayer} from '@deck.gl/layers';
+ * import {getDataFilterExtensionProps} from '@carto/api-client';
+ *
+ * const layer = new VectorTileLayer({
+ *  data: data,
+ *  extensions: [new DataFilterExtension({filterSize: 4})],
+ *  ...getDataFilterExtensionProps(filters),
+ * });
+ * ```
+ */
+declare function getDataFilterExtensionProps(filters: Filters, filtersLogicalOperator?: FilterLogicalOperator): _DataFilterExtensionProps;
+
+type FilterTypeOptions<T extends FilterType> = {
+    type: T;
+    column: string;
+} & Filter[T];
+type AddFilterOptions = FilterTypeOptions<FilterType.IN> | FilterTypeOptions<FilterType.BETWEEN> | FilterTypeOptions<FilterType.CLOSED_OPEN> | FilterTypeOptions<FilterType.TIME> | FilterTypeOptions<FilterType.STRING_SEARCH>;
+/**
+ * Adds a {@link Filter} to the filter set. Any previous filters with the same
+ * `column` and `type` will be replaced.
+ */
+declare function addFilter(filters: Record<string, Filter>, { column, type, values, owner }: AddFilterOptions): Record<string, Filter>;
+type RemoveFilterOptions = {
+    column: string;
+    owner?: string;
+};
+/**
+ * Removes one or more {@link Filter filters} from the filter set. If only
+ * `column` is specified, then all filters on that column are removed. If both
+ * `column` and `owner` are specified, then only filters for that column
+ * associated with the owner are removed.
+ */
+declare function removeFilter(filters: Record<string, Filter>, { column, owner }: RemoveFilterOptions): Record<string, Filter>;
+/**
+ * Clears all {@link Filter filters} from the filter set.
+ */
+declare function clearFilters(filters: Record<string, Filter>): Record<string, Filter>;
+type HasFilterOptions = {
+    column: string;
+    owner?: string;
+};
+declare function hasFilter(filters: Record<string, Filter>, { column, owner }: HasFilterOptions): boolean;
+type GetFilterOptions<T extends FilterType> = {
+    column: string;
+    type: T;
+    owner?: string;
+};
+declare function getFilter<T extends FilterType>(filters: Record<string, Filter>, { column, type, owner }: GetFilterOptions<T>): Filter[T] | null;
+
+/**
+ * Returns a {@link SpatialFilter} for a given viewport, typically obtained
+ * from deck.gl's `viewport.getBounds()` method ([west, south, east, north]).
+ * If the viewport covers the entire world (to some margin of error in Web
+ * Mercator space), `undefined` is returned instead.
+ *
+ * If the viewport extends beyond longitude range [-180, +180], the polygon
+ * may be reformatted for compatibility with CARTO APIs.
+ */
+declare function createViewportSpatialFilter(viewport: BBox): SpatialFilter | undefined;
+/**
+ * Returns a {@link SpatialFilter} for a given {@link Polygon} or
+ * {@link MultiPolygon}. If the polygon(s) extend outside longitude
+ * range [-180, +180], the result may be reformatted for compatibility
+ * with CARTO APIs.
+ */
+declare function createPolygonSpatialFilter(spatialFilter: Polygon | MultiPolygon): SpatialFilter | undefined;
+
+type SourceRequiredOptions = {
+    /** Carto platform access token. */
+    accessToken: string;
+    /** Data warehouse connection name in Carto platform. */
+    connectionName: string;
+};
+type SourceOptionalOptions = {
+    /**
+     * Base URL of the CARTO Maps API.
+     *
+     * Example for account located in EU-west region: `https://gcp-eu-west1.api.carto.com`
+     *
+     * @default https://gcp-us-east1.api.carto.com
+     */
+    apiBaseUrl: string;
+    /**
+     * Custom HTTP headers added to map instantiation and data requests.
+     */
+    headers: Record<string, string>;
+    /**
+     * Cache buster value returned by map instantiation.
+     *
+     * Carto source saves `cache` value of map instantiation response in `cache.value`, so it can be used to
+     * check if underlying map data has changed between distinct source requests.
+     */
+    cache?: {
+        value?: number;
+    };
+    clientId: string;
+    /** @deprecated  use `query` instead **/
+    format: Format;
+    /**
+     * Maximum URL character length. Above this limit, requests use POST.
+     * Used to avoid browser and CDN limits.
+     * @default {@link DEFAULT_MAX_LENGTH_URL}
+     */
+    maxLengthURL?: number;
+    /**
+     * The column name and the type of geospatial support.
+     *
+     * If not present, defaults to `'geom'` for generic queries, `'quadbin'` for Quadbin sources and `'h3'` for H3 sources.
+     */
+    spatialDataColumn?: string;
+    /**
+     * The type of geospatial support. Defaults to `'geo'`.
+     */
+    spatialDataType?: SpatialDataType;
+    /**
+     * Relative resolution of a tile. Higher values increase density and data size. At `tileResolution = 1`, tile geometry is
+     * quantized to a 1024x1024 grid. Increasing or decreasing the resolution will increase or decrease the dimensions of
+     * the quantization grid proportionately.
+     *
+     * Supported `tileResolution` values, with corresponding grid sizes:
+     *
+     * - 0.25: 256x256
+     * - 0.5: 512x512
+     * - 1: 1024x1024
+     * - 2: 2048x2048
+     * - 4: 4096x4096
+     */
+    tileResolution?: TileResolution;
+    /**
+     * By default, local in-memory caching is enabled.
+     */
+    localCache?: LocalCacheOptions;
+};
+type LocalCacheOptions = {
+    /**
+     * Map that stores requests and their responses.
+     */
+    cache?: Map<string, Promise<unknown>>;
+    /**
+     * Cache control
+     *  * `no-cache`: If present, the source will always fetch from original source.
+     *  * `no-store`: If present, source will not store result in cache (for later reuse).
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#directives
+     */
+    cacheControl?: ('no-cache' | 'no-store')[];
+};
+type SourceOptions = SourceRequiredOptions & Partial<SourceOptionalOptions>;
+type AggregationOptions = {
+    /**
+     * Defines the aggregation expressions that will be calculated from the resulting columns on each grid cell.
+     *
+     * Example:
+     *
+     *     sum(pop) as total_population, avg(rev) as average_revenue
+     */
+    aggregationExp: string;
+    /**
+     * Defines the tile aggregation resolution.
+     *
+     * @default 6 for quadbin and 4 for h3 sources
+     */
+    aggregationResLevel?: number;
+    /**
+     * Original resolution of the spatial index data as stored in the DW
+     */
+    dataResolution?: number;
+};
+type FilterOptions = {
+    /**
+     * Filters to apply to the data source on the server
+     */
+    filters?: Filters;
+};
+type QuerySourceOptions = {
+    /** Full SQL query with query paremeter placeholders (if any). */
+    sqlQuery: string;
+    /**
+     * Values for named or positional paramteres in the query.
+     *
+     * The way query parameters are determined by data warehouse.
+     *
+     *  * BigQuery has named query parameters, specified with a dictionary, and referenced by key (`@key`)
+     *
+     *     ```
+     *     sqlQuery: "SELECT * FROM carto-demo-data.demo_tables.retail_stores WHERE storetype = ⁣@type AND revenue > ⁣@minRevenue"
+     *     queryParameters: { type: 'Supermarket', minRevenue: 1000000 }
+     *     ```
+     * * Snowflake supports positional parameters, in the form `:1`, `:2`, etc.
+     *
+     *     ```
+     *     sqlQuery: "SELECT * FROM demo_db.public.import_retail_stores WHERE storetype = :2 AND revenue > :1
+     *     queryParameters: [100000, "Supermarket"]
+     *     ```
+     * * Postgres and Redhisft supports positional parameters, but in the form `$1`, `$2`, etc.
+     *
+     *     ```
+     *     sqlQuery: "SELECT * FROM carto_demo_data.demo_tables.retail_stores WHERE storetype = $2 AND revenue > $1
+     *     queryParameters: [100000, "Supermarket"]
+     *     ```
+     */
+    queryParameters?: QueryParameters;
+    /**
+     * Comma-separated aggregation expressions. If assigned on a vector source, source is grouped by geometry and then aggregated.
+     *
+     * Example:
+     *
+     *     1 as value, avg(rev) as average_revenue
+     */
+    aggregationExp?: string;
+};
+type TableSourceOptions = {
+    /**
+     * Fully qualified name of table.
+     */
+    tableName: string;
+    /**
+     * Comma-separated aggregation expressions. If assigned on a vector source, source is grouped by geometry and then aggregated.
+     *
+     * Example:
+     *
+     *     1 as value, avg(rev) as average_revenue
+     */
+    aggregationExp?: string;
+};
+type TilesetSourceOptions = {
+    /**
+     * Fully qualified name of tileset.
+     */
+    tableName: string;
+    /**
+     * Whether to use Web Workers for local widget calculations. Workers
+     * are used by default if the runtime environment supports ES Module Workers.
+     */
+    widgetWorker?: boolean;
+};
+type ColumnsOption = {
+    /**
+     * Columns to retrieve from the table.
+     *
+     * If not present, all columns are returned.
+     */
+    columns?: string[];
+};
+type SpatialDataType = 'geo' | 'h3' | 'quadbin';
+/**
+ * Strategy used for covering spatial filter geometry with spatial indexes.
+ * See https://docs.carto.com/data-and-analysis/analytics-toolbox-for-bigquery/sql-reference/quadbin#quadbin_polyfill_mode
+ * or https://docs.carto.com/data-and-analysis/analytics-toolbox-for-bigquery/sql-reference/h3#h3_polyfill_mode for more information.
+ * @privateRemarks Source: cloud-native maps-api
+ * */
+type SpatialFilterPolyfillMode = 'center' | 'intersects' | 'contains';
+type TileResolution = 0.25 | 0.5 | 1 | 2 | 4;
+interface Tilejson {
+    tilejson: string;
+    name: string;
+    description: string;
+    version: string;
+    attribution: string;
+    scheme: string;
+    tiles: string[];
+    minzoom: number;
+    maxzoom: number;
+    bounds: [left: number, bottom: number, right: number, top: number];
+    center: [longitute: number, latitude: number, zoom: number];
+    vector_layers: VectorLayer[];
+    minresolution: number;
+    maxresolution: number;
+    properties_tiles: string[];
+    tilestats: Tilestats;
+    tileResolution?: TileResolution;
+    /**
+     * Resolution of data in spatial-index dataset (e.g. H3, Quadbin).
+     *
+     * @internal
+     */
+    dataresolution?: number;
+    /**
+     * Array of ratios of dropped features per zoom level.
+     *
+     * Example: `[0,0,0.5]` - means that 50% of features are dropped at zoom 2 and bigger.
+     *
+     * @internal
+     */
+    fraction_dropped_per_zoom?: number[];
+    /**
+     * Names of bands - rasters only.
+     *
+     * @internal
+     */
+    raster_bands?: string[];
+    /**
+     * Raster metadata - rasters only.
+     *
+     * @internal
+     */
+    raster_metadata?: RasterMetadata;
+}
+interface Tilestats {
+    layerCount: number;
+    layers: Layer[];
+}
+interface Layer {
+    layer: string;
+    count: number;
+    attributeCount: number;
+    attributes: Attribute[];
+}
+interface Attribute {
+    attribute: string;
+    type: string;
+}
+interface VectorLayer {
+    id: string;
+    minzoom: number;
+    maxzoom: number;
+    fields: Record<string, string>;
+    geometry_type?: string;
+}
+type RasterMetadataBandStats = {
+    approximated_stats?: boolean;
+    min: number;
+    max: number;
+    mean: number;
+    stddev: number;
+    sum: number;
+    sum_squares: number;
+    count: number;
+    /**
+     * Quantiles by number of buckets.
+     *
+     * Example:
+     * ```ts
+     *   {
+     *     // for 3 buckets, first 1/3 of items lies in range [min, 20], second 1/3 is in [20, 40], and last 1/3 is in [40, max]
+     *     3: [20, 40],
+     *     4: [20, 30, 50], for 4 buckets ...
+     *   }
+     * ```
+     */
+    quantiles?: Record<number, number[]>;
+    /**
+     * Top values by number of values.
+     *
+     * Key of dictionary is value, value is count.
+     * Key order is random.
+     *
+     * Example:
+     * ```
+     *  {
+     *    3: 5, // means there are 5 pixels with value 3
+     *    11: 222,
+     *    12: 333, // means that 12 is most common value with count 333
+     *    ...      // (assuming 333 was largest value in dict)
+     *   }
+     * ```
+     */
+    top_values?: Record<number, number>;
+    /**
+     * Raster loader version.
+     */
+    version?: string;
+};
+declare enum RasterBandColorinterp {
+    Gray = "gray",
+    Red = "red",
+    Green = "green",
+    Blue = "blue",
+    Alpha = "alpha",
+    Palette = "palette"
+}
+type RasterMetadataBand = {
+    type: string;
+    name: string;
+    stats: RasterMetadataBandStats;
+    /**
+     * Known values:
+     *  * `palette`: use unique value and `colortable` ad default mapping
+     *  * `red`, `green`, `blue`: use the band as color channel
+     *  * `gray`: use the band as grayscale
+     */
+    colorinterp?: string | RasterBandColorinterp;
+    /**
+     * Default color mapping for unique values (or if coloprinterp is `palette`)
+     */
+    colortable?: Record<string, number[]>;
+    /**
+     * No value representation.
+     * Observed values:
+     *   * `'nan'` for `NaN`
+     *   * `number`: both as string as number, so parsing is needed
+     */
+    nodata: string | number;
+};
+type RasterMetadata = {
+    block_resolution: number;
+    minresolution: number;
+    maxresolution: number;
+    nodata: number | string;
+    bands: RasterMetadataBand[];
+    bounds: [left: number, bottom: number, right: number, top: number];
+    center: [longitute: number, latitude: number, zoom: number];
+    width: number;
+    height: number;
+    block_width: number;
+    block_height: number;
+    num_blocks: number;
+    num_pixels: number;
+    pixel_resolution: number;
+};
+type TilejsonResult = Tilejson & {
+    accessToken: string;
+};
+type GeojsonResult = {
+    type: 'FeatureCollection';
+    features: Feature[];
+};
+type JsonResult = any[];
+type QueryResult = {
+    meta: {
+        cacheHit: boolean;
+        location: string;
+        totalBytesProcessed: string;
+    };
+    rows: Record<string, any>[];
+    schema: {
+        name: string;
+        type: string;
+    }[];
+};
+
+declare const SOURCE_DEFAULTS: SourceOptionalOptions;
+
+type BoundaryQuerySourceOptions = SourceOptions & FilterOptions & {
+    columns?: string[];
+    tilesetTableName: string;
+    propertiesSqlQuery: string;
+    queryParameters?: QueryParameters;
+};
+type BoundaryQuerySourceResponse = TilejsonResult;
+declare const boundaryQuerySource: (options: BoundaryQuerySourceOptions) => Promise<BoundaryQuerySourceResponse>;
+
+type BoundaryTableSourceOptions = SourceOptions & FilterOptions & {
+    tilesetTableName: string;
+    columns?: string[];
+    propertiesTableName: string;
+};
+type BoundaryTableSourceResponse = TilejsonResult;
+declare const boundaryTableSource: (options: BoundaryTableSourceOptions) => Promise<BoundaryTableSourceResponse>;
+
+/******************************************************************************
+ * WIDGET API REQUESTS
+ */
+interface ViewState {
+    zoom: number;
+    latitude: number;
+    longitude: number;
+}
+/** Common options for {@link WidgetRemoteSource} requests. */
+interface BaseRequestOptions {
+    signal?: AbortSignal;
+    spatialFilter?: SpatialFilter;
+    spatialFiltersMode?: SpatialFilterPolyfillMode;
+    /** Required for table- and query-based spatial index sources (H3, Quadbin). */
+    spatialIndexReferenceViewState?: ViewState;
+    /** Overrides source filters, if any. */
+    filters?: Filters;
+    filterOwner?: string;
+}
+/** Options for {@link WidgetRemoteSource#getCategories}. */
+interface CategoryRequestOptions extends BaseRequestOptions {
+    column: string;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    operationColumn?: string;
+    /** Local only. */
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/**
+ * Options for {@link WidgetRemoteSource#getFeatures}.
+ * @experimental
+ * @internal
+ */
+interface FeaturesRequestOptions extends BaseRequestOptions {
+    /**
+     * Feature IDs, as found in `_carto_feature_id`. Feature IDs are a hash
+     * of geometry, and features with identical geometry will have the same
+     * feature ID. Order is important; features in the result set will be
+     * sorted according to the order of IDs in the request.
+     */
+    featureIds: string[];
+    /**
+     * Columns to be returned for each picked object. Note that for datasets
+     * containing features with identical geometry, more than one result per
+     * requested feature ID may be returned. To match results back to the
+     * requested feature ID, include `_carto_feature_id` in the columns list.
+     */
+    columns: string[];
+    /** Topology of objects to be picked. */
+    dataType: 'points' | 'lines' | 'polygons';
+    /** Zoom level, required if using 'points' data type. */
+    z?: number;
+    /**
+     * Maximum number of objects to return in the result set. For datasets
+     * containing features with identical geometry, those features will have
+     * the same feature IDs, and so more results may be returned than feature IDs
+     * given in the request.
+     */
+    limit?: number;
+    /**
+     * Must match `tileResolution` used when obtaining the `_carto_feature_id`
+     * column, typically in a layer's tile requests.
+     */
+    tileResolution?: TileResolution;
+}
+/** Options for {@link WidgetRemoteSource#getFormula}. */
+interface FormulaRequestOptions extends BaseRequestOptions {
+    column: string;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum' | 'custom';
+    operationExp?: string;
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getHistogram}. */
+interface HistogramRequestOptions extends BaseRequestOptions {
+    column: string;
+    ticks: number[];
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    /** Local only. */
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getRange}. */
+interface RangeRequestOptions extends BaseRequestOptions {
+    column: string;
+}
+/** Options for {@link WidgetRemoteSource#getScatter}. */
+interface ScatterRequestOptions extends BaseRequestOptions {
+    xAxisColumn: string;
+    xAxisJoinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    yAxisColumn: string;
+    yAxisJoinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getTable}. */
+interface TableRequestOptions extends BaseRequestOptions {
+    columns: string[];
+    sortBy?: string;
+    sortDirection?: SortDirection;
+    sortByColumnType?: SortColumnType;
+    offset?: number;
+    limit?: number;
+    /** Local only. */
+    searchFilterColumn?: string;
+    /** Local only. */
+    searchFilterText?: string;
+}
+/** Options for {@link WidgetRemoteSource#getTimeSeries}. */
+interface TimeSeriesRequestOptions extends BaseRequestOptions {
+    column: string;
+    stepSize: GroupDateType;
+    stepMultiplier?: number;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    operationColumn?: string;
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    splitByCategory?: string;
+    splitByCategoryLimit?: number;
+    splitByCategoryValues?: string[];
+}
+/******************************************************************************
+ * WIDGET API RESPONSES
+ */
+/**
+ * Response from {@link WidgetRemoteSource#getFeatures}.
+ * @experimental
+ * @internal
+ */
+type FeaturesResponse = {
+    rows: Record<string, unknown>[];
+};
+/** Response from {@link WidgetRemoteSource#getFormula}. */
+type FormulaResponse = {
+    value: number | null;
+};
+/** Response from {@link WidgetRemoteSource#getCategories}. */
+type CategoryResponse = {
+    name: string;
+    value: number;
+}[];
+/** Response from {@link WidgetRemoteSource#getRange}. */
+type RangeResponse = {
+    min: number;
+    max: number;
+} | null;
+/** Response from {@link WidgetRemoteSource#getTable}. */
+type TableResponse = {
+    totalCount: number;
+    rows: Record<string, number | string>[];
+};
+/** Response from {@link WidgetRemoteSource#getScatter}. */
+type ScatterResponse = [number, number][];
+/** Response from {@link WidgetRemoteSource#getTimeSeries}. */
+type TimeSeriesResponse = {
+    rows: {
+        name: string;
+        value: number;
+    }[];
+    categories?: string[];
+};
+/** Response from {@link WidgetRemoteSource#getHistogram}. */
+type HistogramResponse = number[];
+
+interface ModelSource {
+    type: MapType;
+    apiVersion: ApiVersion;
+    apiBaseUrl: string;
+    accessToken: string;
+    clientId: string;
+    connectionName: string;
+    data: string;
+    filters?: Record<string, Filter>;
+    filtersLogicalOperator?: FilterLogicalOperator;
+    spatialFilter?: SpatialFilter;
+    queryParameters?: QueryParameters;
+    spatialDataColumn?: string;
+    spatialDataType?: SpatialDataType;
+    spatialFiltersResolution?: number;
+    spatialFiltersMode?: SpatialFilterPolyfillMode;
+    /** original resolution of the spatial index data as stored in the DW */
+    dataResolution?: number;
+}
+
+interface WidgetSourceProps extends Omit<SourceOptions, 'filters'> {
+    apiVersion?: ApiVersion;
+    filters?: Record<string, Filter>;
+    filtersLogicalOperator?: FilterLogicalOperator;
+}
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+declare abstract class WidgetSource<Props extends WidgetSourceProps = WidgetSourceProps> {
+    readonly props: Props;
+    static defaultProps: Partial<WidgetSourceProps>;
+    constructor(props: Props);
+    /**
+     * Destroys the widget source and releases allocated resources.
+     *
+     * For remote sources (tables, queries) this has no effect, but for local
+     * sources (tilesets, rasters) these resources will affect performance
+     * and stability if many (10+) sources are created and not released.
+     */
+    destroy(): void;
+    protected _getSpatialFiltersResolution(source: Omit<ModelSource, 'type' | 'data'>, spatialFilter?: SpatialFilter, referenceViewState?: ViewState): number | undefined;
+    /**
+     * Returns a list of labeled datapoints for categorical data. Suitable for
+     * charts including grouped bar charts, pie charts, and tree charts.
+     */
+    abstract getCategories(options: CategoryRequestOptions): Promise<CategoryResponse>;
+    /**
+     * Given a list of feature IDs (as found in `_carto_feature_id`) returns all
+     * matching features. In datasets containing features with duplicate geometries,
+     * feature IDs may be duplicated (IDs are a hash of geometry) and so more
+     * results may be returned than IDs in the request.
+     * @internal
+     * @experimental
+     */
+    abstract getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
+    /**
+     * Returns a scalar numerical statistic over all matching data. Suitable
+     * for 'headline' or 'scorecard' figures such as counts and sums.
+     */
+    abstract getFormula(options: FormulaRequestOptions): Promise<FormulaResponse>;
+    /**
+     * Returns a list of labeled datapoints for 'bins' of data defined as ticks
+     * over a numerical range. Suitable for histogram charts.
+     */
+    abstract getHistogram(options: HistogramRequestOptions): Promise<HistogramResponse>;
+    /**
+     * Returns a range (min and max) for a numerical column of matching rows.
+     * Suitable for displaying certain 'headline' or 'scorecard' statistics,
+     * or rendering a range slider UI for filtering.
+     */
+    abstract getRange(options: RangeRequestOptions): Promise<RangeResponse>;
+    /**
+     * Returns a list of bivariate datapoints defined as numerical 'x' and 'y'
+     * values. Suitable for rendering scatter plots.
+     */
+    abstract getScatter(options: ScatterRequestOptions): Promise<ScatterResponse>;
+    /**
+     * Returns a list of arbitrary data rows, with support for pagination and
+     * sorting. Suitable for displaying tables and lists.
+     */
+    abstract getTable(options: TableRequestOptions): Promise<TableResponse>;
+    /**
+     * Returns a series of labeled numerical values, grouped into equally-sized
+     * time intervals. Suitable for rendering time series charts.
+     */
+    abstract getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+}
+
+type WidgetRemoteSourceProps = WidgetSourceProps;
+/**
+ * Source for Widget API requests.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+declare abstract class WidgetRemoteSource<Props extends WidgetRemoteSourceProps> extends WidgetSource<Props> {
+    /**
+     * Subclasses of {@link WidgetRemoteSource} must implement this method, calling
+     * {@link WidgetRemoteSource.prototype._getModelSource} for common source
+     * properties, and adding additional required properties including 'type' and
+     * 'data'.
+     */
+    protected abstract getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+    protected _getModelSource(filters: Filters | undefined, filterOwner?: string): Omit<ModelSource, 'type' | 'data'>;
+    getCategories(options: CategoryRequestOptions): Promise<CategoryResponse>;
+    getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
+    getFormula(options: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram(options: HistogramRequestOptions): Promise<HistogramResponse>;
+    getRange(options: RangeRequestOptions): Promise<RangeResponse>;
+    getScatter(options: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable(options: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+}
+
+type LayerQuerySourceOptions = Omit<VectorQuerySourceOptions, 'filters'> | Omit<H3QuerySourceOptions, 'filters'> | Omit<QuadbinQuerySourceOptions, 'filters'>;
+type WidgetQuerySourceResult = {
+    widgetSource: WidgetQuerySource;
+};
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorQuerySource}, {@link h3QuerySource}, or {@link quadbinQuerySource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorQuerySource } from '@carto/api-client';
+ *
+ * const data = vectorQuerySource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   sqlQuery: 'SELECT * FROM carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+declare class WidgetQuerySource extends WidgetRemoteSource<LayerQuerySourceOptions & WidgetRemoteSourceProps> {
+    protected getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+}
+
+type LayerTableSourceOptions = Omit<VectorTableSourceOptions, 'filters'> | Omit<H3TableSourceOptions, 'filters'> | Omit<QuadbinTableSourceOptions, 'filters'>;
+type WidgetTableSourceResult = {
+    widgetSource: WidgetTableSource;
+};
+/**
+ * Source for Widget API requests on a data source defined as a table.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorTableSource}, {@link h3TableSource}, or {@link quadbinTableSource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorTableSource } from '@carto/api-client';
+ *
+ * const data = vectorTableSource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   tableName: 'carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+declare class WidgetTableSource extends WidgetRemoteSource<LayerTableSourceOptions & WidgetRemoteSourceProps> {
+    protected getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+}
+
+/**
+ * @internal
+ * @privateRemarks Exported for use in @deck.gl/carto's getDataFilterExtensionProps.
+ */
+declare function _buildFeatureFilter({ filters, type, filtersLogicalOperator, }: {
+    filters?: Filters;
+    type?: 'number' | 'boolean';
+    filtersLogicalOperator?: FilterLogicalOperator;
+}): (feature: Feature | FeatureData) => number | boolean;
+/**
+ * Apply certain filters to a collection of features.
+ * @internal
+ */
+declare function applyFilters(features: FeatureData[], filters: Filters, filtersLogicalOperator: FilterLogicalOperator): FeatureData[];
+/**
+ * Binary.
+ * @internal
+ */
+declare function buildBinaryFeatureFilter({ filters }: {
+    filters: Filters;
+}): (() => number) | ((featureIdIdx: number, binaryData: BinaryFeature) => boolean);
+
+type FilterFunction = (filterValues: unknown[], featureValue: unknown, params?: Record<string, unknown>) => boolean;
+declare const filterFunctions: Record<FilterType, FilterFunction>;
+
+declare function geojsonFeatures({ geojson, spatialFilter, uniqueIdProperty, }: {
+    geojson: FeatureCollection;
+    spatialFilter: SpatialFilter;
+    uniqueIdProperty?: string;
+}): FeatureData[];
+
+/** @privateRemarks Source: @carto/react-core */
+type TileFeatures = {
+    tiles: Tile[];
+    tileFormat: TileFormat;
+    spatialDataType: SpatialDataType;
+    spatialDataColumn?: string;
+    spatialFilter: SpatialFilter;
+    uniqueIdProperty?: string;
+    options?: TileFeatureExtractOptions;
+};
+/** @privateRemarks Source: @carto/react-core */
+type TileFeatureExtractOptions = {
+    storeGeometry?: boolean;
+    uniqueIdProperty?: string;
+};
+/** @privateRemarks Source: @carto/react-core */
+declare function tileFeatures({ tiles, spatialFilter, uniqueIdProperty, tileFormat, spatialDataColumn, spatialDataType, options, }: TileFeatures): FeatureData[];
+
+declare const FEATURE_GEOM_PROPERTY = "__geomValue";
+declare function tileFeaturesGeometries({ tiles, tileFormat, spatialFilter, uniqueIdProperty, options, }: {
+    tiles: Tile[];
+    tileFormat?: TileFormat;
+    spatialFilter: SpatialFilter;
+    uniqueIdProperty?: string;
+    options?: {
+        storeGeometry?: boolean;
+    };
+}): FeatureData[];
+
+type TileFeaturesSpatialIndexOptions = {
+    tiles: SpatialIndexTile[];
+    spatialFilter: SpatialFilter;
+    spatialDataColumn: string;
+    spatialDataType: SpatialDataType;
+};
+declare function tileFeaturesSpatialIndex({ tiles, spatialFilter, spatialDataColumn, spatialDataType, }: TileFeaturesSpatialIndexOptions): FeatureData[];
+
+declare enum Method {
+    INIT = "init",
+    LOAD_TILES = "loadTiles",
+    SET_TILE_FEATURE_EXTRACT_OPTIONS = "setTileFeatureExtractOptions",
+    LOAD_GEOJSON = "loadGeoJSON",
+    GET_FORMULA = "getFormula",
+    GET_HISTOGRAM = "getHistogram",
+    GET_CATEGORIES = "getCategories",
+    GET_SCATTER = "getScatter",
+    GET_TABLE = "getTable",
+    GET_TIME_SERIES = "getTimeSeries",
+    GET_RANGE = "getRange"
+}
+
+/**
+ * Local (in-memory) implementation of tileset widget calculations. This class
+ * may be instantiated by {@link WidgetTilesetSource} in a Web Worker when
+ * supported, or on the main thread.
+ */
+declare class WidgetTilesetSourceImpl extends WidgetSource<WidgetTilesetSourceProps> {
+    private _tiles;
+    private _features;
+    private _tileFeatureExtractOptions;
+    private _tileFeatureExtractPreviousInputs;
+    /**
+     * Loads features as a list of tiles (typically provided by deck.gl).
+     * After tiles are loaded, {@link extractTileFeatures} must be called
+     * before computing statistics on the tiles.
+     */
+    loadTiles(tiles: unknown[]): void;
+    /** Configures options used to extract features from tiles. */
+    setTileFeatureExtractOptions(options: TileFeatureExtractOptions): void;
+    protected _extractTileFeatures(spatialFilter: SpatialFilter): void;
+    /**
+     * Loads features as GeoJSON (used for testing).
+     * @experimental
+     * @internal Not for public use. Spatial filters in other method calls will be ignored.
+     */
+    loadGeoJSON({ geojson, spatialFilter, }: {
+        geojson: FeatureCollection;
+        spatialFilter: SpatialFilter;
+    }): void;
+    getFeatures(): Promise<FeaturesResponse>;
+    getFormula({ column, operation, joinOperation, filters, filterOwner, spatialFilter, }: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram({ operation, ticks, column, joinOperation, filters, filterOwner, spatialFilter, }: HistogramRequestOptions): Promise<HistogramResponse>;
+    getCategories({ column, operation, operationColumn, joinOperation, filters, filterOwner, spatialFilter, }: CategoryRequestOptions): Promise<CategoryResponse>;
+    getScatter({ xAxisColumn, yAxisColumn, xAxisJoinOperation, yAxisJoinOperation, filters, filterOwner, spatialFilter, }: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable({ columns, searchFilterColumn, searchFilterText, sortBy, sortDirection, sortByColumnType, offset, limit, filters, filterOwner, spatialFilter, }: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries({ column, stepSize, operation, operationColumn, joinOperation, filters, filterOwner, spatialFilter, }: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+    getRange({ column, filters, filterOwner, spatialFilter, }: RangeRequestOptions): Promise<RangeResponse>;
+    /****************************************************************************
+     * INTERNAL
+     */
+    private _getFilteredFeatures;
+}
+
+type WidgetTilesetSourceProps = WidgetSourceProps & Omit<TilesetSourceOptions, 'filters'> & {
+    tileFormat: TileFormat;
+    spatialDataType: SpatialDataType;
+};
+type WidgetTilesetSourceResult = {
+    widgetSource: WidgetTilesetSource;
+};
+/**
+ * Source for Widget API requests on a data source defined by a tileset.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorTilesetSource}, {@link h3TilesetSource}, or {@link quadbinTilesetSource},
+ * which can be shared with map layers. Sources contain a `widgetSource`
+ * property, for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorTilesetSource } from '@carto/api-client';
+ *
+ * const data = vectorTilesetSource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   tableName: 'carto-demo-data.demo_rasters.my_tileset_source'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+declare class WidgetTilesetSource extends WidgetSource<WidgetTilesetSourceProps> {
+    protected _localImpl: WidgetTilesetSourceImpl | null;
+    protected _workerImpl: Worker | null;
+    protected _workerEnabled: boolean;
+    protected _workerNextRequestId: number;
+    constructor(props: WidgetTilesetSourceProps);
+    destroy(): void;
+    /**
+     * Returns an initialized Worker, to be reused for the lifecycle of this
+     * source instance.
+     */
+    protected _getWorker(): Worker;
+    /** Executes a given method on the worker. */
+    protected _executeWorkerMethod<T>(method: Method, params: unknown[], signal?: AbortSignal): Promise<T>;
+    /**
+     * Loads features as a list of tiles (typically provided by deck.gl).
+     * After tiles are loaded, {@link extractTileFeatures} must be called
+     * before computing statistics on the tiles.
+     */
+    loadTiles(tiles: unknown[]): void;
+    /** Configures options used to extract features from tiles. */
+    setTileFeatureExtractOptions(options: TileFeatureExtractOptions): void;
+    /**
+     * Loads features as GeoJSON (used for testing).
+     * @experimental
+     * @internal Not for public use. Spatial filters in other method calls will be ignored.
+     */
+    loadGeoJSON({ geojson, spatialFilter, }: {
+        geojson: FeatureCollection;
+        spatialFilter: SpatialFilter;
+    }): void;
+    getFeatures(): Promise<FeaturesResponse>;
+    getFormula({ signal, ...options }: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram({ signal, ...options }: HistogramRequestOptions): Promise<HistogramResponse>;
+    getCategories({ signal, ...options }: CategoryRequestOptions): Promise<CategoryResponse>;
+    getScatter({ signal, ...options }: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable({ signal, ...options }: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries({ signal, ...options }: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+    getRange({ signal, ...options }: RangeRequestOptions): Promise<RangeResponse>;
+}
+
+type H3QuerySourceOptions = SourceOptions & QuerySourceOptions & AggregationOptions & FilterOptions;
+type H3QuerySourceResponse = TilejsonResult & WidgetQuerySourceResult;
+declare const h3QuerySource: (options: H3QuerySourceOptions) => Promise<H3QuerySourceResponse>;
+
+type H3TableSourceOptions = SourceOptions & TableSourceOptions & AggregationOptions & FilterOptions;
+type H3TableSourceResponse = TilejsonResult & WidgetTableSourceResult;
+declare const h3TableSource: (options: H3TableSourceOptions) => Promise<H3TableSourceResponse>;
+
+type H3TilesetSourceOptions = SourceOptions & TilesetSourceOptions;
+type H3TilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
+declare const h3TilesetSource: (options: H3TilesetSourceOptions) => Promise<H3TilesetSourceResponse>;
+
+type RasterSourceOptions = SourceOptions & TilesetSourceOptions & FilterOptions;
+type RasterSourceResponse = TilejsonResult;
+declare const rasterSource: (options: RasterSourceOptions) => Promise<RasterSourceResponse>;
+
+type QuadbinQuerySourceOptions = SourceOptions & QuerySourceOptions & AggregationOptions & FilterOptions;
+type QuadbinQuerySourceResponse = TilejsonResult & WidgetQuerySourceResult;
+declare const quadbinQuerySource: (options: QuadbinQuerySourceOptions) => Promise<QuadbinQuerySourceResponse>;
+
+type QuadbinTableSourceOptions = SourceOptions & TableSourceOptions & AggregationOptions & FilterOptions;
+type QuadbinTableSourceResponse = TilejsonResult & WidgetTableSourceResult;
+declare const quadbinTableSource: (options: QuadbinTableSourceOptions) => Promise<QuadbinTableSourceResponse>;
+
+type QuadbinTilesetSourceOptions = SourceOptions & TilesetSourceOptions;
+type QuadbinTilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
+declare const quadbinTilesetSource: (options: QuadbinTilesetSourceOptions) => Promise<QuadbinTilesetSourceResponse>;
+
+type VectorQuerySourceOptions = SourceOptions & QuerySourceOptions & FilterOptions & ColumnsOption;
+type VectorQuerySourceResponse = TilejsonResult & WidgetQuerySourceResult;
+declare const vectorQuerySource: (options: VectorQuerySourceOptions) => Promise<VectorQuerySourceResponse>;
+
+type VectorTableSourceOptions = SourceOptions & TableSourceOptions & FilterOptions & ColumnsOption;
+type VectorTableSourceResponse = TilejsonResult & WidgetTableSourceResult;
+declare const vectorTableSource: (options: VectorTableSourceOptions) => Promise<VectorTableSourceResponse>;
+
+type VectorTilesetSourceOptions = SourceOptions & TilesetSourceOptions;
+type VectorTilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
+declare const vectorTilesetSource: (options: VectorTilesetSourceOptions) => Promise<VectorTilesetSourceResponse>;
+
+type APIRequestType = 'Map data' | 'Map instantiation' | 'Public map' | 'Tile stats' | 'SQL' | 'Basemap style';
+type APIErrorContext = {
+    requestType: APIRequestType;
+    mapId?: string;
+    connection?: string;
+    source?: string;
+    type?: MapType;
+};
+/**
+ *
+ * Custom error for reported errors in CARTO Maps API.
+ * Provides useful debugging information in console and context for applications.
+ *
+ */
+declare class CartoAPIError extends Error {
+    /** Source error from server */
+    error: Error;
+    /** Context (API call & parameters) in which error occured */
+    errorContext: APIErrorContext;
+    /** Response from server */
+    response?: Response;
+    /** JSON Response from server */
+    responseJson?: any;
+    constructor(error: Error, errorContext: APIErrorContext, response?: Response, responseJson?: any);
+}
+
+/** @internal Required by fetchMap(). */
+declare function buildPublicMapUrl({ apiBaseUrl, cartoMapId, }: {
+    apiBaseUrl: string;
+    cartoMapId: string;
+}): string;
+/** @internal Required by fetchMap(). */
+declare function buildStatsUrl({ attribute, apiBaseUrl, connectionName, source, type, }: {
+    attribute: string;
+    apiBaseUrl: string;
+    connectionName: string;
+    source: string;
+    type: MapType;
+}): string;
+
+type QueryOptions = SourceOptions & QuerySourceOptions;
+declare const query: (options: QueryOptions) => Promise<QueryResult>;
+
+declare function requestWithParameters<T = any>({ baseUrl, parameters, headers: customHeaders, errorContext, maxLengthURL, localCache, }: {
+    baseUrl: string;
+    parameters?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    errorContext: APIErrorContext;
+    maxLengthURL?: number;
+    localCache?: LocalCacheOptions;
+}): Promise<T>;
+
+/**
+ * Resolution conversion function. Takes a WebMercatorViewport and returns
+ * a H3 resolution such that the screen space size of the hexagons is
+ * "similar" to the given tileSize on screen. Intended for use with deck.gl.
+ * @internal
+ */
+declare function _getHexagonResolution(viewport: {
+    zoom: number;
+    latitude: number;
+}, tileSize: number): number;
+
+/** @privateRemarks Source: @carto/react-core */
+type AggregationFunction = (values: unknown[] | FeatureData[], keys?: string[] | string, joinOperation?: AggregationType) => number;
+/** @privateRemarks Source: @carto/react-core */
+declare const aggregationFunctions: Record<Exclude<AggregationType, 'custom'>, AggregationFunction>;
+/** @privateRemarks Source: @carto/react-core */
+declare function aggregate(feature: FeatureData, keys?: string[], operation?: AggregationType): unknown;
+
+type SortColumns = string | string[] | object[];
+interface SortOptions {
+    sortBy?: SortColumns;
+    sortByDirection?: SortDirection;
+    sortByColumnType?: 'number' | 'string' | 'date';
+}
+/**
+ * Apply sort structure to a collection of features
+ * @param features
+ * @param [sortOptions]
+ * @param [sortOptions.sortBy] - One or more columns to sort by
+ * @param [sortOptions.sortByDirection] - Direction by the columns will be sorted
+ * @param [sortOptions.sortByColumnType] - Column type
+ * @internal
+ * @privateRemarks Source: @carto/react-core
+ */
+declare function applySorting(features: FeatureData[], { sortBy, sortByDirection, sortByColumnType, }?: SortOptions): FeatureData[];
+
+/** @privateRemarks Source: @carto/react-core */
+type GroupByFeature = {
+    name: string;
+    value: number;
+}[];
+/** @privateRemarks Source: @carto/react-core */
+declare function groupValuesByColumn({ data, valuesColumns, joinOperation, keysColumn, operation, }: {
+    data: FeatureData[];
+    valuesColumns?: string[];
+    joinOperation?: AggregationType;
+    keysColumn: string;
+    operation: AggregationType;
+}): GroupByFeature | null;
+
+/** @privateRemarks Source: @carto/react-core */
+declare function groupValuesByDateColumn({ data, valuesColumns, joinOperation, keysColumn, groupType, operation, }: {
+    data: Record<string, unknown>[];
+    valuesColumns?: string[];
+    joinOperation?: Exclude<AggregationType, 'custom'>;
+    keysColumn: string;
+    groupType: GroupDateType;
+    operation?: Exclude<AggregationType, 'custom'>;
+}): GroupByFeature | null;
+
+/**
+ * Histogram computation.
+ * @privateRemarks Source: @carto/react-core
+ */
+declare function histogram({ data, valuesColumns, joinOperation, ticks, operation, }: {
+    data: FeatureData[];
+    valuesColumns?: string[];
+    joinOperation?: Exclude<AggregationType, 'custom'>;
+    ticks: number[];
+    operation: Exclude<AggregationType, 'custom'>;
+}): number[];
+
+type ScatterPlotFeature = [number, number][];
+/**
+ * Filters invalid features and formats  data.
+ * @privateRemarks Source: @carto/react-core
+ */
+declare function scatterPlot({ data, xAxisColumns, xAxisJoinOperation, yAxisColumns, yAxisJoinOperation, }: {
+    data: FeatureData[];
+    xAxisColumns: string[];
+    xAxisJoinOperation?: AggregationType;
+    yAxisColumns: string[];
+    yAxisJoinOperation?: AggregationType;
+}): ScatterPlotFeature;
+
+declare function makeIntervalComplete(intervals: FilterInterval[]): FilterIntervalComplete[];
+
+/**
+ * Transform WGS84 coordinates to tile coords.
+ * It's the inverse of deck.gl coordinate-transform (https://github.com/visgl/deck.gl/blob/master/modules/geo-layers/src/mvt-layer/coordinate-transform.js)
+ *
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
+ */
+declare function transformToTileCoords<T extends Geometry>(geometry: T, bbox: BBox): T;
+
+export { type APIErrorContext, type APIRequestType, type AddFilterOptions, type AggregationFunction, type AggregationType, ApiVersion, type BoundaryQuerySourceOptions, type BoundaryQuerySourceResponse, type BoundaryTableSourceOptions, type BoundaryTableSourceResponse, CartoAPIError, type CategoryRequestOptions, type CategoryResponse, DEFAULT_API_BASE_URL, FEATURE_GEOM_PROPERTY, type FeaturesRequestOptions, type FeaturesResponse, type Filter, type FilterFunction, type FilterInterval, type FilterIntervalComplete, type FilterIntervalExtremum, type FilterLogicalOperator, FilterType, type Filters, type Format, type FormulaRequestOptions, type FormulaResponse, type GeojsonResult, type GetFilterOptions, type GroupByFeature, type GroupDateType, type H3QuerySourceOptions, type H3QuerySourceResponse, type H3TableSourceOptions, type H3TableSourceResponse, type H3TilesetSourceOptions, type H3TilesetSourceResponse, type HasFilterOptions, type HistogramRequestOptions, type HistogramResponse, type JsonResult, type MapType, type NamedQueryParameter, type PositionalQueryParameter, Provider, type QuadbinQuerySourceOptions, type QuadbinQuerySourceResponse, type QuadbinTableSourceOptions, type QuadbinTableSourceResponse, type QuadbinTilesetSourceOptions, type QuadbinTilesetSourceResponse, type QueryOptions, type QueryParameterValue, type QueryParameters, type QueryResult, type QuerySourceOptions, type RangeRequestOptions, type RangeResponse, type Raster, RasterBandColorinterp, type RasterMetadata, type RasterMetadataBand, type RasterMetadataBandStats, type RasterSourceOptions, type RemoveFilterOptions, SOURCE_DEFAULTS, type ScatterPlotFeature, type ScatterRequestOptions, type ScatterResponse, type SortColumnType, type SortDirection, type SourceOptions, type SpatialFilter, type SpatialFilterPolyfillMode, SpatialIndex, type SpatialIndexTile, type StringSearchOptions, type TableRequestOptions, type TableResponse, type TableSourceOptions, type Tile, type TileFeatureExtractOptions, type TileFeatures, type TileFeaturesSpatialIndexOptions, TileFormat, type TileResolution, type TilejsonResult, type TilesetSourceOptions, type TimeSeriesRequestOptions, type TimeSeriesResponse, type VectorLayer, type VectorQuerySourceOptions, type VectorQuerySourceResponse, type VectorTableSourceOptions, type VectorTableSourceResponse, type VectorTilesetSourceOptions, type VectorTilesetSourceResponse, type ViewState, type Viewport, WidgetQuerySource, type WidgetQuerySourceResult, WidgetRemoteSource, type WidgetRemoteSourceProps, WidgetSource, type WidgetSourceProps, WidgetTableSource, type WidgetTableSourceResult, WidgetTilesetSource, type WidgetTilesetSourceProps, type WidgetTilesetSourceResult, type _DataFilterExtensionProps, _buildFeatureFilter, _getHexagonResolution, addFilter, aggregate, aggregationFunctions, applyFilters, applySorting, boundaryQuerySource, boundaryTableSource, buildBinaryFeatureFilter, buildPublicMapUrl, buildStatsUrl, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, filterFunctions, geojsonFeatures, getClient, getDataFilterExtensionProps, getFilter, groupValuesByColumn, groupValuesByDateColumn, h3QuerySource, h3TableSource, h3TilesetSource, hasFilter, histogram, makeIntervalComplete, quadbinQuerySource, quadbinTableSource, quadbinTilesetSource, query, rasterSource, removeFilter, requestWithParameters, scatterPlot, setClient, tileFeatures, tileFeaturesGeometries, tileFeaturesSpatialIndex, transformToTileCoords, vectorQuerySource, vectorTableSource, vectorTilesetSource };