@pol-studios/db 1.0.1 → 1.0.3

package/dist/useResolveFeedback-kQZVy6lb.d.ts

@@ -0,0 +1,1071 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationResult, UseMutationOptions } from '@tanstack/react-query';
+import { D as Database } from './useSupabase-pPhUZHcl.js';
+import { G as GetResult } from './select-query-parser-CLkOKHzc.js';
+import { G as GenericSchema, a as GenericTable } from './types-CKsWM8T3.js';
+import { useInsertMutation, useUpdateMutation } from '@supabase-cache-helpers/postgrest-react-query';
+import { PostgrestSingleResponse, PostgrestError, RealtimePostgresChangesPayload, SupabaseClient } from '@supabase/supabase-js';
+import { u as useDbAdvanceFilterQuery, Q as QueryState, T as Tables, d as DbChangeLog } from './index-DNrSptau.js';
+import { ItemType as ItemType$6 } from '@pol-studios/utils';
+import { U as UseDbQuerySingleReturn } from './useDbQuery-C-TL8jY1.js';
+import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult } from './useDbCount-B5-Va9sg.js';
+import { DatabaseSchema, QueryOptions } from './core/index.js';
+import { FunctionsResponse } from '@supabase/functions-js';
+import * as _supabase_postgrest_js from '@supabase/postgrest-js';
+import { PostgrestSingleResponse as PostgrestSingleResponse$1 } from '@supabase/postgrest-js';
+import { Moment } from 'moment';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { TransformOptions } from '@supabase/storage-js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function setSupabaseUrl(url: string): void;
+declare function getSupabaseUrl(): string;
+
+type ItemType$5<T> = T extends Array<infer U> ? U : T;
+declare function useDbDelete<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult extends object = GetResult<PublicSchema, Table["Row"], RelationName, Relationships, Query>>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof ItemType$5<RowResult> & string)[]): _tanstack_react_query.UseMutationResult<RowResult, Error, Partial<RowResult>, unknown>;
+
+type ItemType$4<T> = T extends Array<infer U> ? U : T;
+type MutationOption$2 = Parameters<typeof useInsertMutation>[3];
+declare function useDbInsert<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", ReturnQuery extends string | undefined = undefined, PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult = ReturnQuery extends undefined ? null : GetResult<PublicSchema, Table["Row"], RelationName, Relationships, Extract<ReturnQuery, string>>, ResultInsert extends object = GetResult<PublicSchema, Table["Insert"], RelationName, Relationships, "*">>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof (ItemType$4<RowResult> | any) & string)[], query?: ReturnQuery, mutationOption?: MutationOption$2 & {
+    crossOrganization?: boolean;
+}): _tanstack_react_query.UseMutationResult<RowResult, Error, ResultInsert, unknown>;
+
+type ItemType$3<T> = T extends Array<infer U> ? U : T;
+declare function useDbMultiDelete<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult extends object = Omit<GetResult<PublicSchema, Table["Update"], RelationName, Relationships, Query>, "id">>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof ItemType$3<RowResult> & string)[]): _tanstack_react_query.UseMutationResult<RowResult, Error, RowResult | RowResult[], unknown>;
+
+type ItemType$2<T> = T extends Array<infer U> ? U : T;
+declare function useDbMultiUpsert<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult extends object = GetResult<PublicSchema, Table["Row"], RelationName, Relationships, Query>, ResultInsert extends object = GetResult<PublicSchema, Table["Insert"], RelationName, Relationships, Query>, ResultUpdate extends object = Omit<GetResult<PublicSchema, Table["Update"], RelationName, Relationships, Query>, "id"> & {
+    id: any;
+}>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof (ItemType$2<RowResult> | any) & string)[], query?: string): _tanstack_react_query.UseMutationResult<RowResult[], Error, (ResultInsert | ResultUpdate)[], unknown>;
+
+type UseDbPartialAdvanceQueryResult<T extends Record<string, any>> = ReturnType<typeof useDbPartialAdvanceQuery<T[]>>;
+declare function useDbPartialAdvanceQuery<Result extends Record<string, any>[]>(query: PromiseLike<PostgrestSingleResponse<Result>>, itemCountPerPage: number, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn"> & {
+    filterKey?: string;
+    timeout?: number;
+}): [
+    ReturnType<typeof useDbAdvanceFilterQuery<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>>
+];
+
+type UseDbPartialQueryResult<T extends Record<string, any>> = ReturnType<typeof useDbPartialQuery<T[]>>;
+declare function useDbPartialQuery<Result extends Record<string, any>[]>(query: PromiseLike<PostgrestSingleResponse<Result>>, itemCountPerPage: number, config?: Omit<UseQueryOptions<Result, PostgrestError>, "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: PostgrestError;
+    status: "error";
+    isError: true;
+    isPending: false;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: 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>, PostgrestError>>;
+    count: number | null;
+} | {
+    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: 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>, PostgrestError>>;
+    count: number | null;
+} | {
+    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: PostgrestError;
+    status: "error";
+    isError: true;
+    isPending: false;
+    isSuccess: false;
+    failureCount: number;
+    failureReason: 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>, PostgrestError>>;
+    count: number | null;
+} | {
+    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: 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>, PostgrestError>>;
+    count: number | null;
+} | {
+    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: 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>, PostgrestError>>;
+    count: number | null;
+} | {
+    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: 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>, PostgrestError>>;
+    count: number | null;
+};
+
+declare function useDbRealtime(key: string, query: string, table: string | {
+    table: string;
+    schema: string;
+}, primaryKeys: string[], options?: {
+    filter?: string;
+    enabled?: boolean;
+    onChange?: (payload: RealtimePostgresChangesPayload<{
+        [key: string]: any;
+    }>) => any;
+}): "SUBSCRIBED" | "TIMED_OUT" | "CLOSED" | "CHANNEL_ERROR";
+
+type ConfigurationOptions<T> = {
+    crossOrganization?: boolean;
+};
+type FilterOperator = "or" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like" | "ilike" | "is" | "in" | "cs" | "cd" | "fts" | "plfts";
+type ValueType = number | string | boolean | null | Date | object;
+type FilterDefinition = {
+    path: string;
+    alias?: string;
+    operator: FilterOperator;
+    negate: boolean;
+    value: ValueType;
+};
+type FilterDefinitions = (FilterComposite | FilterDefinition)[];
+type FilterComposite = {
+    or?: FilterDefinitions;
+    and?: FilterDefinitions;
+};
+type UseDbRealtimeQueryResult<T> = UseDbQuerySingleReturn<T> & {
+    realtimeStatus: "SUBSCRIBED" | "TIMED_OUT" | "CLOSED" | "CHANNEL_ERROR" | "Loading...";
+    isRealtimeConnected: boolean;
+    isRealtimeLoading: boolean;
+};
+type DataType = Record<string, any>;
+declare function convertFilterToRealtimeQuery(filters: FilterDefinitions): string;
+declare function useDbRealtimeQuery<Result extends DataType>(query: PromiseLike<PostgrestSingleResponse<Result>>, config?: Omit<UseQueryOptions<PostgrestSingleResponse<Result>>, "queryKey" | "queryFn"> & ConfigurationOptions<Result>, primaryKeys?: (keyof ItemType$6<Result> & string)[]): UseDbRealtimeQueryResult<Result>;
+
+type ItemType$1<T> = T extends Array<infer U> ? U : T;
+type MutationOption$1 = Parameters<typeof useUpdateMutation>[3];
+declare function useDbUpdate<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", ReturnQuery extends string | undefined = undefined, PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult = ReturnQuery extends undefined ? null : GetResult<PublicSchema, Table["Row"], RelationName, Relationships, Extract<ReturnQuery, string>>, ResultUpdate extends object = (Omit<GetResult<PublicSchema, Table["Update"], RelationName, Relationships, "*">, "id"> & {
+    id: number;
+}) | Omit<GetResult<PublicSchema, Table["Update"], RelationName, Relationships, "*">, "id">>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof (ItemType$1<RowResult> | any) & string)[], query?: ReturnQuery, mutationOption?: MutationOption$1 & {
+    crossOrganization?: boolean;
+}): _tanstack_react_query.UseMutationResult<RowResult, Error, ResultUpdate, unknown>;
+
+type ItemType<T> = T extends Array<infer U> ? U : T;
+type MutationOption = Parameters<typeof useUpdateMutation>[3];
+type useDbUpsertResponse = ReturnType<typeof useDbUpsert>;
+declare function useDbUpsert<TableName extends string & keyof PublicSchema["Tables"], Table extends PublicSchema["Tables"][TableName], Schema extends keyof Database = "public", ReturnQuery extends string | undefined = undefined, PublicSchema extends GenericSchema = Database[Extract<keyof Database, Schema>], RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, RowResult = ReturnQuery extends undefined ? null : GetResult<PublicSchema, Table["Row"], RelationName, Relationships, Extract<ReturnQuery, string>>, ResultInsert extends object = Omit<GetResult<PublicSchema, Table["Insert"], RelationName, Relationships, "*">, "id">, ResultUpdate extends object = Omit<GetResult<PublicSchema, Table["Update"], RelationName, Relationships, "*">, "id"> & {
+    id?: any;
+}>(relation: TableName | {
+    table: TableName;
+    schema: Schema;
+}, primaryKeys?: (keyof (ItemType<RowResult> | any) & string)[], query?: ReturnQuery, mutationOption?: MutationOption & {
+    crossOrganization?: boolean;
+}): _tanstack_react_query.UseMutationResult<RowResult, Error, ResultInsert | ResultUpdate, unknown>;
+
+interface UseMutationSuccessOptions {
+    successMessage?: string;
+    entityName?: string;
+    enabled?: boolean;
+    onSuccess?: () => void;
+}
+/**
+ * Hook to automatically show success feedback after successful mutations
+ * Works with both React Native and Web platforms
+ */
+declare function useMutationSuccess<TData, TError, TVariables>(mutation: UseMutationResult<TData, TError, TVariables>, options?: UseMutationSuccessOptions): UseMutationResult<TData, TError, TVariables>;
+/**
+ * Hook for React Native that uses native toast/alert system
+ * @deprecated Use useMutationSuccess instead - it auto-detects platform
+ */
+declare function useMutationSuccessRN<TData, TError, TVariables>(mutation: UseMutationResult<TData, TError, TVariables>, options?: UseMutationSuccessOptions): UseMutationResult<TData, TError, TVariables>;
+
+/**
+ * V3 Data Layer - Supabase Adapter
+ *
+ * Implements the TableDataAdapter interface for direct Supabase/PostgREST queries.
+ * This adapter is used for online-only data access without local caching.
+ */
+
+/**
+ * Adapter for querying Supabase directly via PostgREST API.
+ *
+ * This adapter:
+ * - Queries Supabase directly (no local caching)
+ * - Supports real-time subscriptions via Supabase Realtime
+ * - Works only when online
+ * - Uses Supabase's native select embedding for relations
+ *
+ * @example
+ * ```typescript
+ * const adapter = createSupabaseAdapter(supabaseClient, schema);
+ *
+ * // Query with relations
+ * const result = await adapter.query<Project>("projects", {
+ *   select: "*, client:clients(*), tasks(*)",
+ *   where: { status: "active" },
+ *   orderBy: [{ field: "created_at", direction: "desc" }],
+ *   limit: 10
+ * });
+ * ```
+ */
+declare class SupabaseAdapter implements TableDataAdapter, CapableDataAdapter {
+    private supabase;
+    private schema;
+    readonly name = "supabase";
+    readonly capabilities: AdapterCapabilities;
+    constructor(supabase: SupabaseClient, schema: DatabaseSchema);
+    /**
+     * Parse a table identifier to extract schema and table name.
+     * Handles schema-qualified names like "core.Profile" -> { schema: "core", tableName: "Profile" }
+     *
+     * @param table - The table name, optionally schema-qualified (e.g., "users" or "core.Profile")
+     * @returns Object with schema (defaults to "public") and tableName
+     */
+    private parseTableIdentifier;
+    /**
+     * Execute a query and return results with optional count
+     *
+     * @param table - The table name to query
+     * @param options - Query options (select, where, orderBy, limit, offset)
+     * @returns Promise resolving to query results with optional count
+     */
+    query<T>(table: string, options: QueryOptions): Promise<AdapterQueryResult<T>>;
+    /**
+     * Query a single record by ID
+     *
+     * @param table - The table name to query
+     * @param id - The record ID
+     * @param options - Optional query options (mainly for select)
+     * @returns Promise resolving to the record or null if not found
+     */
+    queryById<T>(table: string, id: string, options?: Pick<QueryOptions, "select">): Promise<T | null>;
+    /**
+     * Insert a new record
+     *
+     * @param table - The table name
+     * @param data - The data to insert
+     * @returns Promise resolving to the inserted record
+     */
+    insert<T>(table: string, data: Partial<T>): Promise<T>;
+    /**
+     * Update an existing record by ID
+     *
+     * @param table - The table name
+     * @param id - The record ID to update
+     * @param data - The data to update
+     * @returns Promise resolving to the updated record
+     */
+    update<T>(table: string, id: string, data: Partial<T>): Promise<T>;
+    /**
+     * Upsert (insert or update) a record
+     *
+     * @param table - The table name
+     * @param data - The data to upsert
+     * @returns Promise resolving to the upserted record
+     */
+    upsert<T>(table: string, data: Partial<T>): Promise<T>;
+    /**
+     * Delete a record by ID
+     *
+     * @param table - The table name
+     * @param id - The record ID to delete
+     * @returns Promise that resolves when deletion is complete
+     */
+    delete(table: string, id: string): Promise<void>;
+    /**
+     * Subscribe to real-time changes on a query
+     *
+     * @param table - The table name to watch
+     * @param options - Query options to filter what to watch
+     * @param callback - Function called with updated data
+     * @returns Unsubscribe function
+     */
+    subscribe<T>(table: string, options: QueryOptions, callback: (data: T[]) => void): () => void;
+    /**
+     * Apply where clause filters to a Supabase query
+     *
+     * Converts WhereClause to Supabase filter methods:
+     * - Direct value: .eq(field, value)
+     * - { in: [...] }: .in(field, values)
+     * - { gt: n }: .gt(field, n)
+     * - { gte: n }: .gte(field, n)
+     * - { lt: n }: .lt(field, n)
+     * - { lte: n }: .lte(field, n)
+     * - { like: s }: .ilike(field, s)
+     * - { is: null }: .is(field, null)
+     * - { neq: v }: .neq(field, v) or .not(field, "is", null)
+     * - { notIn: [...] }: .not().in(field, values)
+     *
+     * @param query - The Supabase query builder
+     * @param where - The where clause to apply
+     * @returns The query with filters applied
+     */
+    private applyWhereClause;
+}
+/**
+ * Create a new SupabaseAdapter instance
+ *
+ * @param supabase - The Supabase client instance
+ * @param schema - The database schema definition
+ * @returns A new SupabaseAdapter instance
+ *
+ * @example
+ * ```typescript
+ * const adapter = createSupabaseAdapter(supabaseClient, databaseSchema);
+ * const projects = await adapter.query<Project>("projects", {
+ *   where: { status: "active" }
+ * });
+ * ```
+ */
+declare function createSupabaseAdapter(supabase: SupabaseClient, schema: DatabaseSchema): SupabaseAdapter;
+
+declare function useSupabaseFunction(): {
+    downloadFunctionResponse: (functionName: string, body?: any, name?: string) => Promise<void>;
+};
+
+declare function getErrorBody(response: FunctionsResponse<any>): Promise<any>;
+
+interface AIOptions {
+    maxTokens?: number;
+    temperature?: number;
+}
+interface AIResponse {
+    success: boolean;
+    data?: {
+        response: string;
+    };
+    error?: string;
+}
+declare function useAI(): {
+    generate: (prompt: string, context: Record<string, any>, options?: AIOptions) => Promise<string>;
+};
+
+interface ExtractedReceipt {
+    merchantName: string;
+    transactionDate: string | null;
+    currency: string;
+    subtotal: number | null;
+    tax: number | null;
+    total: number;
+    lineItems: Array<{
+        description: string;
+        amount: number;
+        quantity: number | null;
+        suggestedCategory: string | null;
+    }>;
+    confidence: number;
+    notes: string | null;
+}
+interface PendingExpense {
+    id: string;
+    file: File;
+    status: "processing" | "ready" | "error" | "confirming";
+    extractedData: ExtractedReceipt | null;
+    error: string | null;
+    duplicateWarning?: {
+        existingExpenseId: number;
+        reason: string;
+    };
+}
+interface BatchAnalysisProgress {
+    total: number;
+    completed: number;
+    processing: string[];
+}
+interface RecentExpenseContext {
+    merchantName: string;
+    category: string | null;
+    amount: number;
+}
+interface UseReceiptAIOptions {
+    recentExpenses?: RecentExpenseContext[];
+    taxCategories?: Tables<"TaxCategory">[];
+}
+declare function useReceiptAI(options?: UseReceiptAIOptions): {
+    analyzeReceipt: (file: File) => Promise<ExtractedReceipt | null>;
+    analyzeMultipleReceipts: (files: File[], onProgress?: (progress: BatchAnalysisProgress) => void, onItemComplete?: (item: PendingExpense) => void) => Promise<PendingExpense[]>;
+    isAnalyzing: boolean;
+    batchProgress: BatchAnalysisProgress;
+    error: string;
+    extractedData: ExtractedReceipt;
+    reset: () => void;
+};
+
+interface ServerAvailabilityState {
+    isAvailable: boolean | null;
+    isChecking: boolean;
+    lastChecked: Date | null;
+    error: Error | null;
+}
+/**
+ * Hook to check if the Supabase server is available.
+ * Performs periodic health checks and provides availability state.
+ * Works without requiring Supabase context, making it safe to use at app initialization.
+ */
+declare function useServerAvailability(options?: {
+    enabled?: boolean;
+    checkInterval?: number;
+    timeout?: number;
+}): ServerAvailabilityState & {
+    checkAvailability: () => Promise<void>;
+};
+
+declare function useSearchQuery<Result>(baseQuery: PromiseLike<PostgrestSingleResponse$1<Result>>, searchText: string, columns: ((string & keyof Result) | string)[], options?: {
+    isOptional: boolean;
+    additionCondition: (string | undefined)[];
+}): PromiseLike<PostgrestSingleResponse$1<Result>>;
+
+type PublicSchema$2 = Database[Extract<keyof Database, "public">];
+type TableRow<T> = T extends {
+    Row: infer R extends Record<string, unknown>;
+} ? R : Record<string, unknown>;
+declare function useLiveChangeTracking<Relation extends GenericTable, TableName extends string & keyof PublicSchema$2["Tables"], Table extends PublicSchema$2["Tables"][TableName] = PublicSchema$2["Tables"][TableName], Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, TItem = GetResult<PublicSchema$2, TableRow<Table>, RelationName, Relationships, Query>>(tableName: TableName, item: TItem, action?: (updates: Partial<TItem>, changeLog: DbChangeLog) => any): DbChangeLog;
+
+declare function useLatestOperationLog(tableName: string, recordId: number): UseDbQuerySingleReturn<unknown>;
+
+type PublicSchema$1 = Database[Extract<keyof Database, "public">];
+type TimeActivity = any;
+declare function newTimeActivity(date: Moment): TimeActivity;
+type AutosaveOptions<T> = UpdateOptions<T> & {
+    delay: number;
+    primaryKeys?: string[];
+    transformBeforeMutation?: (item: T) => Partial<T>;
+};
+type UpdateOptions<T> = Partial<UseMutationOptions<T, Error, T, unknown>> & {
+    updateCache?: boolean;
+};
+/**
+ * Hook for managing autosave state with proper entity switching support.
+ *
+ * This hook provides three main functions:
+ * 1. `updateValue` - For making changes to the current entity (with autosave)
+ * 2. `setNewEntity` - For switching to a completely different entity (saves previous entity first)
+ * 3. `setValue` - For setting a value without triggering autosave or change tracking
+ *
+ * @example
+ * ```tsx
+ * const [value, updateValue, mutation, setValue, setNewEntity] = useAutosaveState(
+ *   'time_activities',
+ *   defaultTimeActivity,
+ *   {
+ *     delay: 500,
+ *     transformBeforeMutation: (item) => omitFields(item, ['computedField', 'uiOnlyField'])
+ *   }
+ * );
+ *
+ * // For making changes to current entity (autosaves after delay)
+ * updateValue(prev => ({ ...prev, description: 'New description' }));
+ *
+ * // For switching to a different entity (saves current entity first)
+ * setNewEntity(differentTimeActivity);
+ * ```
+ */
+declare function useAutosaveState<T extends TItem & {
+    id: number;
+}, TableName extends string & keyof PublicSchema$1["Tables"] = any, Table extends PublicSchema$1["Tables"][TableName] = any, Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, TItem = Omit<GetResult<PublicSchema$1, Table extends {
+    Row: infer R;
+} ? R extends Record<string, unknown> ? R : any : any, RelationName, Relationships, Query>, "id"> & {
+    id: number;
+}>(relation: TableName, defaultValue: T, options?: AutosaveOptions<T>): [
+    T,
+    React.Dispatch<React.SetStateAction<T>>,
+    UseMutationResult<PostgrestSingleResponse<T>, Error, T, unknown>,
+    React.Dispatch<React.SetStateAction<T>>,
+    (newEntity: T) => void,
+    () => Promise<void>
+];
+
+declare function useToastError<T>(mutation: useDbUpsertResponse): UseMutationResult<unknown, Error, object, unknown>;
+
+declare function executeAdvanceQuery<Result>(supabase: any, query: PromiseLike<PostgrestSingleResponse<Result>>, filterLayer: QueryState): Promise<{
+    data: any;
+    count: number | null;
+    error: any;
+}>;
+
+type CustomPageQueryResult<T extends Record<string, any>[]> = ReturnType<typeof useDbPartialQuery<T>>;
+
+type Attachment = {
+    bucketId: string;
+    path: string;
+};
+declare function useStorageUrl(): {
+    fetchUrl: (entity: {
+        bucketId: string;
+        path: string;
+    }, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }) => Promise<string>;
+    fetchUrls: (entities: Attachment[], options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }) => Promise<Map<string, string | undefined>>;
+    prefetchImage: (entity: Attachment, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }) => Promise<void>;
+    fetchPublicUrl: (entity: {
+        bucketId: string;
+        path: string;
+    }, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }) => Promise<string>;
+    expireCache: (entity: {
+        bucketId: string;
+        path: string;
+    }) => Promise<void>;
+    getCacheVersion: (entity: {
+        bucketId: string;
+        path: string;
+    }) => number;
+    subscribeToCacheVersion: (entity: {
+        bucketId: string;
+        path: string;
+    }, callback: () => void) => () => void;
+};
+
+/**
+ * Metadata stored in storage.objects.metadata JSONB column
+ */
+interface StorageObjectMetadata {
+    processingStatus: "None" | "Processing" | "Error";
+    contentType: string;
+    contentHeight?: number;
+    contentWidth?: number;
+    originalFileName?: string;
+    legacyAttachmentId?: number;
+}
+type UseStoragePathOptions = {
+    /** Whether to fetch metadata from storage.objects (default: true) */
+    fetchMetadata?: boolean;
+    /** Transform options for the URL */
+    transform?: {
+        width?: number;
+        height?: number;
+        quality?: number;
+        format?: "origin";
+    };
+    /** Whether to get a download URL */
+    download?: string | boolean;
+};
+type UseStoragePathResult = {
+    /** Signed URL for the storage object */
+    url: string | null;
+    /** Metadata from storage.objects.metadata JSONB */
+    metadata: StorageObjectMetadata | null;
+    /** Content type (from metadata or inferred from path) */
+    contentType: string;
+    /** Whether the URL or metadata is still loading */
+    isLoading: boolean;
+    /** Error if URL fetch failed */
+    error: Error | null;
+};
+/**
+ * Hook to get a signed URL and metadata for a storage path.
+ * Replaces useAttachment for the path-based storage approach.
+ *
+ * @param storagePath - The path within the bucket (e.g., "14/abc-123.jpg")
+ * @param bucketId - The storage bucket ID
+ * @param options - Optional configuration
+ *
+ * @example
+ * ```tsx
+ * const { url, contentType, isLoading } = useStoragePath(
+ *   profile.profilePath,
+ *   'attachments'
+ * );
+ *
+ * if (isLoading) return <Spinner />;
+ * return <img src={url} />;
+ * ```
+ */
+declare function useStoragePath(storagePath: string | undefined | null, bucketId: string, options?: UseStoragePathOptions): UseStoragePathResult;
+
+/**
+ * Storage bucket names for Supabase storage.
+ * Use these constants when calling storage APIs.
+ */
+declare const BUCKETS: {
+    readonly AVATARS: "avatars";
+    readonly FIXTURE_CATALOG_COVER: "fixture-catalog-cover";
+    readonly FIXTURE_ATTACHMENTS: "fixture-attachments";
+    readonly UNIT_DOCUMENTATION: "unit-documentation-attachments";
+    readonly DATASHEETS: "datasheets";
+    readonly PATTERNS: "patterns";
+    readonly LOGOS: "logos";
+    readonly RECEIPTS: "receipts";
+    readonly TICKET_ATTACHMENTS: "ticket-attachment";
+    readonly PROCESS_RESULTS: "process-results";
+    readonly DATA_EXCHANGE_IMPORTS: "data-exchange-imports";
+    readonly EMAIL_TEMPLATES: "email-templates";
+    readonly EMAIL_TEMPLATES_ASSETS: "email-templates-assets";
+};
+type BucketName = (typeof BUCKETS)[keyof typeof BUCKETS];
+
+declare function createInCondition(column: string, values: (string | number)[]): string;
+
+declare const TIMEOUT_ERROR_MESSAGE = "Request timed out";
+declare const DEFAULT_QUERY_TIMEOUT = 15000;
+declare function isTimeoutError(error: Error | null | undefined): boolean;
+
+interface AlertProps {
+    title: string;
+    description: string;
+}
+interface Context {
+    lastModifiedUserName: string;
+    changeLog: DbChangeLog;
+}
+declare const LiveChangeContext: react.Context<Context>;
+declare const LiveChangeContextProvider: ({ children, changeLog, }: {
+    children: ReactNode;
+    changeLog: DbChangeLog;
+}) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Upsert a changelog (create or update)
+ */
+declare const useUpsertChangelog: () => _tanstack_react_query.UseMutationResult<any, Error, Omit<any, "id"> | (Omit<any, "id"> & {
+    id?: any;
+}), unknown>;
+/**
+ * Delete a changelog
+ * Note: Cascade delete will remove all associated entries and media
+ */
+declare const useDeleteChangelog: () => _tanstack_react_query.UseMutationResult<any, Error, Partial<any>, unknown>;
+/**
+ * Upsert a changelog entry (create or update)
+ */
+declare const useUpsertChangelogEntry: () => _tanstack_react_query.UseMutationResult<any, Error, Omit<any, "id"> | (Omit<any, "id"> & {
+    id?: any;
+}), unknown>;
+/**
+ * Upsert multiple changelog entries at once
+ */
+declare const useMultiUpsertChangelogEntries: () => _tanstack_react_query.UseMutationResult<any[], Error, any[], unknown>;
+/**
+ * Delete a changelog entry
+ * Note: Cascade delete will remove all associated media
+ */
+declare const useDeleteChangelogEntry: () => _tanstack_react_query.UseMutationResult<any, Error, Partial<any>, unknown>;
+/**
+ * Delete multiple changelog entries at once
+ */
+declare const useMultiDeleteChangelogEntries: () => _tanstack_react_query.UseMutationResult<Omit<any, "id">, Error, Omit<any, "id"> | Omit<any, "id">[], unknown>;
+/**
+ * Upsert changelog media (create or update)
+ */
+declare const useUpsertChangelogMedia: () => _tanstack_react_query.UseMutationResult<any, Error, Omit<any, "id"> | (Omit<any, "id"> & {
+    id?: any;
+}), unknown>;
+/**
+ * Delete changelog media
+ */
+declare const useDeleteChangelogMedia: () => _tanstack_react_query.UseMutationResult<any, Error, Partial<any>, unknown>;
+/**
+ * Upload media file for changelog entry
+ * Just returns a simple upload function - caller handles creating ChangelogMedia records
+ */
+declare const useUploadChangelogMedia: () => {
+    mutateAsync: () => Promise<{
+        path: string;
+        publicUrl: string;
+    }>;
+};
+
+/**
+ * Fetch all changelogs with their entries and media
+ * Ordered by release date (newest first)
+ */
+declare const useChangelogs: (options?: {
+    realtime?: boolean;
+}) => (Omit<_tanstack_react_query.QueryObserverRefetchErrorResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverSuccessResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverLoadingErrorResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverPendingResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverPlaceholderResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+});
+/**
+ * Fetch published changelogs only
+ */
+declare const usePublishedChangelogs: (options?: {
+    realtime?: boolean;
+}) => (Omit<_tanstack_react_query.QueryObserverRefetchErrorResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverSuccessResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverLoadingErrorResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverPendingResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+}) | (Omit<_tanstack_react_query.QueryObserverPlaceholderResult<any[], _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_tanstack_react_query.UseQueryResult<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, _supabase_postgrest_js.PostgrestError>, "refetch"> & Pick<_supabase_postgrest_js.PostgrestSingleResponse<any[]>, "count"> & {
+    data: any[];
+    count?: number | null;
+});
+/**
+ * Fetch a single changelog by ID
+ */
+declare const useChangelogById: (id: string | undefined) => UseDbQuerySingleReturn<any>;
+/**
+ * Fetch a single changelog by slug
+ */
+declare const useChangelogBySlug: (slug: string | undefined) => UseDbQuerySingleReturn<any>;
+/**
+ * Fetch changelog entries for a specific changelog
+ */
+declare const useChangelogEntries: (changelogId: string | undefined) => UseDbQuerySingleReturn<any[]>;
+/**
+ * Fetch media for a specific changelog entry
+ */
+declare const useChangelogMedia: (entryId: string | undefined) => UseDbQuerySingleReturn<any[]>;
+
+interface FeedbackListItem {
+    id: number;
+    userId: string | null;
+    table: string | null;
+    schema: string;
+    memoryType: string;
+    resolved: boolean;
+    resolvedAt: string | null;
+    resolvedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+    data: {
+        query: string;
+        queryHash?: string;
+        status?: "success" | "failure" | "needs_review" | "cache_hit";
+        statusMessage?: string;
+        confidence?: number;
+        filters?: any;
+        sql?: string;
+        sqlError?: string;
+        agentDecisions?: any;
+        context?: any;
+        trace?: any;
+        corrections?: {
+            domainTerm?: string;
+            domainFieldPath?: string;
+            fieldPath?: string;
+            filters?: any;
+        };
+        feedback?: string;
+        modelUsed?: string;
+        reasoningEffort?: "minimal" | "medium" | "high";
+        performance?: any;
+        resultCount?: number;
+    };
+}
+interface FeedbackListParams {
+    resolved?: boolean;
+    status?: string;
+    limit?: number;
+    offset?: number;
+    userId?: string;
+    startDate?: string;
+    endDate?: string;
+}
+declare function useFeedbackList(params?: FeedbackListParams): _tanstack_react_query.UseQueryResult<{
+    success: boolean;
+    data: FeedbackListItem[];
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+}, Error>;
+
+interface SubmitFeedbackParams {
+    memoryId?: number;
+    query: string;
+    table: string;
+    schema?: string;
+    status?: "success" | "failure" | "needs_review";
+    corrections?: {
+        domainTerm?: string;
+        domainFieldPath?: string;
+        fieldPath?: string;
+        filters?: any;
+    };
+    feedback?: string;
+}
+declare function useSubmitFeedback(): _tanstack_react_query.UseMutationResult<{
+    success: boolean;
+    data: any;
+}, Error, SubmitFeedbackParams, unknown>;
+
+declare function useApplyFeedback(): _tanstack_react_query.UseMutationResult<{
+    success: boolean;
+    data: any;
+    learningResults: Array<{
+        type: string;
+        id: number;
+        action: string;
+    }>;
+}, Error, number, unknown>;
+
+declare function useResolveFeedback(): _tanstack_react_query.UseMutationResult<{
+    success: boolean;
+    data: any;
+    learningResults: Array<{
+        type: string;
+        id: number;
+    }>;
+}, Error, number, unknown>;
+
+export { LiveChangeContext as $, type UseMutationSuccessOptions as A, useMutationSuccess as B, useMutationSuccessRN as C, getErrorBody as D, type AIOptions as E, type AIResponse as F, useAI as G, type ExtractedReceipt as H, type BatchAnalysisProgress as I, type ServerAvailabilityState as J, useServerAvailability as K, useSearchQuery as L, type MutationOption as M, type UpdateOptions as N, executeAdvanceQuery as O, type PendingExpense as P, type CustomPageQueryResult as Q, type StorageObjectMetadata as R, SupabaseAdapter as S, BUCKETS as T, type UseDbPartialAdvanceQueryResult as U, type BucketName as V, createInCondition as W, TIMEOUT_ERROR_MESSAGE as X, DEFAULT_QUERY_TIMEOUT as Y, isTimeoutError as Z, type AlertProps as _, useDbInsert as a, LiveChangeContextProvider as a0, useUpsertChangelog as a1, useDeleteChangelog as a2, useUpsertChangelogEntry as a3, useMultiUpsertChangelogEntries as a4, useDeleteChangelogEntry as a5, useMultiDeleteChangelogEntries as a6, useUpsertChangelogMedia as a7, useDeleteChangelogMedia as a8, useUploadChangelogMedia as a9, useChangelogs as aa, usePublishedChangelogs as ab, useChangelogById as ac, useChangelogBySlug as ad, useChangelogEntries as ae, useChangelogMedia as af, useFeedbackList as ag, type FeedbackListItem as ah, type FeedbackListParams as ai, useSubmitFeedback as aj, type SubmitFeedbackParams as ak, useApplyFeedback as al, useResolveFeedback as am, useDbUpdate as b, useDbDelete as c, useDbUpsert as d, useDbRealtimeQuery as e, createSupabaseAdapter as f, useSupabaseFunction as g, useReceiptAI as h, useLiveChangeTracking as i, useLatestOperationLog as j, useAutosaveState as k, useToastError as l, useStorageUrl as m, newTimeActivity as n, useStoragePath as o, getSupabaseUrl as p, useDbMultiDelete as q, useDbMultiUpsert as r, setSupabaseUrl as s, useDbPartialAdvanceQuery as t, useDbRealtime as u, type UseDbPartialQueryResult as v, useDbPartialQuery as w, type UseDbRealtimeQueryResult as x, convertFilterToRealtimeQuery as y, type useDbUpsertResponse as z };