@pol-studios/db 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,1486 @@
+import { u as useDbAdvanceFilterQuery, Q as QueryState, T as Tables, D as DbChangeLog } from './index-DNv49L9u.js';
+export { B as BooleanOperator, l as ClarificationQuestion, k as ClarificationSuggestion, C as CompositeTypes, j as ComputedSortConfig, d as Constants, a as Database, E as Enums, f as Filter, e as FilterConditionType, m as FilterContextType, g as FilterGroup, h as FilterInput, F as FilterOperator, i as FilterState, J as Json, O as OrderColumn, P as Pagination, S as Sort, b as TablesInsert, c as TablesUpdate, V as ValueOrArrayForPropertyType, n as normalizeFilter } from './index-DNv49L9u.js';
+export { a as FilterConfig, F as FilterConfigOption, G as Group, P as PropertyType, S as SortConfig, T as TableInfo, V as ValueForPropertyType, W as WhereFilter } from './FilterConfig-Bt2Ek74z.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationResult, QueryClient, UseMutationOptions } from '@tanstack/react-query';
+import { D as Database } from './useSupabase-DO9kQv2O.js';
+export { a as SupabaseDatabaseTypes, S as SupabaseProvider, T as TypedSupabaseClient, U as UserSessionId, c as createNewSupabaseClient, u as default, o as onSupabaseInitialized, s as setDefaultOptions, t as typedSupabase, u as useSupabase } from './useSupabase-DO9kQv2O.js';
+import { G as GetResult } from './select-query-parser-CGI40aOg.js';
+export { S as SelectQueryError } from './select-query-parser-CGI40aOg.js';
+import { G as GenericSchema, a as GenericTable } from './types-DjuX1XHy.js';
+export { F as Fetch, k as GenericFunction, i as GenericNonUpdatableView, h as GenericUpdatableView, j as GenericView, b as PostgrestError, f as PostgrestMaybeSingleResponse, g as PostgrestResponse, d as PostgrestResponseFailure, c as PostgrestResponseSuccess, e as PostgrestSingleResponse, P as Prettify } from './types-DjuX1XHy.js';
+import { useInsertMutation, useUpdateMutation } from '@supabase-cache-helpers/postgrest-react-query';
+import { PostgrestSingleResponse, PostgrestError, RealtimePostgresChangesPayload, SupabaseClient } from '@supabase/supabase-js';
+import * as react from 'react';
+import { ReactNode, JSX } from 'react';
+import { U as UseDbQuerySingleReturn } from './useDbQuery-C-TL8jY1.js';
+export { u as useDbQuery } from './useDbQuery-C-TL8jY1.js';
+import { ItemType as ItemType$6 } from '@pol-studios/utils';
+import { FileOptions, TransformOptions } from '@supabase/storage-js';
+export { u as useBatchDelete, a as useBatchUpsert } from './useBatchUpsert-BHaIk9ID.js';
+import { DatabaseSchema, QueryOptions, DataLayerConfig } from './core/index.js';
+export { AdapterRegistry as AdapterRegistryInterface, AutoStrategy, BuiltQuery, CachedStrategy, ColumnInfo, ColumnType, ConnectionConfig, DataAdapter, DataLayerHooks, DeleteMutationResult, ExtractInsert, ExtractRow, ExtractUpdate, HybridStrategy, MutationHookResult, MutationResult, OrderBy, ParsedSelect, PowerSyncStrategy, QueryResult, QuerySingleResult, RelationshipInfo, RelationshipType, ResolvedRelationship, ScopeDefinition, SelectColumn, SelectRelation, SupabaseStrategy, SyncControl, SyncMode, SyncScope, SyncStatus, TableNames, TableSchema, TableStrategy, UseDbMutationHook, UseDbQueryByIdHook, UseDbQueryHook, WhereClause, WhereOperators } from './core/index.js';
+export { UsePartialAdvancedQueryResult, UsePartialQueryResult, UseQuerySingleReturn, extractColumnNames, extractRelationNames, getRelationSelect, hasRelation, parseSelect, stringifySelect, tokenizeTopLevel, useAdvancedFilterQuery, useAdvancedQuery, useInfiniteQuery, usePartialAdvancedQuery, usePartialQuery, useQuery } from './query/index.js';
+import { Q as QueryExecutor, P as PowerSyncDatabase$1 } from './executor-CB4KHyYG.js';
+export { e as RelationJoinData, R as RelationshipResolver, b as ResultJoiner, S as SQLBuilder, f as createQueryExecutor, c as createRelationshipResolver, d as createResultJoiner, a as createSQLBuilder } from './executor-CB4KHyYG.js';
+import { T as TableDataAdapter, C as CapableDataAdapter, A as AdapterCapabilities, a as AdapterQueryResult, D as DataLayerContextValue } from './index-CMhJjgef.js';
+export { F as ADAPTER_STRATEGIES, I as AdapterAutoDetector, y as AdapterConfig, B as AdapterDependencies, z as AdapterFactory, G as AdapterRegistry, E as AdapterStrategyType, L as AutoDetectionResult, M as AutoDetectorOptions, N as BackendChangeListener, K as BackendStatus, O as DataLayerContext, Q as DataLayerStatus, n as DatabaseTypes, P as PublicTableNames, R as ResolveRowType, S as SchemaNames, o as SchemaTableNames, p as TableIdentifier, w as UseAdvanceQueryOptions, x as UseAdvanceQueryResult, r as UseDbCountOptions, s as UseDbCountResult, U as UseDbInfiniteQueryOptions, q as UseDbInfiniteQueryResult, v as UseDbQueryOptions, t as UseDbQueryResult, J as createAdapterAutoDetector, H as createAdapterRegistry, m as useAdvanceQuery, u as useDataLayer, l as useDbCount, l as useDbCountV3, b as useDbDeleteV3, k as useDbInfiniteQuery, k as useDbInfiniteQueryV3, c as useDbInsertV3, e as useDbQueryById, d as useDbQueryV3, f as useDbUpdateV3, g as useDbUpsertV3, h as useOnlineStatus, i as useSyncControl, j as useSyncStatus } from './index-CMhJjgef.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_dropzone from 'react-dropzone';
+import { FileRejection, FileError } from 'react-dropzone';
+export { AnyPostgrestResponse, FilterDefinition, FilterDefinitions, FilterFn, NestedPath, OPERATOR_MAP, OperatorFn, OrderDefinition, Path, PostgrestFilter, PostgrestFilterOperator, PostgrestHasMorePaginationCacheData, PostgrestHasMorePaginationResponse, PostgrestPaginationCacheData, PostgrestPaginationResponse, PostgrestParser, PostgrestQueryParser, PostgrestQueryParserOptions, SUPPORTED_OPERATORS, ValueType, binarySearch, buildSortedComparator, denormalize, encodeObject, extractPathsFromFilters, filterFilterDefinitionsByPaths, findFilters, findIndexOrdered, findLastIndex, get, getTable, groupPathsRecursive, ifDateGetTime, isAndFilter, isAnyPostgrestResponse, isFilterDefinition, isISODateString, isNestedPath, isNotNull, isObject, isOrFilter, isPostgrestBuilder, isPostgrestHasMorePaginationCacheData, isPostgrestHasMorePaginationResponse, isPostgrestPaginationCacheData, isPostgrestPaginationResponse, parseOrderByKey, parseSelectParam, parseValue, removeAliasFromDeclaration, removeFirstPathElement, setFilterValue, sortSearchParams } from './parser/index.js';
+export { Accessory, Address, AdvanceQuery, AdvanceQueryNotificationSetting, AdvancedQueryView, BillableService, BillingDetails, CachedEmbedding, Changelog, ChangelogEntry, ChangelogMedia, ChargeTable, Circuit, Client, Comment, CommentReaction, CommentRead, CommentSection, CommentTag, CommonNote, CommonNoteCategory, CommonNoteSubCategory, ControlComponent, ControlComponentDatasheet, Controller, CoreSavedQuery, CoreSavedQueryAccess, Currency, CurrencyUsdConversion, DataExchangeImport, Datasheet, Dimension, DimmerModule, DimmerRack, Embedding, EquipmentConfigurationGroup, EquipmentFixture, EquipmentFixtureConfiguration, EquipmentFixtureConfigurationAccessoryEntry, EquipmentFixtureConfigurationControlComponentEntry, EquipmentFixtureCost, EquipmentFixtureDatasheet, EquipmentFixtureDimension, EquipmentFixtureDocument, EquipmentFixtureLampConfiguration, EquipmentFixtureListing, EquipmentFixtureMode, EquipmentFixtureModeChannel, EquipmentFixturePreset, EquipmentFixtureUnit, EquipmentFixtureUnitControl, EquipmentFixtureUnitLocation, EquipmentFixtureUnitLocationTag, EquipmentFixtureUnitLocationTagValue, EquipmentFixtureUnitPatternEntry, EquipmentFixtureWeight, EquipmentType, EquipmentUnitMediaContent, Expense, ExpenseLineItem, ExpenseReport, Fixture, FixtureCatalog, FixtureCatalogItem, FixtureCategory, FixtureTag, GlobalExpenseReport, HighlightServer, HighlightServerInstance, HighlightServerInstanceLog, HighlightServerInstanceOptions, HighlightServerInstanceStatus, HighlightServerRequest, Invoice, InvoiceSummaryTable, InvoiceTerm, InvoiceTermCondition, Lamp, LampCategory, LampCurrentListing, LampType, LicenseAssignment, Logo, Manufacturer, ManufacturerTag, ManufacturerToTag, OperationLog, OrderHinted, Organization, OrganizationUser, OrganizationUserAccess, ParameterMappingProfile, ParameterMappingProfileAssignment, Pattern, PaymentCustomer, PaymentInvoice, PaymentPaymentIntents, PaymentPlan, PaymentProduct, PaymentProductFeature, PaymentSubscription, PaymentSubscriptionPlan, PhaseActivityBucket, ProfileConfig as Profile, ProfileConfig, ProfileTimeBank, Project, ProjectDatabase, ProjectDatabaseEquipmentConfigurationGroup, ProjectDatabaseExcelParameterAssignment, ProjectDatabaseGroup, ProjectDatabaseParameterMappingProfile, ProjectDefaultRateByTitle, ProjectDocument, ProjectDocumentLineItem, PunchList, PunchListAccess, PunchListItem, PunchListItemAssignment, PunchListItemAttachedEntity, PunchListItemAttachment, PunchListItemCheckListItem, PunchListPage, PunchListPageAccess, PunchListUserOrderHint, QrCode, RetainageItem, RevitEquipmentUnitChange, RevitImport, RevitValueChangedEvent, Role, Service, ServiceCosts, ServiceStorageHourly, SmartCode, SmartCodeTag, Subtask, SystemBroadcastChannel, SystemBroadcastChannelThrottle, SystemConfiguration, SystemEmailNotification, SystemEvent, SystemEventListener, SystemEventWorker, SystemGlobalVariables, SystemHealthCheck, SystemInAppNotification, SystemLog, SystemMutedTopic, SystemNotification, SystemPushNotification, SystemSubscriber, SystemSupportAccess, SystemSupportTeam, SystemTask, SystemTaskAttempt, SystemTaskAttemptAccess, SystemTemp, SystemTicket, SystemTicketAttachment, SystemTicketComment, SystemTicketCommentAttachment, SystemUserPushTokens, Tag, Task, TaxCategory, Ticket, TicketAttachment, TicketComment, TicketCommentAttachment, TimeActivity, TimeBankTransaction, UserMetadata, UserTimesheet, WeeklyTimesheet, WorkEstimation, WorkEstimationLineItem, WorkingPhase, WorkingPhaseBillingItemDailySummary, WorkingPhaseBillingItemLatestSummary, WorkingPhaseCategory, WorkingPhaseDailySummary, WorkingPhaseRoleRate, WorkingPhaseSummary } from './gen/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import '@supabase/supabase-js/dist/module/lib/types.js';
+
+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;
+
+/**
+ * PowerSync Adapter
+ *
+ * Wraps the QueryExecutor to execute queries against PowerSync's local SQLite database.
+ * Implements the TableDataAdapter interface for use with the V3 data layer.
+ *
+ * This adapter provides offline-first data access by querying the local SQLite
+ * database that PowerSync keeps synchronized with Supabase.
+ */
+
+/**
+ * Handler interface for PowerSync watch callbacks.
+ */
+interface WatchHandler {
+    onResult: (results: {
+        rows?: {
+            _array: Record<string, unknown>[];
+        };
+    }) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Options for PowerSync watch operations.
+ */
+interface SQLWatchOptions {
+    signal?: AbortSignal;
+    tables?: string[];
+    throttleMs?: number;
+}
+/**
+ * Extended PowerSync database interface that includes watch functionality.
+ * This extends the base interface from the executor to add reactive query support.
+ *
+ * The watch method is optional to maintain backward compatibility with databases
+ * that don't support reactive queries. When not available, subscribe will fall
+ * back to polling.
+ */
+interface PowerSyncDatabase {
+    getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
+    get<T>(sql: string, params?: unknown[]): Promise<T | null>;
+    execute(sql: string, params?: unknown[]): Promise<{
+        rowsAffected: number;
+    }>;
+    /**
+     * Watch a SQL query for changes.
+     * Executes the query and invokes the handler whenever the underlying data changes.
+     * Optional - if not available, subscribe will fall back to polling.
+     */
+    watch?(sql: string, parameters?: unknown[], handler?: WatchHandler, options?: SQLWatchOptions): void;
+}
+/**
+ * PowerSyncAdapter implements the TableDataAdapter interface by delegating
+ * all operations to the QueryExecutor.
+ *
+ * @example
+ * const adapter = createPowerSyncAdapter(powerSyncDb, schema);
+ *
+ * // Query with filtering and pagination
+ * const { data, count } = await adapter.query<EquipmentUnit>("EquipmentUnit", {
+ *   where: { status: "active" },
+ *   orderBy: [{ field: "name", direction: "asc" }],
+ *   limit: 10
+ * });
+ *
+ * // Query with relations
+ * const { data } = await adapter.query<EquipmentUnitWithRelations>("EquipmentUnit", {
+ *   select: "*, EquipmentFixture(*), ProjectDatabase(name)"
+ * });
+ */
+declare class PowerSyncAdapter implements TableDataAdapter, CapableDataAdapter {
+    private db;
+    private schema;
+    /**
+     * Unique identifier for this adapter type
+     */
+    readonly name = "powersync";
+    /**
+     * Capabilities supported by this adapter
+     */
+    readonly capabilities: AdapterCapabilities;
+    /**
+     * The underlying query executor
+     */
+    private executor;
+    /**
+     * Create a new PowerSyncAdapter
+     *
+     * @param db - PowerSync database instance
+     * @param schema - Database schema for relationship resolution
+     */
+    constructor(db: PowerSyncDatabase, schema: DatabaseSchema);
+    /**
+     * Execute a query and return results with optional count for pagination.
+     *
+     * @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>;
+    /**
+     * Subscribe to changes on a query using PowerSync's native watch() API.
+     *
+     * This uses PowerSync's reactive query watching which efficiently detects
+     * changes to the underlying data and re-executes the query only when needed.
+     *
+     * If the database doesn't support watch(), falls back to polling every 5 seconds.
+     *
+     * @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;
+    /**
+     * Fallback polling-based subscription for databases that don't support watch().
+     *
+     * @internal
+     */
+    private subscribeWithPolling;
+    /**
+     * 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.
+     * If the record has an ID and exists, it will be updated.
+     * Otherwise, a new record will be inserted.
+     *
+     * @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>;
+    /**
+     * Get the underlying QueryExecutor for advanced use cases.
+     *
+     * This allows direct access to the executor for operations that
+     * may not be covered by the TableDataAdapter interface.
+     *
+     * @returns The QueryExecutor instance
+     */
+    getExecutor(): QueryExecutor;
+    /**
+     * Get the raw PowerSync database for advanced use cases.
+     *
+     * This allows direct SQL execution when the adapter methods
+     * are not sufficient.
+     *
+     * @returns The PowerSyncDatabase instance
+     */
+    getDatabase(): PowerSyncDatabase;
+    /**
+     * Get the database schema.
+     *
+     * @returns The DatabaseSchema used for relationship resolution
+     */
+    getSchema(): DatabaseSchema;
+}
+/**
+ * Create a new PowerSyncAdapter instance.
+ *
+ * This is the recommended way to create a PowerSyncAdapter as it provides
+ * a cleaner API and allows for future enhancements without breaking changes.
+ *
+ * @param db - PowerSync database instance
+ * @param schema - Database schema for relationship resolution
+ * @returns A new PowerSyncAdapter instance
+ *
+ * @example
+ * import { createPowerSyncAdapter } from "./adapters/powersync-adapter";
+ *
+ * const adapter = createPowerSyncAdapter(powerSyncDb, databaseSchema);
+ *
+ * // Use the adapter
+ * const { data } = await adapter.query("EquipmentUnit", {
+ *   where: { status: "active" }
+ * });
+ */
+declare function createPowerSyncAdapter(db: PowerSyncDatabase, schema: DatabaseSchema): PowerSyncAdapter;
+
+/**
+ * V3 Data Layer Provider
+ *
+ * React context provider that initializes adapters, manages the PowerSync lifecycle,
+ * and provides context for all V3 hooks. This is the main entry point for the V3
+ * data layer in a React application.
+ */
+
+/**
+ * Props for DataLayerProvider
+ */
+interface DataLayerProviderProps {
+    /** Data layer configuration */
+    config: DataLayerConfig;
+    /** Children to render */
+    children: ReactNode;
+    /** Optional PowerSync database instance */
+    powerSyncInstance?: PowerSyncDatabase$1 | null;
+    /** Supabase client (required) */
+    supabaseClient: SupabaseClient;
+    /** React Query client (required) */
+    queryClient: QueryClient;
+    /** Callback when initialization completes */
+    onInitialized?: (context: DataLayerContextValue) => void;
+    /** Callback when error occurs */
+    onError?: (error: Error) => void;
+}
+/**
+ * Provider component for the V3 data layer.
+ *
+ * This provider:
+ * - Creates and manages the AdapterRegistry
+ * - Initializes the AdapterAutoDetector for backend selection
+ * - Sets up Supabase and PowerSync adapters
+ * - Tracks online/offline status
+ * - Provides context for all V3 hooks
+ *
+ * @example
+ * ```tsx
+ * import { DataLayerProvider } from "@pol-studios/db";
+ *
+ * function App() {
+ *   return (
+ *     <DataLayerProvider
+ *       config={dataLayerConfig}
+ *       supabaseClient={supabase}
+ *       queryClient={queryClient}
+ *       powerSyncInstance={powerSyncDb}
+ *     >
+ *       <YourApp />
+ *     </DataLayerProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function DataLayerProvider({ config, children, powerSyncInstance, supabaseClient, queryClient, onInitialized, onError, }: DataLayerProviderProps): JSX.Element;
+
+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;
+
+/**
+ * Platform-aware network status utility
+ *
+ * Provides unified network connectivity detection for both web (browser)
+ * and React Native environments.
+ *
+ * - On React Native: Uses @react-native-community/netinfo
+ * - On Web: Uses navigator.onLine and window online/offline events
+ */
+/**
+ * Check if we're running in React Native environment
+ */
+declare function isReactNative(): boolean;
+/**
+ * Get current online status
+ *
+ * @returns Promise resolving to true if online, false if offline
+ */
+declare function getOnlineStatus(): Promise<boolean>;
+/**
+ * Get current online status synchronously (browser only, RN returns cached/default)
+ * Use getOnlineStatus() for accurate cross-platform results
+ *
+ * @returns true if online (or unknown), false if offline
+ */
+declare function getOnlineStatusSync(): boolean;
+/**
+ * Subscribe to network status changes
+ *
+ * @param callback - Function called when online status changes
+ * @returns Unsubscribe function
+ */
+declare function subscribeToNetworkChanges(callback: (isOnline: boolean) => void): () => void;
+/**
+ * Initialize network monitoring (call early in app lifecycle)
+ * This pre-loads NetInfo on React Native for faster subsequent calls
+ */
+declare function initializeNetworkMonitoring(): Promise<void>;
+
+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 { type AIOptions, type AIResponse, AdapterCapabilities, AdapterQueryResult, type AlertProps, BUCKETS, type BatchAnalysisProgress, type BucketName, CapableDataAdapter, type CustomPageQueryResult, DEFAULT_QUERY_TIMEOUT, DataLayerConfig, DataLayerContextValue, DataLayerProvider, type DataLayerProviderProps, DatabaseSchema, DbChangeLog, type ExtractedReceipt, type FeedbackListItem, type FeedbackListParams, GenericSchema, GenericTable, GetResult, LiveChangeContext, LiveChangeContextProvider, type MutationOption, type PendingExpense, PowerSyncAdapter, PowerSyncDatabase$1 as PowerSyncDatabase, QueryExecutor, QueryOptions, QueryState, type ServerAvailabilityState, type StorageObjectMetadata, type SubmitFeedbackParams, SupabaseAdapter, TIMEOUT_ERROR_MESSAGE, TableDataAdapter, Tables, type UpdateOptions, type UseDbPartialAdvanceQueryResult, type UseDbPartialQueryResult, UseDbQuerySingleReturn, type UseDbRealtimeQueryResult, type UseMutationSuccessOptions, type UseSupabaseUploadOptions, type UseSupabaseUploadReturn, convertFilterToRealtimeQuery, createInCondition, createPowerSyncAdapter, createSupabaseAdapter, executeAdvanceQuery, getErrorBody, getOnlineStatus, getOnlineStatusSync, getSupabaseUrl, initializeNetworkMonitoring, isReactNative, isTimeoutError, newTimeActivity, sanitizeStorageKey, setSupabaseUrl, subscribeToNetworkChanges, useAI, useApplyFeedback, useAutosaveState, useChangelogById, useChangelogBySlug, useChangelogEntries, useChangelogMedia, useChangelogs, useDbAdvanceFilterQuery, useDbAdvanceFilterQuery as useDbAdvanceQuery, useDbDelete, useDbInsert, useDbMultiDelete, useDbMultiUpsert, useDbPartialAdvanceQuery, useDbPartialQuery, useDbRealtime, useDbRealtimeQuery, useDbUpdate, useDbAttachmentUpload as useDbUpload, useDbUpsert, type useDbUpsertResponse, useDbDelete as useDelete, useDeleteChangelog, useDeleteChangelogEntry, useDeleteChangelogMedia, useFeedbackList, useDbInsert as useInsert, useLatestOperationLog, useLiveChangeTracking, useMultiDeleteChangelogEntries, useMultiUpsertChangelogEntries, useMutationSuccess, useMutationSuccessRN, usePublishedChangelogs, useDbRealtime as useRealtime, useDbRealtimeQuery as useRealtimeQuery, useReceiptAI, useResolveFeedback, useSearchQuery, useServerAvailability, useStoragePath, useStorageUrl, useSubmitFeedback, useSupabaseFunction, useSupabaseUpload, useToastError, useDbUpdate as useUpdate, useUploadChangelogMedia, useDbUpsert as useUpsert, useUpsertChangelog, useUpsertChangelogEntry, useUpsertChangelogMedia };