@pol-studios/db 1.0.19 → 1.0.22

package/dist/useResolveFeedback-DTGcHpCs.d.ts

@@ -0,0 +1,882 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationResult, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { SupabaseClient, PostgrestSingleResponse as PostgrestSingleResponse$1, PostgrestError } from '@supabase/supabase-js';
+import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult } from './DataLayerContext-ZmLPYR_s.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 } from '@supabase/postgrest-js';
+import { G as GetResult } from './select-query-parser-BwyHum1L.js';
+import { G as GenericTable } from './types-CYr9JiUE.js';
+import { D as Database } from './useSupabase-DvWVuHHE.js';
+import { D as DbChangeLog, Q as QueryState } from './index-2YySlz7X.js';
+import { U as UseDbQuerySingleReturn } from './useDbQuery-C-TL8jY1.js';
+import { J as UseDbUpsertResult } from './useDbCount-s-aR9YeV.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;
+
+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 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 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<Result>>, searchText: string, columns: ((string & keyof Result) | string)[], options?: {
+    isOptional: boolean;
+    additionCondition: (string | undefined)[];
+}): PromiseLike<PostgrestSingleResponse<Result>>;
+
+type PublicSchema$1 = 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$1["Tables"], Table extends PublicSchema$1["Tables"][TableName] = PublicSchema$1["Tables"][TableName], Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, TItem = GetResult<PublicSchema$1, 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 = 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: string;
+}, TableName extends string & keyof PublicSchema["Tables"] = any, Table extends PublicSchema["Tables"][TableName] = any, Query extends string = "*", RelationName = unknown, Relationships = Table extends {
+    Relationships: infer R;
+} ? R : unknown, TItem = Omit<GetResult<PublicSchema, Table extends {
+    Row: infer R;
+} ? R extends Record<string, unknown> ? R : any : any, RelationName, Relationships, Query>, "id"> & {
+    id: string;
+}>(relation: TableName, defaultValue: T, options?: AutosaveOptions<T>): [
+    T,
+    React.Dispatch<React.SetStateAction<T>>,
+    UseDbUpsertResult<T>,
+    React.Dispatch<React.SetStateAction<T>>,
+    (newEntity: T) => void,
+    () => Promise<void>
+];
+
+declare function useToastError<T>(mutation: UseDbUpsertResult<T>): UseDbUpsertResult<T>;
+
+declare function executeAdvanceQuery<Result>(supabase: any, query: PromiseLike<PostgrestSingleResponse$1<Result>>, filterLayer: QueryState): Promise<{
+    data: any;
+    count: number | null;
+    error: any;
+}>;
+
+type UseDbPartialQueryResult<T extends Record<string, any>> = ReturnType<typeof useDbPartialQuery<T[]>>;
+declare function useDbPartialQuery<Result extends Record<string, any>[]>(query: PromiseLike<PostgrestSingleResponse$1<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$1<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$1<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$1<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$1<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$1<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$1<Result>, PostgrestError>>;
+    count: number | null;
+};
+
+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: () => UseDbUpsertResult<Record<string, 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: () => UseDbUpsertResult<Record<string, 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: () => UseDbUpsertResult<Record<string, 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 { type SubmitFeedbackParams as $, type AIOptions as A, BUCKETS as B, type CustomPageQueryResult as C, DEFAULT_QUERY_TIMEOUT as D, useUpsertChangelog as E, useDeleteChangelog as F, useUpsertChangelogEntry as G, useMultiUpsertChangelogEntries as H, useDeleteChangelogEntry as I, useMultiDeleteChangelogEntries as J, useUpsertChangelogMedia as K, LiveChangeContext as L, useDeleteChangelogMedia as M, useUploadChangelogMedia as N, useChangelogs as O, usePublishedChangelogs as P, useChangelogById as Q, useChangelogBySlug as R, SupabaseAdapter as S, TIMEOUT_ERROR_MESSAGE as T, type UseMutationSuccessOptions as U, useChangelogEntries as V, useChangelogMedia as W, useFeedbackList as X, type FeedbackListItem as Y, type FeedbackListParams as Z, useSubmitFeedback as _, useLatestOperationLog as a, useApplyFeedback as a0, useResolveFeedback as a1, type UseDbPartialQueryResult as a2, useDbPartialQuery as a3, useAutosaveState as b, useToastError as c, useStorageUrl as d, useStoragePath as e, useMutationSuccess as f, getSupabaseUrl as g, useMutationSuccessRN as h, createSupabaseAdapter as i, getErrorBody as j, type AIResponse as k, useAI as l, type ServerAvailabilityState as m, newTimeActivity as n, useServerAvailability as o, useSearchQuery as p, type UpdateOptions as q, executeAdvanceQuery as r, setSupabaseUrl as s, type StorageObjectMetadata as t, useLiveChangeTracking as u, type BucketName as v, createInCondition as w, isTimeoutError as x, type AlertProps as y, LiveChangeContextProvider as z };