@pol-studios/db 1.0.1 → 1.0.2

package/dist/useResolveFeedback-DuGP4Tgb.d.ts

@@ -0,0 +1,1165 @@
+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 { FileOptions, TransformOptions } from '@supabase/storage-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 * as react_dropzone from 'react-dropzone';
+import { FileRejection, FileError } from 'react-dropzone';
+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 RequestOptions = {
+    onUploadProgress?: (bytesUploaded: number, bytesTotal: number) => any;
+};
+declare function sanitizeStorageKey(path: string): string;
+declare function useDbAttachmentUpload(bucketId: string, options?: RequestOptions): _tanstack_react_query.UseMutationResult<{
+    bucketId: string;
+    path: string;
+    contentType: string;
+}, Error, {
+    directory?: string;
+    fileName?: string;
+    file: File | Blob | Pick<ReadableStreamDefaultReader, "read">;
+    onUploadProgress?: (bytesUploaded: number, bytesTotal: number) => any;
+} & FileOptions, 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;
+};
+
+interface FileWithPreview extends File {
+    preview?: string;
+    errors: readonly FileError[];
+}
+type UseSupabaseUploadOptions = {
+    /**
+     * Name of bucket to upload files to in your Supabase project
+     */
+    bucketName: string;
+    /**
+     * Folder to upload files to in the specified bucket within your Supabase project.
+     *
+     * Defaults to uploading files to the root of the bucket
+     *
+     * e.g If specified path is `test`, your file will be uploaded as `test/file_name`
+     */
+    path?: string;
+    /**
+     * Allowed MIME types for each file upload (e.g `image/png`, `text/html`, etc). Wildcards are also supported (e.g `image/*`).
+     *
+     * Defaults to allowing uploading of all MIME types.
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Maximum upload size of each file allowed in bytes. (e.g 1000 bytes = 1 KB)
+     */
+    maxFileSize?: number;
+    /**
+     * Maximum number of files allowed per upload.
+     */
+    maxFiles?: number;
+    /**
+     * The number of seconds the asset is cached in the browser and in the Supabase CDN.
+     *
+     * This is set in the Cache-Control: max-age=<seconds> header. Defaults to 3600 seconds.
+     */
+    cacheControl?: number;
+    /**
+     * When set to true, the file is overwritten if it exists.
+     *
+     * When set to false, an error is thrown if the object already exists. Defaults to `false`
+     */
+    upsert?: boolean;
+};
+type UseSupabaseUploadReturn = ReturnType<typeof useSupabaseUpload>;
+declare const useSupabaseUpload: (options: UseSupabaseUploadOptions) => {
+    open: () => void;
+    isFocused: boolean;
+    isDragActive: boolean;
+    isDragAccept: boolean;
+    isDragReject: boolean;
+    isFileDialogActive: boolean;
+    acceptedFiles: readonly react_dropzone.FileWithPath[];
+    fileRejections: readonly FileRejection[];
+    rootRef: React.RefObject<HTMLElement>;
+    inputRef: React.RefObject<HTMLInputElement>;
+    getRootProps: <T extends react_dropzone.DropzoneRootProps>(props?: T) => T;
+    getInputProps: <T extends react_dropzone.DropzoneInputProps>(props?: T) => T;
+    files: FileWithPreview[];
+    setFiles: react.Dispatch<react.SetStateAction<FileWithPreview[]>>;
+    successes: string[];
+    isSuccess: boolean;
+    loading: boolean;
+    errors: {
+        name: string;
+        message: string;
+    }[];
+    setErrors: react.Dispatch<react.SetStateAction<{
+        name: string;
+        message: string;
+    }[]>>;
+    onUpload: () => Promise<void>;
+    maxFileSize: number;
+    maxFiles: number;
+    allowedMimeTypes: string[];
+};
+
+/**
+ * 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 { createInCondition as $, sanitizeStorageKey as A, type useDbUpsertResponse as B, type UseMutationSuccessOptions as C, useMutationSuccess as D, useMutationSuccessRN as E, getErrorBody as F, type AIOptions as G, type AIResponse as H, useAI as I, type ExtractedReceipt as J, type BatchAnalysisProgress as K, type ServerAvailabilityState as L, type MutationOption as M, useServerAvailability as N, useSearchQuery as O, type PendingExpense as P, type UpdateOptions as Q, executeAdvanceQuery as R, SupabaseAdapter as S, type CustomPageQueryResult as T, type UseDbPartialAdvanceQueryResult as U, useSupabaseUpload as V, type UseSupabaseUploadOptions as W, type UseSupabaseUploadReturn as X, type StorageObjectMetadata as Y, BUCKETS as Z, type BucketName as _, useDbAttachmentUpload as a, TIMEOUT_ERROR_MESSAGE as a0, DEFAULT_QUERY_TIMEOUT as a1, isTimeoutError as a2, type AlertProps as a3, LiveChangeContext as a4, LiveChangeContextProvider as a5, useUpsertChangelog as a6, useDeleteChangelog as a7, useUpsertChangelogEntry as a8, useMultiUpsertChangelogEntries as a9, useDeleteChangelogEntry as aa, useMultiDeleteChangelogEntries as ab, useUpsertChangelogMedia as ac, useDeleteChangelogMedia as ad, useUploadChangelogMedia as ae, useChangelogs as af, usePublishedChangelogs as ag, useChangelogById as ah, useChangelogBySlug as ai, useChangelogEntries as aj, useChangelogMedia as ak, useFeedbackList as al, type FeedbackListItem as am, type FeedbackListParams as an, useSubmitFeedback as ao, type SubmitFeedbackParams as ap, useApplyFeedback as aq, useResolveFeedback as ar, useDbInsert as b, useDbUpdate as c, useDbDelete as d, useDbUpsert as e, useDbRealtimeQuery as f, createSupabaseAdapter as g, useSupabaseFunction as h, useReceiptAI as i, useLiveChangeTracking as j, useLatestOperationLog as k, useAutosaveState as l, useToastError as m, newTimeActivity as n, useStorageUrl as o, useStoragePath as p, getSupabaseUrl as q, useDbMultiDelete as r, setSupabaseUrl as s, useDbMultiUpsert as t, useDbRealtime as u, useDbPartialAdvanceQuery as v, type UseDbPartialQueryResult as w, useDbPartialQuery as x, type UseDbRealtimeQueryResult as y, convertFilterToRealtimeQuery as z };