@pol-studios/db 1.0.19 → 1.0.21

package/dist/query/index.d.ts

@@ -0,0 +1,723 @@
+import { ParsedSelect, SelectRelation } from '../core/index.js';
+export { BuiltQuery, ColumnInfo, DatabaseSchema, OrderBy, QueryOptions, RelationshipInfo, RelationshipType, ResolvedRelationship, SelectColumn, TableSchema, WhereClause, WhereOperators } from '../core/index.js';
+export { P as PowerSyncDatabase, Q as QueryExecutor, e as RelationJoinData, R as RelationshipResolver, b as ResultJoiner, S as SQLBuilder, f as createQueryExecutor, c as createRelationshipResolver, d as createResultJoiner, a as createSQLBuilder } from '../executor-CB4KHyYG.js';
+import { PostgrestSingleResponse, PostgrestError } from '@supabase/supabase-js';
+import { ItemType } from '@pol-studios/utils';
+import { UseQuerySingleReturn as UseQuerySingleReturn$1 } from '@supabase-cache-helpers/postgrest-react-query';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, DefinedUseQueryResult, UseInfiniteQueryOptions, InfiniteData } from '@tanstack/react-query';
+import * as _supabase_postgrest_js from '@supabase/postgrest-js';
+import * as react from 'react';
+import { Dispatch, SetStateAction } from 'react';
+import { V as ValueForPropertyType, P as PropertyType, a as FilterConfig } from '../FilterConfig-Bt2Ek74z.js';
+import { G as GenericTable, h as GenericView } from '../types-CYr9JiUE.js';
+
+/**
+ * Select String Parser
+ *
+ * Parses Supabase PostgREST select syntax into an AST for local SQLite processing.
+ *
+ * Supported Syntax:
+ * - "*"                                    -> All columns
+ * - "id, name, status"                     -> Specific columns
+ * - "*, RelatedTable(*)"                   -> All columns + relation
+ * - "id, RelatedTable(id, name)"           -> Specific + relation with specific columns
+ * - "*, Parent(*, Grandparent(name))"      -> Nested relations
+ * - "*, items:RelatedTable(*)"             -> Aliased relation
+ * - "aliasName:columnName"                 -> Aliased column
+ */
+
+/**
+ * Tokenize a string at the top level, respecting parentheses nesting.
+ * Splits by comma but keeps nested parentheses intact.
+ *
+ * @example
+ * tokenizeTopLevel("id, name, Parent(*, Child(name))")
+ * // Returns: ["id", "name", "Parent(*, Child(name))"]
+ */
+declare function tokenizeTopLevel(input: string): string[];
+/**
+ * Parse a Supabase PostgREST select string into an AST.
+ *
+ * @param select - The select string (e.g., "*, RelatedTable(*)")
+ * @returns Parsed select AST
+ *
+ * @example
+ * parseSelect("*")
+ * // Returns: { columns: "*", relations: [] }
+ *
+ * parseSelect("id, name, status")
+ * // Returns: {
+ * //   columns: [{ name: "id" }, { name: "name" }, { name: "status" }],
+ * //   relations: []
+ * // }
+ *
+ * parseSelect("*, EquipmentFixture(*)")
+ * // Returns: {
+ * //   columns: "*",
+ * //   relations: [{ name: "EquipmentFixture", columns: "*", relations: [] }]
+ * // }
+ *
+ * parseSelect("id, name, ProjectDatabase(name, Organization(*))")
+ * // Returns: {
+ * //   columns: [{ name: "id" }, { name: "name" }],
+ * //   relations: [{
+ * //     name: "ProjectDatabase",
+ * //     columns: [{ name: "name" }],
+ * //     relations: [{ name: "Organization", columns: "*", relations: [] }]
+ * //   }]
+ * // }
+ */
+declare function parseSelect(select: string): ParsedSelect;
+/**
+ * Convert a parsed select back to a string representation (for debugging)
+ */
+declare function stringifySelect(parsed: ParsedSelect): string;
+/**
+ * Extract all column names from a parsed select (for building SQL queries)
+ * Does not include relation names.
+ */
+declare function extractColumnNames(parsed: ParsedSelect): string[] | "*";
+/**
+ * Extract all relation names from a parsed select
+ */
+declare function extractRelationNames(parsed: ParsedSelect): string[];
+/**
+ * Check if a select string references a specific relation
+ */
+declare function hasRelation(parsed: ParsedSelect, relationName: string): boolean;
+/**
+ * Get the select configuration for a specific relation
+ */
+declare function getRelationSelect(parsed: ParsedSelect, relationName: string): SelectRelation | undefined;
+
+type ConfigurationOptions<T> = {
+    crossOrganization?: boolean;
+    filter?: (item: ItemType<T>) => boolean;
+};
+type UseQuerySingleReturn<T> = UseQuerySingleReturn$1<T> & {
+    data: T | null | undefined;
+};
+declare function useQuery<Result>(query: PromiseLike<PostgrestSingleResponse<Result>>, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn"> & ConfigurationOptions<Result>): UseQuerySingleReturn<Result>;
+
+type UsePartialQueryResult<T extends Record<string, any>> = ReturnType<typeof usePartialQuery<T[]>>;
+declare function usePartialQuery<Result extends Record<string, any>[]>(query: PromiseLike<PostgrestSingleResponse<Result>>, itemCountPerPage: number, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn">): {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: _supabase_postgrest_js.PostgrestError;
+    status: "error";
+    isError: true;
+    isPending: false;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isPlaceholderData: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+} | {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: null;
+    status: "success";
+    isError: false;
+    isPending: false;
+    isSuccess: true;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isPlaceholderData: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+} | {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: _supabase_postgrest_js.PostgrestError;
+    status: "error";
+    isError: true;
+    isPending: false;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isPlaceholderData: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+} | {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: null;
+    status: "pending";
+    isError: false;
+    isPending: true;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isPlaceholderData: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+} | {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: null;
+    status: "pending";
+    isError: false;
+    isPending: true;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: boolean;
+    isLoadingError: false;
+    isRefetchError: false;
+    isPlaceholderData: false;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+} | {
+    fetchPreviousPage: () => void;
+    fetchNextPage: () => void;
+    currentPage: number;
+    setCurrentPage: react.Dispatch<react.SetStateAction<number>>;
+    data: {
+        Items: Result;
+        CurrentPage: number;
+        ItemCount: number;
+        MaxCountPerPage: number;
+        PageCount: number;
+    };
+    pageCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    error: null;
+    status: "success";
+    isError: false;
+    isPending: false;
+    isSuccess: true;
+    failureCount: number;
+    failureReason: _supabase_postgrest_js.PostgrestError;
+    isPaused: boolean;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isPlaceholderData: true;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<Result>;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PostgrestSingleResponse<Result>, _supabase_postgrest_js.PostgrestError>>;
+    count: number;
+};
+
+/**
+ * Filter operators supported by the edge function.
+ * This is the single source of truth - matches /supabase/functions/_shared/query-sdk/types.ts
+ *
+ * Note: The following operators are normalized by normalizeFilter() before sending to the server:
+ * - "like" -> "contains"
+ * - "regex", "regex_i", "similar_to" -> "contains"
+ * - "!=" and "<>" are NOT supported - use "=" with not: true instead
+ */
+type FilterOperator = "=" | ">" | ">=" | "<" | "<=" | "contains" | "ilike" | "is" | "in" | "ai_search";
+/**
+ * Filter interface - matches edge function API
+ */
+interface Filter {
+    /** Unique identifier */
+    id: string;
+    /** Field to filter on */
+    field: string;
+    /** Operator */
+    op: FilterOperator;
+    /** Value to compare */
+    value: string | number | string[] | number[] | boolean | null;
+    /** Negate the condition */
+    not?: boolean;
+    /** AI search options (when op = "ai_search") */
+    similarity?: number;
+    where?: string;
+    display?: string;
+    options?: {
+        display: string;
+        value: ValueForPropertyType<PropertyType>;
+    }[];
+    /** Filter configuration (UI metadata) */
+    info?: FilterConfig<any>;
+}
+/**
+ * Filter group - combine multiple filters
+ */
+interface FilterGroup {
+    /** Unique identifier */
+    id: string;
+    /** How to combine filters */
+    op: "AND" | "OR";
+    /** Filters in this group */
+    filters: Array<Filter | FilterGroup>;
+    /** Negate the entire group (NOT (A AND B)) */
+    not?: boolean;
+}
+/**
+ * Pagination settings
+ */
+interface Pagination {
+    offset?: number;
+    limit?: number;
+}
+/**
+ * Configuration for computed/aggregated field sorting
+ */
+interface ComputedSortConfig {
+    /** Aggregation function to apply */
+    fn: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX";
+    /** Field to aggregate */
+    field: string;
+    /** Relationship path for related table aggregation (e.g., "OrderItem" or "Order.OrderItem") */
+    relationship?: string;
+}
+/**
+ * Sort order
+ */
+interface Sort {
+    field: string;
+    direction: "asc" | "desc";
+    /** Optional computed/aggregated sort configuration for sorting by aggregate values */
+    computed?: ComputedSortConfig;
+}
+/**
+ * Query state that includes FilterGroup plus pagination, sort, and isReady
+ * Used by useAdvancedFilterQuery for managing filter state with query metadata
+ */
+interface QueryState extends FilterGroup {
+    /** Pagination settings */
+    pagination?: Pagination;
+    /** Sort order */
+    sort?: Sort[];
+    /** Distinct ON expressions - returns one record per unique combination */
+    distinctOn?: string[];
+    /** Natural language query - converts to filters automatically */
+    naturalLanguageQuery?: string;
+    /** Whether the query is ready to execute */
+    isReady: boolean;
+}
+interface ClarificationSuggestion {
+    interpretation: string;
+    field_path: string;
+    example: string;
+    confidence: number;
+}
+interface ClarificationQuestion {
+    question: string;
+    suggestions: ClarificationSuggestion[];
+}
+declare function useAdvancedFilterQuery<Result>(query: PromiseLike<PostgrestSingleResponse<Result>>, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn"> & {
+    key?: string;
+    filterKey?: string;
+    searchByDefault?: boolean;
+    timeout?: number;
+    count?: "exact" | "estimated" | "";
+}): [
+    DefinedUseQueryResult<Result, Error> & {
+        count: number;
+        clarification?: ClarificationQuestion;
+    },
+    QueryState,
+    Dispatch<SetStateAction<QueryState>>
+];
+declare const useAdvancedQuery: typeof useAdvancedFilterQuery;
+
+type DataType = Record<string, any>;
+declare function useInfiniteQuery<Relation extends GenericTable | GenericView, Result extends DataType, Query extends string = "*", RelationName = unknown, Relationships = Relation extends {
+    Relationships: infer R;
+} ? R : unknown, Builder = PromiseLike<PostgrestSingleResponse<Result>>>(query: PromiseLike<PostgrestSingleResponse<Result>>, countPerLoad: number, config?: Omit<UseInfiniteQueryOptions<PostgrestSingleResponse<Result>, Error, InfiniteData<PostgrestSingleResponse<Result>, number>>, "queryKey" | "queryFn" | "getNextPageParam" | "initialPageParam"> & {
+    crossOrganization?: boolean;
+    onQuery?: ({ pageParam, query }: {
+        pageParam: number;
+        query: Builder;
+    }) => any;
+    enableOnQuery?: boolean;
+}): {
+    count: number;
+    data: Result;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+} | {
+    count: number;
+    data: Result;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+} | {
+    count: number;
+    data: Result;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+} | {
+    count: number;
+    data: Result;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+} | {
+    count: number;
+    data: Result;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+} | {
+    count: number;
+    data: Result;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<PostgrestSingleResponse<Result>, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<PostgrestSingleResponse<Result>, unknown>>;
+};
+
+type UsePartialAdvancedQueryResult<T extends Record<string, any>> = ReturnType<typeof usePartialAdvancedQuery<T[]>>;
+declare function usePartialAdvancedQuery<Result extends Record<string, any>[]>(query: PromiseLike<PostgrestSingleResponse<Result>>, itemCountPerPage: number, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn"> & {
+    filterKey?: string;
+    timeout?: number;
+}): [
+    ReturnType<typeof useAdvancedFilterQuery<Result>>[0] & {
+        currentPage: number;
+        setCurrentPage: (value: React.SetStateAction<number>) => void;
+        fetchNextPage: () => any;
+        fetchPreviousPage: () => any;
+        data: {
+            Items: Result;
+            CurrentPage: number;
+            ItemCount: number;
+            MaxCountPerPage: number;
+            PageCount: number;
+        };
+        pageCount: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        count: number;
+    },
+    QueryState,
+    React.Dispatch<React.SetStateAction<QueryState>>
+];
+
+export { ParsedSelect, SelectRelation, type UsePartialAdvancedQueryResult, type UsePartialQueryResult, type UseQuerySingleReturn, extractColumnNames, extractRelationNames, getRelationSelect, hasRelation, parseSelect, stringifySelect, tokenizeTopLevel, useAdvancedFilterQuery, useAdvancedQuery, useInfiniteQuery, usePartialAdvancedQuery, usePartialQuery, useQuery };