@altertable/data-app 0.59.1

package/dist/types/react/hooks.d.ts

@@ -0,0 +1,831 @@
+import { type ReactNode } from 'react';
+import type { DataOperations, DateRangeRequest } from '../core/contract.js';
+import type { DataClient, InputOf, OutputOf } from '../client/index.js';
+import { type ReportingPeriod } from './ui/PeriodSummary.js';
+import { type VariableCollection } from '../core/variables.js';
+import { dateRangeVariable, type DateRangeVariableOptions } from './ui/variables.js';
+import { type DimensionFilterOptions, type DimensionOption, type DimensionValue } from '../core/dimension.js';
+import type { EmptyStateProps } from './ui/EmptyState.js';
+import { type DataContentState } from './content.js';
+import { type DataViewDefinition, type ResolvedVariables, type ViewBindings } from './view.js';
+type TimeVariables<Additional extends VariableCollection> = {
+    period: ReturnType<typeof dateRangeVariable>;
+} & Additional;
+type TimeInput<Additional extends VariableCollection> = keyof Additional extends never ? DateRangeRequest : ResolvedVariables<TimeVariables<Additional>>;
+type TimeInputMapping<Additional extends VariableCollection, Input> = TimeInput<Additional> extends Input ? {
+    input?: (values: ResolvedVariables<TimeVariables<Additional>>) => Input;
+} : {
+    input: (values: ResolvedVariables<TimeVariables<Additional>>) => Input;
+};
+/**
+ * `placeholderData` may belong to an earlier input. Use `useDataView` to distinguish initial
+ * loading, refreshes, and changed-input requests.
+ */
+export declare function createDataHooks<Operations extends DataOperations>(client: DataClient<Operations>): {
+    useDataQuery: <Name extends keyof Operations & string>(name: Name, input: InputOf<Operations[Name]>, options?: {
+        enabled?: boolean;
+        staleTime?: number;
+        gcTime?: number;
+        refetchOnWindowFocus?: boolean;
+    }) => {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        isError: false;
+        error: null;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: true;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: null;
+        isError: false;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: false;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+    };
+    useDataView: <Name extends keyof Operations & string>(name: Name, input: InputOf<Operations[Name]>, options: {
+        enabled?: boolean;
+        staleTime?: number;
+        gcTime?: number;
+        refetchOnWindowFocus?: boolean;
+    } & {
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        describeInput?: (input: InputOf<Operations[Name]>) => string;
+        period?: (input: InputOf<Operations[Name]>) => ReportingPeriod;
+        sameInput?: (left: InputOf<Operations[Name]>, right: InputOf<Operations[Name]>) => boolean;
+    }) => {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        isError: false;
+        error: null;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: true;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: null;
+        isError: false;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: false;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+    };
+    defineDataView: <Name extends keyof Operations & string, const Variables extends VariableCollection>(definition: DataViewDefinition<Name, Variables, InputOf<Operations[Name]>, OutputOf<Operations[Name]>>) => {
+        operation: Name;
+        input: (values: ResolvedVariables<Variables>) => InputOf<Operations[Name]>;
+        bindings?: Partial<{ [Key in keyof Variables]: (input: InputOf<Operations[Name]>) => ResolvedVariables<Variables>[Key]; }> | undefined;
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        empty: Pick<EmptyStateProps, 'title' | 'description'>;
+        date: import("./view.js").ViewDate<Variables, InputOf<Operations[Name]>>;
+        variables: Variables;
+        describeInput: (input: InputOf<Operations[Name]>) => string;
+        content(render: (state: DataContentState<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>) => ReactNode): {
+            loading: ReactNode;
+            children(data: OutputOf<Operations[Name]>, input: InputOf<Operations[Name]>): ReactNode;
+        };
+    } | {
+        operation: Name;
+        input: (values: ResolvedVariables<Variables>) => InputOf<Operations[Name]>;
+        bindings?: Partial<{ [Key in keyof Variables]: (input: InputOf<Operations[Name]>) => ResolvedVariables<Variables>[Key]; }> | undefined;
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        empty: Pick<EmptyStateProps, 'title' | 'description'>;
+        date?: never;
+        variables: Variables;
+        describeInput: (input: InputOf<Operations[Name]>) => string;
+        content(render: (state: DataContentState<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>) => ReactNode): {
+            loading: ReactNode;
+            children(data: OutputOf<Operations[Name]>, input: InputOf<Operations[Name]>): ReactNode;
+        };
+    };
+    defineTimeView: <Name extends keyof Operations & string, const Additional extends VariableCollection = {}>(definition: {
+        operation: Name;
+        time: Omit<DateRangeVariableOptions, 'key'>;
+        variables?: Additional & {
+            period?: never;
+        };
+        bindings?: ViewBindings<{
+            period: ReturnType<typeof dateRangeVariable>;
+        } & NoInfer<Additional>, InputOf<Operations[Name]>>;
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        empty: Pick<EmptyStateProps, 'title' | 'description'>;
+    } & TimeInputMapping<NoInfer<Additional>, InputOf<Operations[Name]>>) => {
+        operation: Name;
+        input: (values: ResolvedVariables<{
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional>) => InputOf<Operations[Name]>;
+        bindings?: Partial<{
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional extends infer T extends VariableCollection ? { [Key in keyof T]: (input: Input) => ResolvedVariables<T>[Key]; } : never> | undefined;
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        empty: Pick<EmptyStateProps, 'title' | 'description'>;
+        date: import("./view.js").ViewDate<{
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional, InputOf<Operations[Name]>>;
+        variables: {
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional;
+        describeInput: (input: InputOf<Operations[Name]>) => string;
+        content(render: (state: DataContentState<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>) => ReactNode): {
+            loading: ReactNode;
+            children(data: OutputOf<Operations[Name]>, input: InputOf<Operations[Name]>): ReactNode;
+        };
+    } | {
+        operation: Name;
+        input: (values: ResolvedVariables<{
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional>) => InputOf<Operations[Name]>;
+        bindings?: Partial<{
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional extends infer T extends VariableCollection ? { [Key in keyof T]: (input: Input) => ResolvedVariables<T>[Key]; } : never> | undefined;
+        isEmpty: (data: OutputOf<Operations[Name]>) => boolean;
+        empty: Pick<EmptyStateProps, 'title' | 'description'>;
+        date?: never;
+        variables: {
+            period: import("../core/variables.js").DateRangeVariable;
+        } & Additional;
+        describeInput: (input: InputOf<Operations[Name]>) => string;
+        content(render: (state: DataContentState<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>) => ReactNode): {
+            loading: ReactNode;
+            children(data: OutputOf<Operations[Name]>, input: InputOf<Operations[Name]>): ReactNode;
+        };
+    };
+    defineFacetFilter: <Name extends keyof Operations & string, const T extends DimensionValue>(config: Omit<DimensionFilterOptions<T>, 'options' | 'facet'> & {
+        facet: {
+            operation: Name;
+            input: (values: Record<string, unknown>) => InputOf<Operations[Name]>;
+        };
+    } & (OutputOf<Operations[Name]> extends readonly DimensionOption<T>[] ? object : never)) => import("../core/dimension.js").DimensionVariable<T>;
+    useView: <Name extends keyof Operations & string, const Variables extends VariableCollection>(definition: DataViewDefinition<Name, Variables, InputOf<Operations[Name]>, OutputOf<Operations[Name]>>) => {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: undefined;
+        error: null;
+        isError: false;
+        isPending: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'pending';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        isError: false;
+        error: null;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: true;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: Error;
+        isError: true;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: 'error';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    } | {
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+        data: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        error: null;
+        isError: false;
+        isPending: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: false;
+        status: 'success';
+        /** Abort the current request and restore its prior query state. */
+        cancel(this: void): Promise<void>;
+        response: import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        view: import("../core/data-view.js").DataView<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>;
+        snapshot: import("../core/data-view.js").DisplayedSnapshot<OutputOf<Operations[Name]>, InputOf<Operations[Name]>> | undefined;
+        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../client/index.js").DataResponse<OutputOf<Operations[Name]>, InputOf<Operations[Name]>>, Error>>;
+        refresh: {
+            refreshing: boolean;
+            onRefresh(): undefined;
+            onCancel: (this: void) => Promise<void>;
+        };
+        queries: import("../core/contract.js").DisclosedQuery[] | undefined;
+        empty: Pick<EmptyStateProps, "description" | "title">;
+        controls: ReactNode[] | null;
+        variables: {
+            values: import("../core/variables.js").AppVariableValues<Variables>;
+            set: <Key extends keyof Variables & string>(name: Key, value: import("../core/variables.js").AppVariableValues<Variables>[Key]) => void;
+            reset: <Key extends keyof Variables & string>(name: Key) => void;
+            update: (next: Partial<import("../core/variables.js").AppVariableValues<Variables>>, history?: import("../core/variables.js").HistoryMode) => void;
+            bind: <Key extends keyof Variables & string>(name: Key) => {
+                value: import("../core/variables.js").AppVariableValues<Variables>[Key];
+                onChange(value: import("../core/variables.js").AppVariableValues<Variables>[Key]): void;
+                resetValue: import("../core/variables.js").AppVariableValues<Variables>[Key];
+            };
+            resolved: ResolvedVariables<Variables>;
+            controls: ReactNode[] | null;
+        };
+    };
+};
+export {};