@cubejs-client/react 1.7.13 → 1.7.14

package/dist/types.d.ts

@@ -0,0 +1,765 @@
+/**
+ * Types of `@cubejs-client/react`.
+ *
+ * Everything exported from `src/index.ts` is part of the published API: the
+ * declarations shipped in `dist` are emitted from these sources, so a change
+ * here is a change to what consumers see.
+ */
+import type * as React from 'react';
+import type { BinaryOperator, CacheMode, CubeApi, DateRange, DeeplyReadonly, DryRunResponse, Filter, FilterOperator, LoadMethodOptions, MemberType, Meta, PivotConfig, ProgressResponse, Query, QueryOrder, RequestError, ResultSet, SqlQuery, TCubeDimension, TCubeMeasure, TCubeSegment, TimeDimension, TimeDimensionGranularity, TOrderMember, TSourceAxis, UnaryOperator } from '@cubejs-client/core';
+/**
+ * Object the API methods store their MUTEX in.
+ */
+export type MutexObj = NonNullable<LoadMethodOptions['mutexObj']>;
+/**
+ * A query as accepted by `useCubeQuery`.
+ */
+export type ReadonlyQueryInput = DeeplyReadonly<Query | Query[]>;
+export type CubeProviderOptions = {
+    castNumerics?: boolean;
+};
+export type CubeProviderProps = {
+    cubeApi: CubeApi | null;
+    options?: CubeProviderOptions;
+    children: React.ReactNode;
+};
+export type CubeContextProps = {
+    cubeApi: CubeApi;
+    options?: CubeProviderOptions;
+};
+export type TLoadingState = {
+    isLoading: boolean;
+};
+export type ChartType = 'line' | 'bar' | 'table' | 'area' | 'number' | 'pie';
+export type VizState = {
+    query?: Query;
+    pivotConfig?: PivotConfig;
+    chartType?: ChartType;
+};
+export type QueryRendererRenderProps = {
+    resultSet: ResultSet | null;
+    error: Error | null;
+    loadingState: TLoadingState;
+    sqlQuery: SqlQuery | null;
+};
+export type QueryRendererProps = {
+    /**
+     * Analytic query. [Learn more about it's format](/product/apis-integrations/rest-api/query-format)
+     */
+    query: Query | Query[];
+    queries?: {
+        [key: string]: Query;
+    };
+    /**
+     * Indicates whether the generated by `Cube.js` SQL Code should be requested. See [rest-api#sql](/reference/rest-api#v1sql). When set to `only` then only the request to [/v1/sql](/reference/rest-api#v1sql) will be performed. When set to `true` the sql request will be performed along with the query request. Will not be performed if set to `false`
+     */
+    loadSql?: 'only' | boolean;
+    /**
+     * When `true` the **resultSet** will be reset to `null` first on every state change
+     */
+    resetResultSetOnChange?: boolean;
+    updateOnlyOnStateChange?: boolean;
+    /**
+     * `CubeApi` instance to use
+     */
+    cubeApi?: CubeApi;
+    /**
+     * Server-side cache policy for query execution. Does not control client-side caching.
+     */
+    cache?: CacheMode;
+    /**
+     * Output of this function will be rendered by the `QueryRenderer`
+     */
+    render: (renderProps: QueryRendererRenderProps) => void;
+    /**
+     * @hidden
+     */
+    children?: never;
+};
+/**
+ * `resultSet` holds a map of result sets keyed by query name when the `queries`
+ * prop is used, and a single result set otherwise.
+ *
+ * @hidden
+ */
+export type QueryRendererState = {
+    isLoading?: boolean;
+    error?: RequestError | null;
+    sqlQuery?: SqlQuery | null;
+    resultSet?: ResultSet | {
+        [key: string]: ResultSet;
+    } | null;
+    /**
+     * Never assigned — `render()` has always read it from state rather than from
+     * props, so the empty-object fallback for `resultSet` does not kick in.
+     */
+    queries?: {
+        [key: string]: Query;
+    };
+};
+export type QueryRendererWithTotalsProps = Omit<QueryRendererProps, 'queries' | 'query'> & {
+    query: Query;
+};
+/**
+ * What `QueryRenderer` passes to its render prop. `resultSet`,
+ * `loadingState.isLoading` and `sqlQuery` are only set once a request resolves.
+ *
+ * @hidden
+ */
+export type QueryRendererLoadState = {
+    error: Error | null;
+    resultSet: ResultSet | {
+        [key: string]: ResultSet;
+    } | null | undefined;
+    loadingState: {
+        isLoading?: boolean;
+    };
+    sqlQuery: SqlQuery | null | undefined;
+};
+/**
+ * @hidden
+ */
+export type SchemaChangeProps = {
+    schemaVersion: number;
+    refresh: () => Promise<void>;
+};
+export type QueryBuilderState = VizState & {
+    query?: Query;
+};
+export type QueryBuilderProps = {
+    /**
+     * `CubeApi` instance to use
+     */
+    cubeApi?: CubeApi;
+    /**
+     * State for the QueryBuilder to start with. Pass in the value previously saved from onVizStateChanged to restore a session.
+     */
+    initialVizState?: VizState;
+    /**
+     * Called by the `QueryBuilder` when the viz state has changed. Use it to save state outside of the `QueryBuilder` component.
+     */
+    onVizStateChanged?: (vizState: VizState) => void;
+    /**
+     * @default defaultChartType line (used when initialVizState is not set or does not contain chartType)
+     */
+    defaultChartType?: ChartType;
+    /**
+     * Default query (used when initialVizState is not set or does not contain query)
+     */
+    defaultQuery?: Query;
+    /**
+     * Defaults to `false`. This means that the default heuristics will be applied. For example: when the query is empty and you select a measure that has a default time dimension it will be pushed to the query.
+     * @default disableHeuristics false
+     */
+    disableHeuristics?: boolean;
+    wrapWithQueryRenderer?: boolean;
+    render: (renderProps: QueryBuilderRenderProps) => React.ReactNode;
+    /**
+     * A function that accepts the `newState` just before it's applied. You can use it to override the **defaultHeuristics** or to tweak the query or the vizState in any way.
+     */
+    stateChangeHeuristics?: (state: QueryBuilderState, newState: QueryBuilderState) => QueryBuilderState;
+    /**
+     * @ignore @deprecated Controlled query
+     */
+    query?: Query;
+    /**
+     * @ignore @deprecated Controlled query setter
+     */
+    setQuery?: (query: Query) => void;
+    /**
+     * @ignore @deprecated Controlled vizState
+     */
+    vizState?: VizState;
+    /**
+     * @ignore @deprecated Controlled vizState setter
+     */
+    setVizState?: (vizState: VizState) => void;
+    /**
+     * @hidden
+     */
+    schemaVersion?: number;
+    /**
+     * @hidden
+     */
+    queryVersion?: number | string;
+    /**
+     * @hidden
+     */
+    onSchemaChange?: (props: SchemaChangeProps) => void;
+};
+export type QueryBuilderRenderProps = {
+    resultSet?: ResultSet | null;
+    error?: Error | null;
+    loadingState?: TLoadingState;
+    meta: Meta | undefined;
+    metaError?: Error | null;
+    richMetaError?: Error | null;
+    metaErrorStack?: string | null;
+    isFetchingMeta: boolean;
+    /**
+     * Indicates whether the query is ready to be displayed or not
+     */
+    isQueryPresent: boolean;
+    measures: (TCubeMeasure & {
+        index: number;
+    })[];
+    dimensions: (TCubeDimension & {
+        index: number;
+    })[];
+    segments: (TCubeSegment & {
+        index: number;
+    })[];
+    timeDimensions: (TimeDimensionWithExtraFields & {
+        index: number;
+    })[];
+    availableMembers: AvailableMembers;
+    availableFilterMembers: Array<AvailableCube<TCubeMeasure> | AvailableCube<TCubeDimension>>;
+    /**
+     * An array of available measures to select. They are loaded via the API from Cube.js Backend.
+     */
+    availableMeasures: TCubeMeasure[];
+    /**
+     * An array of available dimensions to select. They are loaded via the API from Cube.js Backend.
+     */
+    availableDimensions: TCubeDimension[];
+    /**
+     * An array of available time dimensions to select. They are loaded via the API from Cube.js Backend.
+     */
+    availableTimeDimensions: TCubeDimension[];
+    /**
+     * An array of available segments to select. They are loaded via the API from Cube.js Backend.
+     */
+    availableSegments: TCubeSegment[];
+    updateMeasures: MeasureUpdater;
+    updateDimensions: DimensionUpdater;
+    updateSegments: SegmentUpdater;
+    updateTimeDimensions: TimeDimensionUpdater;
+    updateFilters: FilterUpdater;
+    /**
+     * Used for partial of full query update
+     */
+    updateQuery: (query: Query) => void;
+    filters: (FilterWithExtraFields & {
+        index: number;
+    })[];
+    /**
+     * All possible order members for the query
+     */
+    orderMembers: TOrderMember[];
+    /**
+     * Used for query order update
+     */
+    updateOrder: OrderUpdater;
+    /**
+     * See [Pivot Config](@cubejs-client-core#types-pivot-config)
+     */
+    pivotConfig?: PivotConfig;
+    /**
+     * Helper method for `pivotConfig` updates
+     */
+    updatePivotConfig: PivotConfigUpdater;
+    /**
+     * Selected chart type
+     */
+    chartType?: ChartType;
+    /**
+     * Used for chart type update
+     */
+    updateChartType: (chartType: ChartType) => void;
+    /**
+     * Used to set the initial query for this component. Note that adding this prop turns this into an
+     * uncontrolled component and will only be able to execute `dryRun` queries. To use this component
+     * as a controlled component, use `setQuery` instead.
+     */
+    query: Query;
+    validatedQuery: Query;
+    refresh: () => void;
+    missingMembers: string[];
+    dryRunResponse?: DryRunResponse;
+};
+/**
+ * The state `QueryBuilder` keeps. It is a superset of `QueryBuilderState`:
+ * everything beyond `query`, `pivotConfig` and `chartType` is internal
+ * bookkeeping.
+ *
+ * @hidden
+ */
+export type QueryBuilderInternalState = QueryBuilderState & {
+    query: Query;
+    validatedQuery?: Query;
+    missingMembers: string[];
+    isFetchingMeta: boolean;
+    dryRunResponse?: DryRunResponse | null;
+    meta?: Meta;
+    metaError?: Error | null;
+    richMetaError?: Error | null;
+    metaErrorStack?: string | null;
+    queryError?: Error | null;
+    richQueryError?: Error | null;
+    sessionGranularity?: TimeDimensionGranularity | null;
+    shouldApplyHeuristicOrder?: boolean;
+};
+/**
+ * A state update on its way through `updateVizState`. Heuristics may return a
+ * partial state, and the missing pieces are filled in before it is applied.
+ *
+ * @hidden
+ */
+export type QueryBuilderStateUpdate = Partial<QueryBuilderInternalState>;
+/**
+ * @hidden
+ */
+export type QueryMemberType = MemberType | 'timeDimensions';
+/**
+ * State `QueryBuilder.resolveMember` resolves members against.
+ *
+ * @hidden
+ */
+export type ResolveMemberArgs = {
+    meta?: Meta;
+    query: Query | Query[];
+};
+/**
+ * Resolved query members carry the position they hold in the query.
+ *
+ * @hidden
+ */
+export type IndexedMeasure = TCubeMeasure & {
+    index: number;
+};
+/**
+ * @hidden
+ */
+export type IndexedDimension = TCubeDimension & {
+    index: number;
+};
+/**
+ * @hidden
+ */
+export type IndexedSegment = TCubeSegment & {
+    index: number;
+};
+export type AvailableMembers = {
+    measures: AvailableCube<TCubeMeasure>[];
+    dimensions: AvailableCube<TCubeDimension>[];
+    segments: AvailableCube<TCubeSegment>[];
+    timeDimensions: AvailableCube<TCubeDimension>[];
+};
+export type AvailableCube<T = any> = {
+    type: 'cube' | 'view';
+    public: boolean;
+    cubeName: string;
+    cubeTitle: string;
+    members: T[];
+};
+export type UseCubeQueryOptions = {
+    /**
+     * A `CubeApi` instance to use. Taken from the context if the param is not passed
+     */
+    cubeApi?: CubeApi;
+    /**
+     * Query execution will be skipped when `skip` is set to `true`. You can use this flag to avoid sending incomplete queries.
+     */
+    skip?: boolean;
+    /**
+     * Use continuous fetch behavior. See [Real-Time Data Fetch](/product/apis-integrations/rest-api/real-time-data-fetch)
+     */
+    subscribe?: boolean;
+    /**
+     * When `true` the resultSet will be reset to `null` first
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * If enabled, all members of the 'number' type will be automatically converted to numerical values on the client side
+     */
+    castNumerics?: boolean;
+    /**
+     * Server-side cache policy for query execution. Does not control client-side caching.
+     */
+    cache?: CacheMode;
+};
+/**
+ * `ResultSet` constrains its data to `Record<string, any>`, while `Data` is
+ * unconstrained here, as it is in `useCubeQuery`.
+ */
+type ResultSetData<Data> = Data extends Record<string, any> ? Data : any;
+export type UseCubeQueryResult<QueryInput, Data> = {
+    error: Error | null;
+    isLoading: boolean;
+    resultSet: ResultSet<ResultSetData<Data>> | null;
+    /**
+     * Set from the `Continue wait` messages of a long-running query.
+     *
+     * Note: this is `null` until the first such message arrives — the type is
+     * kept non-nullable for backwards compatibility, so read it with `progress?.`
+     */
+    progress: ProgressResponse;
+    /**
+     * The query the current `resultSet` was loaded for.
+     *
+     * Note: this is `null` until the first query runs — the type is kept
+     * non-nullable for backwards compatibility.
+     */
+    previousQuery: QueryInput;
+    refetch: () => Promise<void>;
+};
+/**
+ * What `useCubeQuery` builds, with `progress` and `previousQuery` as they
+ * actually are before the first response.
+ *
+ * @hidden
+ */
+export type UseCubeQueryInternalResult = {
+    error: Error | null;
+    isLoading: boolean;
+    resultSet: ResultSet | null;
+    progress: ProgressResponse | null;
+    previousQuery: ReadonlyQueryInput | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * @hidden
+ */
+export type CubeFetchOptions = {
+    skip?: boolean;
+    cubeApi?: CubeApi;
+    query?: Query;
+};
+/**
+ * @hidden
+ */
+export type CubeFetchResult<T> = {
+    isLoading: boolean;
+    error: Error | null;
+    /**
+     * The response of the last request.
+     *
+     * Note: this is `null` until the first request resolves — the type is kept
+     * non-nullable for backwards compatibility, so check `isLoading` first.
+     */
+    response: T;
+};
+/**
+ * The result of `useCubeMeta`, `useCubeSql` and `useDryRun`: a
+ * `CubeFetchResult` plus the `refetch` they expose.
+ */
+export type UseCubeFetchResult<T> = CubeFetchResult<T> & {
+    refetch: (options?: UseCubeFetchLoadOptions) => Promise<void>;
+};
+/**
+ * What `useCubeFetch` returns before the first request resolves.
+ *
+ * @hidden
+ */
+export type UseCubeFetchInternalResult<T> = CubeFetchState<T> & {
+    error: Error | null;
+    refetch: (options?: UseCubeFetchLoadOptions) => Promise<void>;
+};
+/**
+ * @hidden
+ */
+export type UseDryRunResult = CubeFetchResult<DryRunResponse>;
+/**
+ * @hidden
+ */
+export type UseCubeSqlResponse = {
+    sql: string;
+};
+/**
+ * What `useCubeSql` resolves with. Its declared `response` is a
+ * `DryRunResponse` for backwards compatibility; cast to this to get at the
+ * `SqlQuery` it actually resolves with.
+ */
+export type UseCubeSqlResult = UseCubeFetchResult<SqlQuery>;
+/**
+ * @hidden
+ */
+export type LoadLazyDryRunOptions = {
+    query?: Query | Query[];
+};
+/**
+ * `CubeApi` methods `useCubeFetch` can dispatch to.
+ *
+ * @hidden
+ */
+export type CubeFetchMethod = 'meta' | 'sql' | 'dryRun';
+/**
+ * Options of `useCubeSql`, `useDryRun` and `useLazyDryRun`. Unlike
+ * `CubeFetchOptions` they accept an array of queries and a `baseRequestId`.
+ */
+export type UseCubeFetchOptions = Omit<CubeFetchOptions, 'query'> & {
+    query?: Query | Query[];
+    baseRequestId?: string;
+    onlyViews?: boolean;
+};
+/**
+ * The query a `refetch` — or `useLazyDryRun`'s loader — runs instead of the one
+ * the hook was called with.
+ */
+export type UseCubeFetchLoadOptions = {
+    query?: Query | Query[];
+    onlyViews?: boolean;
+};
+/**
+ * @hidden
+ */
+export type CubeMetaFetchOptions = Omit<CubeFetchOptions, 'query'> & {
+    /**
+     * Request views only — the response's `cubes` array then contains only entries
+     * whose `type` is `view`. Over HTTP, servers predating the flag ignore it and
+     * return the full model, so callers should not assume the response is filtered;
+     * over `WebSocketTransport` such servers reject the message with a 400.
+     */
+    onlyViews?: boolean;
+    /**
+     * @hidden
+     */
+    baseRequestId?: string;
+};
+/**
+ * What `useCubeFetch` keeps in state.
+ *
+ * @hidden
+ */
+export type CubeFetchState<T> = {
+    isLoading: boolean;
+    response: T | null;
+};
+/**
+ * Arguments the dispatched `CubeApi` method is called with: `meta` takes only
+ * options, `sql` and `dryRun` take a query as well.
+ *
+ * @hidden
+ */
+export type CubeFetchArgs = [LoadMethodOptions] | [Query | Query[], LoadMethodOptions];
+/**
+ * The `CubeApi` method `useCubeFetch` dispatches to. The three methods share
+ * neither their signatures nor their response type, so the response is narrowed
+ * by the caller.
+ *
+ * @hidden
+ */
+export type CubeFetchDispatch = (this: CubeApi, ...args: CubeFetchArgs) => Promise<unknown>;
+/**
+ * `ProgressResult` keeps `progressResponse` private, but `useCubeQuery` has
+ * always read it to expose the raw response.
+ *
+ * @hidden
+ */
+export type ProgressResultWithResponse = {
+    progressResponse: ProgressResponse;
+};
+/**
+ * @hidden
+ */
+export type ProgressCallback = NonNullable<LoadMethodOptions['progressCallback']>;
+/**
+ * You can use the following methods for member manipulaltion
+ * ```js
+ * <QueryBuilder
+ *   // ...
+ *   cubeApi={cubeApi}
+ *   render={({
+ *     // ...
+ *     availableMeasures,
+ *     updateMeasures,
+ *   }) => {
+ *     return (
+ *       // ...
+ *       <Select
+ *         mode="multiple"
+ *         placeholder="Please select"
+ *         onSelect={(measure) => updateMeasures.add(measure)}
+ *         onDeselect={(measure) => updateMeasures.remove(measure)}
+ *       >
+ *         {availableMeasures.map((measure) => (
+ *           <Select.Option key={measure.name} value={measure}>
+ *             {measure.title}
+ *           </Select.Option>
+ *         ))}
+ *       </Select>
+ *     );
+ *   }}
+ * />
+ * ```
+ *
+ * NOTE: if you need to add or remove more than one member at a time you should use `updateQuery` prop of {@see QueryBuilderRenderProps}
+ * ```js
+ * <QueryBuilder
+ *   // ...
+ *   cubeApi={cubeApi}
+ *   render={({
+ *     // ...
+ *     measures,
+ *     updateMeasures,
+ *     updateQuery,
+ *   }) => {
+ *     // ...
+ *     return (
+ *       <>
+ *         // WRONG: This code will not work properly
+ *         <button
+ *           onClick={() =>
+ *             measures.forEach((measure) => updateMeasures.remove(measure))
+ *           }
+ *         >
+ *           Remove all
+ *         </button>
+ *
+ *         // CORRECT: Using `updateQuery` for removing all measures
+ *         <button
+ *           onClick={() =>
+ *             updateQuery({
+ *               measures: [],
+ *             })
+ *           }
+ *         >
+ *           Remove all
+ *         </button>
+ *       </>
+ *     );
+ *   }}
+ * />
+ * ```
+ */
+export type MemberUpdater<T> = {
+    add: (member: T) => void;
+    remove: (member: {
+        index: number;
+    }) => void;
+    update: (member: {
+        index: number;
+    }, updateWith: T) => void;
+};
+/**
+ * Builds the updater for one kind of query member. `toQuery` turns a member
+ * into its query representation, and defaults to reading its name.
+ *
+ * @hidden
+ */
+export type MemberUpdaterFactory = <Member>(memberType: QueryMemberType | 'filters', toQuery?: (member: Member) => unknown) => MemberUpdater<Member>;
+export type FilterExtraFields = {
+    dimension: TCubeDimension | TCubeMeasure;
+    operators: {
+        name: string;
+        title: string;
+    }[];
+};
+export type FilterWithExtraFields = Omit<Filter, 'dimension'> & FilterExtraFields;
+export type GranularityOptions = {
+    granularities: {
+        name: string;
+        title: string;
+    }[];
+};
+export type TimeDimensionExtraFields = {
+    dimension: TCubeDimension & GranularityOptions;
+};
+export type TimeDimensionWithExtraFields = Omit<TimeDimension, 'dimension'> & TimeDimensionExtraFields;
+export type DimensionUpdater = MemberUpdater<TCubeDimension>;
+export type MeasureUpdater = MemberUpdater<TCubeMeasure>;
+export type SegmentUpdater = MemberUpdater<TCubeSegment>;
+export type TimeDimensionRangedUpdateFields = {
+    granularity?: TimeDimensionGranularity;
+    dateRange?: DateRange;
+    dimension: TCubeDimension;
+};
+export type TimeDimensionComparisonUpdateFields = {
+    granularity?: TimeDimensionGranularity;
+    compareDateRange: Array<DateRange>;
+    dimension: TCubeDimension;
+};
+export type TimeDimensionUpdater = MemberUpdater<TimeDimensionRangedUpdateFields | TimeDimensionComparisonUpdateFields>;
+export type FilterUpdateFields = {
+    member?: string;
+    operator: BinaryOperator | UnaryOperator;
+    values?: string[];
+    dimension: TCubeDimension | TCubeMeasure;
+};
+export type FilterUpdater = MemberUpdater<FilterUpdateFields>;
+/**
+ * The fields `toTimeDimension` reads off a member. The updater takes either the
+ * ranged or the comparison variant, so both range fields are optional here.
+ *
+ * @hidden
+ */
+export type TimeDimensionUpdateInput = {
+    granularity?: TimeDimensionGranularity;
+    dateRange?: DateRange;
+    compareDateRange?: Array<DateRange>;
+    dimension: TCubeDimension;
+};
+/**
+ * The fields `toFilter` reads off a member. Unlike `FilterUpdateFields`, where
+ * `member` is declared as a string, the resolved member object is what is read
+ * here.
+ *
+ * @hidden
+ */
+export type FilterUpdateInput = {
+    member?: TCubeDimension | TCubeMeasure;
+    dimension?: TCubeDimension | TCubeMeasure;
+    operator: BinaryOperator | UnaryOperator;
+    values?: string[];
+};
+/**
+ * A time dimension as `QueryBuilder.resolveMember` returns it: the resolved
+ * dimension carries the granularity options the query builder offers.
+ *
+ * @hidden
+ */
+export type ResolvedTimeDimension = Omit<TimeDimension, 'dimension'> & {
+    dimension: TCubeDimension & {
+        granularities: GranularityOption[];
+    };
+    index: number;
+};
+/**
+ * A granularity the query builder offers. `name` is left out for the
+ * "w/o grouping" option.
+ */
+export type GranularityOption = {
+    name?: TimeDimensionGranularity;
+    title: string;
+};
+/**
+ * Either an `Error` or the `plainError` string from the API response, of which
+ * `fetchMeta` only reads `message`/`toString()`.
+ *
+ * @hidden
+ */
+export type MetaErrorSource = {
+    message?: string;
+    toString(): string;
+};
+/**
+ * A filter as it reaches the render props: the resolved member and the
+ * operators available for it, alongside the fields of the query filter.
+ *
+ * @hidden
+ */
+export type ResolvedFilter = Omit<Filter, 'dimension'> & {
+    dimension: TCubeDimension | TCubeMeasure;
+    operators: FilterOperator[];
+    index: number;
+};
+export type OrderUpdater = {
+    set: (memberId: string, order: QueryOrder | 'none') => void;
+    update: (order: Query['order']) => void;
+    reorder: (sourceIndex: number, destinationIndex: number) => void;
+};
+export type PivotConfigUpdaterArgs = {
+    sourceIndex: number;
+    destinationIndex: number;
+    sourceAxis: TSourceAxis;
+    destinationAxis: TSourceAxis;
+};
+export type PivotConfigExtraUpdateFields = {
+    limit?: number;
+};
+export type PivotConfigUpdater = {
+    moveItem: (args: PivotConfigUpdaterArgs) => void;
+    update: (pivotConfig: PivotConfig & PivotConfigExtraUpdateFields) => void;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map