@carto/ps-react-maps 4.5.2 → 4.6.1

package/dist/types/editable/lasso-tools/provider/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/editable/measurement-tools/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -26,7 +26,7 @@ export { createMeasurementToolsStore } from './editable/measurement-tools/provid
 export { CustomEditableGeojsonLayer } from './editable/custom-editable-geojson-layer';
 export { getCursorDefault, getTooltipDefault } from './helpers';
 export { MapComponent } from './maps/map';
-export type { ModelProps } from './models/types';
+export type { ModelProps, FormulaWidgetProps, CategoryWidgetProps, TimeSeriesWidgetProps, HistogramWidgetProps, AggregationsWidgetProps, RangeWidgetProps, ScatterWidgetProps, TableWidgetProps, FeaturesWidgetProps, } from './models/types';
 export { AggregationsModel, useAggregations } from './models/aggregations';
 export { CategoriesModel, useCategories } from './models/categories';
 export { FeaturesModel, useFeatures } from './models/features';

package/dist/types/models/aggregations.d.ts

@@ -1,5 +1,5 @@
-import { AggregationsRequestOptions as _AggregationsRequestOptions, AggregationsResponse, AggregationType } from '@carto/api-client';
-export type AggregationsRequestOptions = Omit<_AggregationsRequestOptions, 'aggregations'> & {
+import { AggregationsRequestOptions, AggregationsResponse, AggregationType } from '@carto/api-client';
+export type AggregationsWidgetProps = Omit<AggregationsRequestOptions, 'aggregations'> & {
     aggregations: ({
         operation: 'custom';
         aggregationExp: string;
@@ -10,7 +10,17 @@ export type AggregationsRequestOptions = Omit<_AggregationsRequestOptions, 'aggr
         alias: string;
     })[];
 };
-declare const useAggregations: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<AggregationsRequestOptions, AggregationsResponse>) => import('@tanstack/react-query').UseQueryResult<AggregationsResponse, Error>, AggregationsModel: ({ children, ...modelProps }: import('./types').ModelProps<AggregationsRequestOptions, AggregationsResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<AggregationsResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+declare const useAggregations: <P extends import('./types').ModelProps<AggregationsWidgetProps, AggregationsResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<AggregationsResponse> : import('./types').ModelResponse<AggregationsResponse[]>, AggregationsModel: {
+    (props: import('./types').ModelProps<AggregationsWidgetProps, AggregationsResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<AggregationsResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<AggregationsWidgetProps, AggregationsResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<AggregationsResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useAggregations, AggregationsModel };

package/dist/types/models/categories.d.ts

@@ -1,5 +1,16 @@
-import { CategoryRequestOptions, CategoryResponse } from '@carto/api-client';
-declare const useCategories: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<CategoryRequestOptions, CategoryResponse>) => import('@tanstack/react-query').UseQueryResult<CategoryResponse, Error>, CategoriesModel: ({ children, ...modelProps }: import('./types').ModelProps<CategoryRequestOptions, CategoryResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<CategoryResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { CategoryResponse } from '@carto/api-client';
+import { CategoryWidgetProps } from './types';
+declare const useCategories: <P extends import('./types').ModelProps<CategoryWidgetProps, CategoryResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<CategoryResponse> : import('./types').ModelResponse<CategoryResponse[]>, CategoriesModel: {
+    (props: import('./types').ModelProps<CategoryWidgetProps, CategoryResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<CategoryResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<CategoryWidgetProps, CategoryResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<CategoryResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useCategories, CategoriesModel };

package/dist/types/models/features.d.ts

@@ -1,5 +1,16 @@
-import { FeaturesRequestOptions, FeaturesResponse } from '@carto/api-client';
-declare const useFeatures: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<FeaturesRequestOptions, FeaturesResponse>) => import('@tanstack/react-query').UseQueryResult<FeaturesResponse, Error>, FeaturesModel: ({ children, ...modelProps }: import('./types').ModelProps<FeaturesRequestOptions, FeaturesResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<FeaturesResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { FeaturesResponse } from '@carto/api-client';
+import { FeaturesWidgetProps } from './types';
+declare const useFeatures: <P extends import('./types').ModelProps<FeaturesWidgetProps, FeaturesResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<FeaturesResponse> : import('./types').ModelResponse<FeaturesResponse[]>, FeaturesModel: {
+    (props: import('./types').ModelProps<FeaturesWidgetProps, FeaturesResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<FeaturesResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<FeaturesWidgetProps, FeaturesResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<FeaturesResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useFeatures, FeaturesModel };

package/dist/types/models/formula.d.ts

@@ -1,5 +1,16 @@
-import { FormulaRequestOptions, FormulaResponse } from '@carto/api-client';
-declare const useFormula: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<FormulaRequestOptions, FormulaResponse>) => import('@tanstack/react-query').UseQueryResult<FormulaResponse, Error>, FormulaModel: ({ children, ...modelProps }: import('./types').ModelProps<FormulaRequestOptions, FormulaResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<FormulaResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { FormulaResponse } from '@carto/api-client';
+import { FormulaWidgetProps } from './types';
+declare const useFormula: <P extends import('./types').ModelProps<FormulaWidgetProps, FormulaResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<FormulaResponse> : import('./types').ModelResponse<FormulaResponse[]>, FormulaModel: {
+    (props: import('./types').ModelProps<FormulaWidgetProps, FormulaResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<FormulaResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<FormulaWidgetProps, FormulaResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<FormulaResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useFormula, FormulaModel };

package/dist/types/models/histogram.d.ts

@@ -1,5 +1,16 @@
-import { HistogramRequestOptions, HistogramResponse } from '@carto/api-client';
-declare const useHistogram: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<HistogramRequestOptions, HistogramResponse>) => import('@tanstack/react-query').UseQueryResult<HistogramResponse, Error>, HistogramModel: ({ children, ...modelProps }: import('./types').ModelProps<HistogramRequestOptions, HistogramResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<HistogramResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { HistogramResponse } from '@carto/api-client';
+import { HistogramWidgetProps } from './types';
+declare const useHistogram: <P extends import('./types').ModelProps<HistogramWidgetProps, HistogramResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<HistogramResponse> : import('./types').ModelResponse<HistogramResponse[]>, HistogramModel: {
+    (props: import('./types').ModelProps<HistogramWidgetProps, HistogramResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<HistogramResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<HistogramWidgetProps, HistogramResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<HistogramResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useHistogram, HistogramModel };

package/dist/types/models/range.d.ts

@@ -1,5 +1,16 @@
-import { RangeRequestOptions, RangeResponse } from '@carto/api-client';
-declare const useRange: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<RangeRequestOptions, RangeResponse>) => import('@tanstack/react-query').UseQueryResult<RangeResponse, Error>, RangeModel: ({ children, ...modelProps }: import('./types').ModelProps<RangeRequestOptions, RangeResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<RangeResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { RangeResponse } from '@carto/api-client';
+import { RangeWidgetProps } from './types';
+declare const useRange: <P extends import('./types').ModelProps<RangeWidgetProps, RangeResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<RangeResponse> : import('./types').ModelResponse<RangeResponse[]>, RangeModel: {
+    (props: import('./types').ModelProps<RangeWidgetProps, RangeResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<RangeResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<RangeWidgetProps, RangeResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<RangeResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useRange, RangeModel };

package/dist/types/models/scatter.d.ts

@@ -1,5 +1,16 @@
-import { ScatterRequestOptions, ScatterResponse } from '@carto/api-client';
-declare const useScatter: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<ScatterRequestOptions, ScatterResponse>) => import('@tanstack/react-query').UseQueryResult<ScatterResponse, Error>, ScatterModel: ({ children, ...modelProps }: import('./types').ModelProps<ScatterRequestOptions, ScatterResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<ScatterResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { ScatterResponse } from '@carto/api-client';
+import { ScatterWidgetProps } from './types';
+declare const useScatter: <P extends import('./types').ModelProps<ScatterWidgetProps, ScatterResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<ScatterResponse> : import('./types').ModelResponse<ScatterResponse[]>, ScatterModel: {
+    (props: import('./types').ModelProps<ScatterWidgetProps, ScatterResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<ScatterResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<ScatterWidgetProps, ScatterResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<ScatterResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useScatter, ScatterModel };

package/dist/types/models/table.d.ts

@@ -1,5 +1,16 @@
-import { TableRequestOptions, TableResponse } from '@carto/api-client';
-declare const useTable: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<TableRequestOptions, TableResponse>) => import('@tanstack/react-query').UseQueryResult<TableResponse, Error>, TableModel: ({ children, ...modelProps }: import('./types').ModelProps<TableRequestOptions, TableResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<TableResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { TableResponse } from '@carto/api-client';
+import { TableWidgetProps } from './types';
+declare const useTable: <P extends import('./types').ModelProps<TableWidgetProps, TableResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<TableResponse> : import('./types').ModelResponse<TableResponse[]>, TableModel: {
+    (props: import('./types').ModelProps<TableWidgetProps, TableResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<TableResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<TableWidgetProps, TableResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<TableResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useTable, TableModel };

package/dist/types/models/time-series.d.ts

@@ -1,5 +1,16 @@
-import { TimeSeriesRequestOptions, TimeSeriesResponse } from '@carto/api-client';
-declare const useTimeSeries: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: import('./types').ModelProps<TimeSeriesRequestOptions, TimeSeriesResponse>) => import('@tanstack/react-query').UseQueryResult<TimeSeriesResponse, Error>, TimeSeriesModel: ({ children, ...modelProps }: import('./types').ModelProps<TimeSeriesRequestOptions, TimeSeriesResponse> & {
-    children: (props: import('@tanstack/react-query').UseQueryResult<TimeSeriesResponse, Error>) => React.ReactNode;
-}) => import('react').ReactNode;
+import { TimeSeriesResponse } from '@carto/api-client';
+import { TimeSeriesWidgetProps } from './types';
+declare const useTimeSeries: <P extends import('./types').ModelProps<TimeSeriesWidgetProps, TimeSeriesResponse>>(props: P) => P extends {
+    sourceId: string;
+    sourcesId?: string[];
+} ? import('./types').ModelResponse<TimeSeriesResponse> : import('./types').ModelResponse<TimeSeriesResponse[]>, TimeSeriesModel: {
+    (props: import('./types').ModelProps<TimeSeriesWidgetProps, TimeSeriesResponse> & {
+        sourceId: string;
+        children: (props: import('./types').ModelResponse<TimeSeriesResponse>) => React.ReactNode;
+    }): React.ReactElement;
+    (props: import('./types').ModelProps<TimeSeriesWidgetProps, TimeSeriesResponse> & {
+        sourcesId: string[];
+        children: (props: import('./types').ModelResponse<TimeSeriesResponse[]>) => React.ReactNode;
+    }): React.ReactElement;
+};
 export { useTimeSeries, TimeSeriesModel };

package/dist/types/models/types.d.ts

@@ -1,9 +1,168 @@
-import { AddFilterOptions } from '@carto/api-client';
-import { UseQueryOptions } from '@tanstack/react-query';
-export interface ModelProps<T, R> {
+import { RefetchOptions, UseQueryResult, UseQueryOptions } from '@tanstack/react-query';
+import { AddFilterOptions, FormulaRequestOptions, CategoryRequestOptions, TimeSeriesRequestOptions, HistogramRequestOptions, AggregationsRequestOptions, RangeRequestOptions, ScatterRequestOptions, TableRequestOptions, FeaturesRequestOptions } from '@carto/api-client';
+/**
+ * Helper type for multi-value support in Formula widget props.
+ * Formula has: column (optional), operationExp (optional)
+ *
+ * @since 4.6.0
+ */
+export type FormulaWidgetProps = Omit<FormulaRequestOptions, 'filters' | 'column' | 'operationExp'> & {
+    column?: string | string[];
+    operationExp?: string | string[];
+};
+/**
+ * Helper type for multi-value support in Category widget props.
+ * Category has: column (required), operationExp (optional), operationColumn (optional)
+ *
+ * @since 4.6.0
+ */
+export type CategoryWidgetProps = Omit<CategoryRequestOptions, 'filters' | 'column' | 'operationExp' | 'operationColumn'> & {
+    column: string | string[];
+    operationExp?: string | string[];
+    operationColumn?: string | string[];
+};
+/**
+ * Helper type for multi-value support in TimeSeries widget props.
+ * TimeSeries has: column (required), operationExp (optional), operationColumn (optional)
+ *
+ * @since 4.6.0
+ */
+export type TimeSeriesWidgetProps = Omit<TimeSeriesRequestOptions, 'filters' | 'column' | 'operationExp' | 'operationColumn'> & {
+    column: string | string[];
+    operationExp?: string | string[];
+    operationColumn?: string | string[];
+};
+/**
+ * Helper type for multi-value support in Histogram widget props.
+ * Histogram has: column (required), NO operationExp, NO operationColumn
+ *
+ * @since 4.6.0
+ */
+export type HistogramWidgetProps = Omit<HistogramRequestOptions, 'filters' | 'column'> & {
+    column: string | string[];
+};
+/**
+ * Helper type for multi-value support in Aggregations widget props.
+ * Aggregations has: aggregations (array/string), NO column, NO operationExp
+ *
+ * @since 4.6.0
+ */
+export type AggregationsWidgetProps = Omit<AggregationsRequestOptions, 'filters'>;
+/**
+ * Helper type for multi-value support in Range widget props.
+ * Range has: column (required), NO operationExp, NO operationColumn
+ *
+ * @since 4.6.0
+ */
+export type RangeWidgetProps = Omit<RangeRequestOptions, 'filters' | 'column'> & {
+    column: string | string[];
+};
+/**
+ * Helper type for multi-value support in Scatter widget props.
+ * Scatter has: xColumn, yColumn (both required), NO operationExp
+ *
+ * @since 4.6.0
+ */
+export type ScatterWidgetProps = Omit<ScatterRequestOptions, 'filters' | 'xColumn' | 'yColumn'> & {
+    xColumn: string | string[];
+    yColumn: string | string[];
+};
+/**
+ * Helper type for multi-value support in Table widget props.
+ * Table has: columns (optional array), NO operationExp
+ *
+ * @since 4.6.0
+ */
+export type TableWidgetProps = Omit<TableRequestOptions, 'filters'>;
+/**
+ * Helper type for multi-value support in Features widget props.
+ * Features has: NO column, NO operationExp
+ *
+ * @since 4.6.0
+ */
+export type FeaturesWidgetProps = Omit<FeaturesRequestOptions, 'filters'>;
+/**
+ * @deprecated Use specific widget props types (FormulaWidgetProps, CategoryWidgetProps, etc.) instead.
+ * This generic type assumes all widgets have the same properties, which is incorrect.
+ * @since 4.5.0
+ */
+export type WidgetPropsWithMultiColumn<T> = Omit<T, 'filters' | 'column' | 'operationExp' | 'operationColumn'> & {
+    column?: string | string[];
+    operationExp?: string | string[];
+    operationColumn?: string | string[];
+};
+/**
+ * Props for CARTO model components and hooks.
+ *
+ * @template W - Widget-specific props type (FormulaWidgetProps, CategoryWidgetProps, etc.)
+ * @template R - Widget response data type
+ *
+ * @remarks
+ * All CARTO model components (FormulaModel, CategoriesModel, etc.) use these props.
+ * Supports both single-source and multi-source queries with flexible column configuration.
+ *
+ * @example
+ * ```tsx
+ * Single source (deprecated)
+ * <FormulaModel
+ *   accessToken={token}
+ *   sourceId="sales"
+ *   widgetProps={{ column: 'revenue', operation: 'sum' }}
+ * />
+ *
+ * Multiple sources (recommended)
+ * <FormulaModel
+ *   accessToken={token}
+ *   sourcesId={['sales_2023', 'sales_2024']}
+ *   widgetProps={{ column: 'revenue', operation: 'sum' }}
+ * />
+ *
+ * Multiple sources with different columns
+ * <FormulaModel
+ *   accessToken={token}
+ *   sourcesId={['sales', 'inventory', 'customers']}
+ *   widgetProps={{
+ *     column: ['total_sales', 'stock_count', 'active_users'],
+ *     operation: 'sum'
+ *   }}
+ * />
+ * ```
+ *
+ * @since 4.6.0 - Changed to use specific widget props types
+ */
+export type ModelProps<W, R> = {
+    /** CARTO API access token for authentication */
     accessToken: string;
-    sourceId: string;
-    widgetProps: Omit<T, 'filters'>;
-    additionalFilter?: AddFilterOptions[];
+    /** Widget-specific configuration with multi-value support for applicable properties */
+    widgetProps: W;
+    /** Optional additional filters to apply to the query */
+    additionalFilter?: AddFilterOptions[] | AddFilterOptions[][];
+    /** React Query configuration options */
     useQueryProps?: Omit<UseQueryOptions<R>, 'queryKey' | 'queryFn'>;
-}
+} & ({
+    /**
+     * @deprecated Use `sourcesId` instead. Will be removed in v5.0.0.
+     * @see {@link sourcesId}
+     */
+    sourceId: string;
+    /**
+     * Array of source identifiers for multi-source queries (recommended).
+     * @since 4.0.0
+     */
+    sourcesId?: string[];
+} | {
+    /**
+     * @deprecated Use `sourcesId` instead. Will be removed in v5.0.0.
+     * @see {@link sourcesId}
+     */
+    sourceId?: string;
+    /**
+     * Array of source identifiers for multi-source queries (recommended).
+     * @since 4.0.0
+     */
+    sourcesId: string[];
+});
+export type ModelResponse<T = unknown[]> = Pick<UseQueryResult<T, Error>, 'data' | 'error' | 'isLoading' | 'isFetching' | 'isError' | 'isSuccess' | 'status' | 'fetchStatus' | 'isPending' | 'isStale' | 'isRefetching' | 'isFetched' | 'isFetchedAfterMount' | 'isRefetchError' | 'isLoadingError' | 'isPlaceholderData' | 'failureCount' | 'dataUpdatedAt' | 'errorUpdatedAt' | 'isPaused' | 'failureReason' | 'errorUpdateCount' | 'isEnabled'> & {
+    promise: Promise<T[]>[];
+    refetch: () => Promise<RefetchOptions[]>;
+};

package/dist/types/models/utils/create-model.d.ts

@@ -1,17 +1,26 @@
-import { UseQueryResult } from '@tanstack/react-query';
-import { ModelProps } from '../types';
+import { ModelProps, ModelResponse } from '../types';
 import { useCommonModel } from './use-common-model';
-interface ModelConfig<TRequestOptions, TResponse> {
+interface ModelConfig<TRequestOptions extends object, TResponse> {
     queryKeyPrefix: string[];
-    getWidgetMethod: (widgetModel: NonNullable<ReturnType<typeof useCommonModel>['widgetModel']>) => (params: TRequestOptions & {
+    getWidgetMethod: (widgetModel: NonNullable<NonNullable<ReturnType<typeof useCommonModel>['widgetModel']>[0]>) => (params: TRequestOptions & {
         filters?: unknown;
         signal?: AbortSignal;
     }) => Promise<TResponse>;
 }
-export declare function createModel<TRequestOptions, TResponse>({ queryKeyPrefix, getWidgetMethod, }: ModelConfig<TRequestOptions, TResponse>): {
-    useModelHook: ({ accessToken, sourceId, widgetProps, additionalFilter, useQueryProps: { enabled, ...useQueryProps }, }: ModelProps<TRequestOptions, TResponse>) => UseQueryResult<import('@tanstack/react-query').NoInfer<TResponse>, Error>;
-    ModelComponent: ({ children, ...modelProps }: ModelProps<TRequestOptions, TResponse> & {
-        children: (props: UseQueryResult<TResponse, Error>) => React.ReactNode;
-    }) => import('react').ReactNode;
+export declare function createModel<TWidgetProps extends object, TResponse>({ queryKeyPrefix, getWidgetMethod, }: ModelConfig<TWidgetProps, TResponse>): {
+    useModelHook: <P extends ModelProps<TWidgetProps, TResponse>>(props: P) => P extends {
+        sourceId: string;
+        sourcesId?: string[];
+    } ? ModelResponse<TResponse> : ModelResponse<TResponse[]>;
+    ModelComponent: {
+        (props: ModelProps<TWidgetProps, TResponse> & {
+            sourceId: string;
+            children: (props: ModelResponse<TResponse>) => React.ReactNode;
+        }): React.ReactElement;
+        (props: ModelProps<TWidgetProps, TResponse> & {
+            sourcesId: string[];
+            children: (props: ModelResponse<TResponse[]>) => React.ReactNode;
+        }): React.ReactElement;
+    };
 };
 export {};

package/dist/types/models/utils/resolve-property-for-source.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Resolves a property value for a specific source index
+ * @param value - Single string value or array of values
+ * @param sourceIndex - Index of the current source
+ * @param totalSources - Total number of sources
+ * @param propertyName - Name of the property being resolved (for error messages)
+ * @returns The resolved string value for the source
+ * @internal
+ */
+export declare function resolvePropertyForSource(value: string | string[] | undefined, sourceIndex: number, totalSources: number, propertyName: string): string | undefined;
+/**
+ * Resolves the column value for a specific source index
+ * @param column - Single column string or array of columns
+ * @param sourceIndex - Index of the current source
+ * @param totalSources - Total number of sources
+ * @returns The resolved column string for the source
+ * @internal
+ */
+export declare function resolveColumnForSource(column: string | string[] | undefined, sourceIndex: number, totalSources: number): string | undefined;

package/dist/types/models/utils/use-common-model.d.ts

@@ -1,8 +1,27 @@
 import { ModelProps } from '../types';
-export declare function useCommonModel<TRequestOptions, TResponse>({ queryKeyPrefix, accessToken, sourceId, widgetProps, additionalFilter, }: Pick<ModelProps<TRequestOptions, TResponse>, 'accessToken' | 'sourceId' | 'additionalFilter' | 'widgetProps'> & {
+import { useWidgetModel } from './use-widget-model';
+import { Filter } from '@carto/api-client';
+type CommonModelArgs<TRequestOptions, TResponse> = Pick<ModelProps<TRequestOptions, TResponse>, 'accessToken' | 'widgetProps' | 'additionalFilter'> & {
     queryKeyPrefix: string[];
-}): {
-    mergedFilters: {} | undefined;
-    widgetModel: import('@carto/api-client').WidgetQuerySource | import('@carto/api-client').WidgetTilesetSource<import('@carto/api-client').WidgetTilesetSourceProps> | import('@carto/api-client').WidgetTableSource | null;
-    queryKey: unknown[];
 };
+type SingleSourceArgs<TRequestOptions, TResponse> = CommonModelArgs<TRequestOptions, TResponse> & {
+    sourceId: string;
+    sourcesId?: never;
+};
+type MultiSourceArgs<TRequestOptions, TResponse> = CommonModelArgs<TRequestOptions, TResponse> & {
+    sourceId?: never;
+    sourcesId: string[];
+};
+interface SingleSourceResult {
+    mergedFilters: Filter | undefined;
+    widgetModel: ReturnType<typeof useWidgetModel>[0] | null;
+    queryKey: readonly unknown[];
+}
+interface MultiSourceResult {
+    mergedFilters: (Filter | undefined)[];
+    widgetModel: ReturnType<typeof useWidgetModel>;
+    queryKey: unknown[][];
+}
+export declare function useCommonModel<TRequestOptions extends object, TResponse>(args: SingleSourceArgs<TRequestOptions, TResponse>): SingleSourceResult;
+export declare function useCommonModel<TRequestOptions extends object, TResponse>(args: MultiSourceArgs<TRequestOptions, TResponse>): MultiSourceResult;
+export {};

package/dist/types/models/utils/use-common-model.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/models/utils/use-filters-merged.d.ts

@@ -1,2 +1,16 @@
-import { AddFilterOptions } from '@carto/api-client';
-export declare function useFiltersMerged(sourceId: string, additionalFilter?: AddFilterOptions[]): {} | undefined;
+import { Filter, AddFilterOptions } from '@carto/api-client';
+interface SingleSourceFilterArgs {
+    sourceId: string;
+    sourcesId?: never;
+    additionalFilter?: AddFilterOptions[];
+}
+interface MultiSourceFilterArgs {
+    sourceId?: never;
+    sourcesId: string[];
+    additionalFilter?: AddFilterOptions[] | AddFilterOptions[][];
+}
+export declare function useFiltersMerged(sourceId: string, additionalFilter?: AddFilterOptions[]): Filter | undefined;
+export declare function useFiltersMerged(sourcesId: string[], additionalFilter?: AddFilterOptions[] | AddFilterOptions[][]): Filter[] | undefined;
+export declare function useFiltersMerged(args: SingleSourceFilterArgs): Filter | undefined;
+export declare function useFiltersMerged(args: MultiSourceFilterArgs): Filter[] | undefined;
+export {};

package/dist/types/models/utils/use-query-key.d.ts

@@ -1,4 +1,15 @@
 import { ModelProps } from '../types';
-export declare function useQueryKey<TRequestOptions, TResponse>({ queryKeyPrefix, sourceId, }: Pick<ModelProps<TRequestOptions, TResponse>, 'sourceId'> & {
+type QueryKeyArgs<TRequestOptions, TResponse> = Pick<ModelProps<TRequestOptions, TResponse>, never> & {
     queryKeyPrefix: string[];
-}): unknown[];
+};
+type SingleSourceQueryArgs<TRequestOptions, TResponse> = QueryKeyArgs<TRequestOptions, TResponse> & {
+    sourceId: string | undefined;
+    sourcesId?: never;
+};
+type MultiSourceQueryArgs<TRequestOptions, TResponse> = QueryKeyArgs<TRequestOptions, TResponse> & {
+    sourceId?: never;
+    sourcesId: string[];
+};
+export declare function useQueryKey<TRequestOptions, TResponse>(args: SingleSourceQueryArgs<TRequestOptions, TResponse>): readonly unknown[];
+export declare function useQueryKey<TRequestOptions, TResponse>(args: MultiSourceQueryArgs<TRequestOptions, TResponse>): unknown[][];
+export {};

package/dist/types/models/utils/use-query-key.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/models/utils/use-widget-model.d.ts

@@ -1 +1,18 @@
-export declare function useWidgetModel(accessToken: string, sourceId: string): import('@carto/api-client').WidgetQuerySource | import('@carto/api-client').WidgetTilesetSource<import('@carto/api-client').WidgetTilesetSourceProps> | import('@carto/api-client').WidgetTableSource | null;
+import { useSources } from '../../providers/sources/store';
+type SourceWidget = ReturnType<typeof useSources>[0]['widgets'];
+type WidgetModelResult = SourceWidget | null;
+interface SingleSourceWidgetArgs {
+    accessToken: string;
+    sourceId: string;
+    sourcesId?: never;
+}
+interface MultiSourceWidgetArgs {
+    accessToken: string;
+    sourceId?: never;
+    sourcesId: string[];
+}
+export declare function useWidgetModel(accessToken: string, sourceId: string): WidgetModelResult;
+export declare function useWidgetModel(accessToken: string, sourcesId: string[]): WidgetModelResult[];
+export declare function useWidgetModel(args: SingleSourceWidgetArgs): WidgetModelResult;
+export declare function useWidgetModel(args: MultiSourceWidgetArgs): WidgetModelResult[];
+export {};

package/dist/types/models/utils/use-widget-model.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/layers/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/map/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/sources/store.d.ts

@@ -23,12 +23,19 @@ export declare const useSourceStore: import('zustand').UseBoundStore<Omit<import
  * @returns source object without filters
  */
 export declare function useSource<T extends AllSources = AllExternalSources>(id: string): Source<T>;
+/**
+ * Shortcut to grabbing the source from the sources store object
+ * @param ids - the ids of the sources you want to grab
+ * @returns source object without filters
+ */
+export declare function useSources<T extends AllSources = AllExternalSources>(ids: string[]): Source<T>[];
 /**
  * Shortcut to grabbing the filters from the filters store object
- * @param id - the id of the source the filters are applied to
+ * @param ids - the ids of the sources the filters are applied to
  * @returns filters object as used in the `@carto/api-client` methods calls
  */
-export declare function useFilters(id: string): Filters | undefined;
+export declare function useFilters(ids: string): Filters | undefined;
+export declare function useFilters(ids: string[]): (Filters | undefined)[];
 /**
  * Returns a source together with its filters, pulling from the separate `sources` and `filters` state objects
  * @param id - the id of the source

package/dist/types/providers/sources/widgets/geojson-features.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/sources/widgets/widget-geojson-source-impl.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/sources/widgets/widget-geojson-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/stats/get-query-stats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/stats/get-table-stats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/mapping-meridian.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/sort-layers.test.d.ts

@@ -0,0 +1 @@
+export {};