@carto/api-client 0.4.3 → 0.5.0-alpha.0

package/build/constants.d.ts

@@ -29,3 +29,25 @@ export declare enum ApiVersion {
 }
 /** @internalRemarks Source: @carto/constants, @deck.gl/carto */
 export declare const DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
+/** @internalRemarks Source: @carto/react-core */
+export declare enum TileFormat {
+    MVT = "mvt",
+    JSON = "json",
+    GEOJSON = "geojson",
+    BINARY = "binary"
+}
+/** @internalRemarks Source: @carto/react-core */
+export declare enum SpatialIndex {
+    H3 = "h3",
+    S2 = "s2",
+    QUADBIN = "quadbin"
+}
+/** @internalRemarks Source: @carto/react-core */
+export declare enum Provider {
+    BIGQUERY = "bigquery",
+    REDSHIFT = "redshift",
+    POSTGRES = "postgres",
+    SNOWFLAKE = "snowflake",
+    DATABRICKS = "databricks",
+    DATABRICKS_REST = "databricksRest"
+}

package/build/filters/Filter.d.ts

@@ -0,0 +1,13 @@
+import { FilterLogicalOperator, Filters } from '../types';
+import { Feature } from 'geojson';
+import { FeatureData } from '../types-internal';
+import { BinaryFeature } from '@loaders.gl/schema';
+export declare function buildFeatureFilter({ filters, type, filtersLogicalOperator, }: {
+    filters?: Filters;
+    type?: 'number' | 'boolean';
+    filtersLogicalOperator?: FilterLogicalOperator;
+}): (feature: Feature | FeatureData) => number | boolean;
+export declare function applyFilters(features: FeatureData[], filters: Filters, filtersLogicalOperator: FilterLogicalOperator): FeatureData[];
+export declare function buildBinaryFeatureFilter({ filters }: {
+    filters: Filters;
+}): (() => number) | ((featureIdIdx: number, binaryData: BinaryFeature) => boolean);

package/build/filters/FilterTypes.d.ts

@@ -0,0 +1,3 @@
+import { FilterType } from '../constants';
+export type FilterFunction = (filterValues: unknown[], featureValue: unknown, params?: Record<string, unknown>) => boolean;
+export declare const filterFunctions: Record<FilterType, FilterFunction>;

package/build/filters/geosjonFeatures.d.ts

@@ -0,0 +1,8 @@
+import { FeatureCollection } from 'geojson';
+import { SpatialFilter } from '..';
+import { FeatureData } from '../types-internal';
+export declare function geojsonFeatures({ geojson, spatialFilter, uniqueIdProperty, }: {
+    geojson: FeatureCollection;
+    spatialFilter: SpatialFilter;
+    uniqueIdProperty?: string;
+}): FeatureData[];

package/build/filters/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Filter.js';
+export * from './FilterTypes.js';
+export * from './geosjonFeatures.js';
+export * from './tileFeatures.js';
+export * from './tileFeaturesGeometries.js';
+export * from './tileFeaturesSpatialIndex.js';

package/build/filters/tileFeatures.d.ts

@@ -0,0 +1,20 @@
+import { SpatialFilter, Tile } from '../types';
+import { TileFormat } from '../constants';
+import { FeatureData } from '../types-internal';
+import { SpatialDataType } from '../sources/types';
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatures = {
+    tiles: Tile[];
+    tileFormat: TileFormat;
+    spatialDataType: SpatialDataType;
+    spatialDataColumn?: string;
+    spatialFilter?: SpatialFilter;
+    uniqueIdProperty?: string;
+    options?: TileFeatureExtractOptions;
+};
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatureExtractOptions = {
+    storeGeometry?: boolean;
+};
+/** @internalRemarks Source: @carto/react-core */
+export declare function tileFeatures({ tiles, spatialFilter, uniqueIdProperty, tileFormat, spatialDataColumn, spatialDataType, options, }: TileFeatures): FeatureData[];

package/build/filters/tileFeaturesGeometries.d.ts

@@ -0,0 +1,13 @@
+import { TileFormat } from '../constants.js';
+import { SpatialFilter, Tile } from '../types.js';
+import { FeatureData } from '../types-internal.js';
+export declare const FEATURE_GEOM_PROPERTY = "__geomValue";
+export declare function tileFeaturesGeometries({ tiles, tileFormat, spatialFilter, uniqueIdProperty, options, }: {
+    tiles: Tile[];
+    tileFormat?: TileFormat;
+    spatialFilter: SpatialFilter;
+    uniqueIdProperty?: string;
+    options?: {
+        storeGeometry?: boolean;
+    };
+}): FeatureData[];

package/build/filters/tileFeaturesSpatialIndex.d.ts

@@ -0,0 +1,10 @@
+import { SpatialFilter, SpatialIndexTile } from '../types.js';
+import { FeatureData } from '../types-internal.js';
+import { SpatialDataType } from '../sources/types.js';
+export type TileFeaturesSpatialIndexOptions = {
+    tiles: SpatialIndexTile[];
+    spatialFilter: SpatialFilter;
+    spatialDataColumn: string;
+    spatialDataType: SpatialDataType;
+};
+export declare function tileFeaturesSpatialIndex({ tiles, spatialFilter, spatialDataColumn, spatialDataType, }: TileFeaturesSpatialIndexOptions): FeatureData[];

package/build/index.d.ts

@@ -8,3 +8,7 @@ export * from './types.js';
 export { APIErrorContext, APIRequestType, CartoAPIError, QueryOptions, buildPublicMapUrl, // Internal, but required for fetchMap().
 buildStatsUrl, // Internal, but required for fetchMap().
 query, requestWithParameters, } from './api/index.js';
+export * from './filters/index.js';
+export * from './operations/index.js';
+export * from './utils/makeIntervalComplete.js';
+export * from './utils/transformToTileCoords.js';

package/build/models/index.d.ts

@@ -1,3 +1,3 @@
 export { executeModel } from './model.js';
-export type { Model } from './model.js';
+export type { Model, ModelSource } from './model.js';
 export type { ModelRequestOptions } from './common.js';

package/build/models/model.d.ts

@@ -1,6 +1,7 @@
 import { Filter, FilterLogicalOperator, MapType, QueryParameters, SpatialFilter } from '../types.js';
 import { ModelRequestOptions } from './common.js';
 import { ApiVersion } from '../constants.js';
+import { SpatialDataType, SpatialFilterPolyfillMode } from '../sources/types.js';
 /** @internalRemarks Source: @carto/react-api */
 declare const AVAILABLE_MODELS: readonly ["category", "histogram", "formula", "pick", "timeseries", "range", "scatterplot", "table"];
 export type Model = (typeof AVAILABLE_MODELS)[number];
@@ -14,9 +15,14 @@ export interface ModelSource {
     data: string;
     filters?: Record<string, Filter>;
     filtersLogicalOperator?: FilterLogicalOperator;
-    geoColumn?: string;
     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;
 }
 /**
  * Execute a SQL model request.

package/build/operations/aggregation.d.ts

@@ -0,0 +1,8 @@
+import { AggregationType } from '../types';
+import { FeatureData } from '../types-internal';
+/** @internalRemarks Source: @carto/react-core */
+export type AggregationFunction = (values: unknown[] | FeatureData[], keys?: string[] | string, joinOperation?: AggregationType) => number;
+/** @internalRemarks Source: @carto/react-core */
+export declare const aggregationFunctions: Record<Exclude<AggregationType, 'custom'>, AggregationFunction>;
+/** @internalRemarks Source: @carto/react-core */
+export declare function aggregate(feature: FeatureData, keys?: string[], operation?: AggregationType): unknown;

package/build/operations/applySorting.d.ts

@@ -0,0 +1,20 @@
+import { SortDirection } from '../types';
+import { FeatureData } from '../types-internal';
+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
+ * @internalRemarks Source: @carto/react-core
+ */
+export declare function applySorting(features: FeatureData[], { sortBy, sortByDirection, sortByColumnType, }?: SortOptions): FeatureData[];
+export {};

package/build/operations/groupBy.d.ts

@@ -0,0 +1,15 @@
+import { AggregationType } from '../types';
+import { FeatureData } from '../types-internal';
+/** @internalRemarks Source: @carto/react-core */
+export type GroupByFeature = {
+    name: string;
+    value: number;
+}[];
+/** @internalRemarks Source: @carto/react-core */
+export declare function groupValuesByColumn({ data, valuesColumns, joinOperation, keysColumn, operation, }: {
+    data: FeatureData[];
+    valuesColumns?: string[];
+    joinOperation?: AggregationType;
+    keysColumn: string;
+    operation: AggregationType;
+}): GroupByFeature | null;

package/build/operations/groupByDate.d.ts

@@ -0,0 +1,11 @@
+import { AggregationType, GroupDateType } from '../types.js';
+import { GroupByFeature } from './groupBy.js';
+/** @internalRemarks Source: @carto/react-core */
+export 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;

package/build/operations/histogram.d.ts

@@ -0,0 +1,13 @@
+import { AggregationType } from '../types';
+import { FeatureData } from '../types-internal';
+/**
+ * Histogram computation.
+ * @internalRemarks Source: @carto/react-core
+ */
+export declare function histogram({ data, valuesColumns, joinOperation, ticks, operation, }: {
+    data: FeatureData[];
+    valuesColumns?: string[];
+    joinOperation?: Exclude<AggregationType, 'custom'>;
+    ticks: number[];
+    operation: Exclude<AggregationType, 'custom'>;
+}): number[];

package/build/operations/index.d.ts

@@ -0,0 +1,6 @@
+export * from './aggregation.js';
+export * from './applySorting.js';
+export * from './groupBy.js';
+export * from './groupByDate.js';
+export * from './histogram.js';
+export * from './scatterPlot.js';

package/build/operations/scatterPlot.d.ts

@@ -0,0 +1,14 @@
+import { FeatureData } from '../types-internal';
+import { AggregationType } from '../types';
+export type ScatterPlotFeature = [number, number][];
+/**
+ * Filters invalid features and formats  data.
+ * @internalRemarks Source: @carto/react-core
+ */
+export declare function scatterPlot({ data, xAxisColumns, xAxisJoinOperation, yAxisColumns, yAxisJoinOperation, }: {
+    data: FeatureData[];
+    xAxisColumns: string[];
+    xAxisJoinOperation?: AggregationType;
+    yAxisColumns: string[];
+    yAxisJoinOperation?: AggregationType;
+}): ScatterPlotFeature;

package/build/sources/h3-tileset-source.d.ts

@@ -1,4 +1,5 @@
+import { WidgetTilesetSourceResult } from '../widget-sources';
 import type { SourceOptions, TilejsonResult, TilesetSourceOptions } from './types';
 export type H3TilesetSourceOptions = SourceOptions & TilesetSourceOptions;
-export type H3TilesetSourceResponse = TilejsonResult;
+export type H3TilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
 export declare const h3TilesetSource: (options: H3TilesetSourceOptions) => Promise<H3TilesetSourceResponse>;

package/build/sources/index.d.ts

@@ -11,7 +11,7 @@ export type { H3TableSourceOptions, H3TableSourceResponse, } from './h3-table-so
 export { h3TilesetSource } from './h3-tileset-source';
 export type { H3TilesetSourceOptions, H3TilesetSourceResponse, } from './h3-tileset-source';
 export { rasterSource } from './raster-source';
-export type { RasterSourceOptions, RasterSourceResponse } from './raster-source';
+export type { RasterSourceOptions } from './raster-source';
 export { quadbinQuerySource } from './quadbin-query-source';
 export type { QuadbinQuerySourceOptions, QuadbinQuerySourceResponse, } from './quadbin-query-source';
 export { quadbinTableSource } from './quadbin-table-source';

package/build/sources/quadbin-tileset-source.d.ts

@@ -1,4 +1,5 @@
+import { WidgetTilesetSourceResult } from '../widget-sources';
 import type { SourceOptions, TilejsonResult, TilesetSourceOptions } from './types';
 export type QuadbinTilesetSourceOptions = SourceOptions & TilesetSourceOptions;
-export type QuadbinTilesetSourceResponse = TilejsonResult;
+export type QuadbinTilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
 export declare const quadbinTilesetSource: (options: QuadbinTilesetSourceOptions) => Promise<QuadbinTilesetSourceResponse>;

package/build/sources/types.d.ts

@@ -38,6 +38,30 @@ export type SourceOptionalOptions = {
      * @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.
      */
@@ -73,6 +97,10 @@ export type AggregationOptions = {
      * @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;
 };
 export type FilterOptions = {
     /**
@@ -81,28 +109,8 @@ export type FilterOptions = {
     filters?: Filters;
 };
 export type QuerySourceOptions = {
-    /**
-     * 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;
-    /** SQL query. */
+    /** Full SQL query with query paremeter placeholders (if any). */
     sqlQuery: string;
-    /**
-     * 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;
     /**
      * Values for named or positional paramteres in the query.
      *
@@ -142,26 +150,6 @@ export type TableSourceOptions = {
      * Fully qualified name of table.
      */
     tableName: string;
-    /**
-     * The column name and the type of geospatial support.
-     *
-     * If not present, defaults to `'geom'` for generic tables, `'quadbin'` for Quadbin sources and `'h3'` for H3 sources.
-     */
-    spatialDataColumn?: string;
-    /**
-     * 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;
     /**
      * Comma-separated aggregation expressions. If assigned on a vector source, source is grouped by geometry and then aggregated.
      *
@@ -186,6 +174,13 @@ export type ColumnsOption = {
     columns?: string[];
 };
 export 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.
+ * @internalRemarks Source: cloud-native maps-api
+ * */
+export type SpatialFilterPolyfillMode = 'center' | 'intersects' | 'contains';
 export type TilejsonMapInstantiation = MapInstantiation & {
     tilejson: {
         url: string[];

package/build/sources/vector-tileset-source.d.ts

@@ -1,4 +1,5 @@
+import { WidgetTilesetSourceResult } from '../widget-sources';
 import type { SourceOptions, TilesetSourceOptions, TilejsonResult } from './types';
 export type VectorTilesetSourceOptions = SourceOptions & TilesetSourceOptions;
-export type VectorTilesetSourceResponse = TilejsonResult;
+export type VectorTilesetSourceResponse = TilejsonResult & WidgetTilesetSourceResult;
 export declare const vectorTilesetSource: (options: VectorTilesetSourceOptions) => Promise<VectorTilesetSourceResponse>;

package/build/spatial-index.d.ts

@@ -0,0 +1,8 @@
+import type { ModelSource } from './models/model';
+import type { AggregationOptions } from './sources/types';
+import type { ViewState } from './widget-sources';
+export declare function getSpatialFiltersResolution(source: Partial<ModelSource & AggregationOptions>, viewState: ViewState): number | undefined;
+export declare function getHexagonResolution(viewport: {
+    zoom: number;
+    latitude: number;
+}, tileSize: number): number;

package/build/types-internal.d.ts

@@ -49,4 +49,8 @@ type MapInstantiationFormats = Record<Format, {
     url: string[];
     error?: any;
 }>;
+/******************************************************************************
+ * LOCAL CALCULATIONS
+ */
+export type FeatureData = Record<string, unknown>;
 export {};

package/build/types.d.ts

@@ -1,5 +1,6 @@
 import type { FilterType } from './constants.js';
-import type { Polygon, MultiPolygon } from 'geojson';
+import type { Polygon, MultiPolygon, Feature } from 'geojson';
+import type { BinaryFeature, BinaryFeatureCollection } from '@loaders.gl/schema';
 /******************************************************************************
  * MAPS AND TILES
  */
@@ -7,6 +8,50 @@ import type { Polygon, MultiPolygon } from 'geojson';
 export type Format = 'json' | 'geojson' | 'tilejson';
 /** @internalRemarks Source: @carto/constants, @deck.gl/carto */
 export type MapType = 'boundary' | 'query' | 'table' | 'tileset' | 'raster';
+/**
+ * Alias for GeoJSON 'BBox' type, semantically representing a viewport.
+ * Order of values is "west", "south", "east", "north".
+ */
+export 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.
+ * @internalRemarks Source: @deck.gl/geo-layers
+ */
+export 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. */
+export type SpatialIndexTile = Tile & {
+    data?: (Feature & {
+        id: bigint;
+    })[];
+};
+/** @internalRemarks Source: @deck.gl/carto */
+export type Raster = {
+    blockSize: number;
+    cells: {
+        numericProps: BinaryFeature['numericProps'];
+        properties: BinaryFeature['properties'];
+    };
+};
 /******************************************************************************
  * AGGREGATION
  */
@@ -49,10 +94,25 @@ export interface Filter {
     [FilterType.STRING_SEARCH]?: {
         owner?: string;
         values: string[];
+        params?: StringSearchOptions;
     };
 }
 /** @internalRemarks Source: @carto/react-core */
 export 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.
+ */
+export type FilterIntervalExtremum = number | null | undefined;
+export type FilterInterval = [FilterIntervalExtremum, FilterIntervalExtremum];
+export type FilterIntervalComplete = [number, number];
+export type StringSearchOptions = {
+    useRegExp?: boolean;
+    mustStart?: boolean;
+    mustEnd?: boolean;
+    caseSensitive?: boolean;
+    keepSpecialCharacters?: boolean;
+};
 /******************************************************************************
  * GROUPING
  */

package/build/utils/dateUtils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns midnight (local time) on the Monday preceeding a given date, in
+ * milliseconds since the UNIX epoch.
+ */
+export declare function getMonday(date: number | Date): number;
+/**
+ * Returns midnight (UTC) on the Monday preceeding a given date, in
+ * milliseconds since the UNIX epoch.
+ */
+export declare function getUTCMonday(date: number | Date): number;

package/build/utils/getTileFormat.d.ts

@@ -0,0 +1,3 @@
+import { TileFormat } from '../constants.js';
+import { Tilejson } from '../sources/types.js';
+export declare function getTileFormat(tilejson: Tilejson): TileFormat;

package/build/utils/makeIntervalComplete.d.ts

@@ -0,0 +1,2 @@
+import { FilterInterval, FilterIntervalComplete } from '../types';
+export declare function makeIntervalComplete(intervals: FilterInterval[]): FilterIntervalComplete[];

package/build/utils/transformTileCoordsToWGS84.d.ts

@@ -0,0 +1,8 @@
+import { BBox, Geometry } from 'geojson';
+/**
+ * Transform tile coords to WGS84 coordinates.
+ *
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
+ */
+export declare function transformTileCoordsToWGS84<T extends Geometry>(geometry: T, bbox: BBox): T;

package/build/utils/transformToTileCoords.d.ts

@@ -0,0 +1,9 @@
+import { BBox, Geometry } from 'geojson';
+/**
+ * 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
+ */
+export declare function transformToTileCoords<T extends Geometry>(geometry: T, bbox: BBox): T;

package/build/utils.d.ts

@@ -14,7 +14,7 @@ type Row<T> = Record<string, T> | Record<string, T>[] | T[] | T;
  */
 export declare function normalizeObjectKeys<T, R extends Row<T>>(el: R): R;
 /** @internalRemarks Source: @carto/react-core */
-export declare function assert(condition: unknown, message: string): void;
+export declare function assert(condition: unknown, message: string): asserts condition;
 /**
  * @internalRemarks Source: @carto/react-core
  * @internal

package/build/widget-sources/index.d.ts

@@ -1,4 +1,5 @@
-export * from './widget-base-source.js';
 export * from './widget-query-source.js';
+export * from './widget-remote-source.js';
 export * from './widget-table-source.js';
+export * from './widget-tileset-source.js';
 export * from './types.js';