@pol-studios/db 1.0.17 → 1.0.19

package/dist/parser/index.d.ts

@@ -1,366 +0,0 @@
-import { PostgrestBuilder, PostgrestSingleResponse, PostgrestMaybeSingleResponse, PostgrestResponse, PostgrestQueryBuilder } from '@supabase/postgrest-js';
-export { G as GetResult, S as SelectQueryError } from '../select-query-parser-BwyHum1L.js';
-export { F as Fetch, i as GenericFunction, g as GenericNonUpdatableView, j as GenericSchema, G as GenericTable, f as GenericUpdatableView, h as GenericView, P as PostgrestError, d as PostgrestMaybeSingleResponse, e as PostgrestResponse, b as PostgrestResponseFailure, a as PostgrestResponseSuccess, c as PostgrestSingleResponse, k as Prettify } from '../types-CYr9JiUE.js';
-
-/**
- * A function that validates whether the given input is an object of type Type
- * @returns true if obj is of type Type, false if not
- */
-type FilterFn<Type extends Record<string, unknown>> = (obj: unknown) => obj is Type;
-/**
- * The supported value types
- */
-type ValueType = number | string | boolean | null | Date | object;
-/**
- * A function implementing a FilterOperators
- * @param columnValue the value of the input object to test the filter against
- * @param filterValue the value of the filter, e.g. in .eq('colname', 'filterValue'), 'filterValue' would be the filterValue
- * @returns true if the filter applies, false if not
- */
-type OperatorFn = (columnValue: any, filterValue: any) => boolean;
-/**
- * All supported operators of PostgREST
- */
-type PostgrestFilterOperator = 'or' | 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'fts' | 'plfts';
-/**
- * An object describing a selected path of a query
- *
- */
-type Path = {
-    /**
-     * The aliased path if a column or relation name mapping is used within the path
-     */
-    alias?: string;
-    /**
-     * The "real" path of a column
-     */
-    path: string;
-    /**
-     * The full declaration of a column that includes alias, hints and inner joins
-     */
-    declaration: string;
-};
-/**
- * A decomposed filter applied to a query
- */
-type FilterDefinition = {
-    /**
-     * The path to which the filter is applied
-     */
-    path: string;
-    /**
-     * The aliased path if a column or relation name mapping is used
-     */
-    alias?: string;
-    /**
-     * The operator that is applied
-     */
-    operator: PostgrestFilterOperator;
-    /**
-     * Whether or not to negate the results of the filter, e.g. when .not('name', 'eq', 'Paris') is applied
-     */
-    negate: boolean;
-    /**
-     * The value of the filter
-     */
-    value: ValueType;
-};
-/**
- * A json representation of PostgREST filters that are applied to a query
- */
-type FilterDefinitions = ({
-    or: FilterDefinitions;
-} | {
-    and: FilterDefinitions;
-} | FilterDefinition)[];
-type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
-declare const isAndFilter: (f: ArrayElement<FilterDefinitions>) => f is {
-    and: FilterDefinitions;
-};
-declare const isOrFilter: (f: ArrayElement<FilterDefinitions>) => f is {
-    or: FilterDefinitions;
-};
-declare const isFilterDefinition: (f: ArrayElement<FilterDefinitions>) => f is FilterDefinition;
-type OrderDefinition = {
-    column: string;
-    ascending: boolean;
-    nullsFirst: boolean;
-    foreignTable?: string;
-};
-
-declare const SUPPORTED_OPERATORS: string[];
-type PostgrestQueryParserOptions = {
-    /**
-     * If defined, will use only filters that apply to the given paths
-     */
-    exclusivePaths?: string[];
-};
-declare class PostgrestQueryParser {
-    readonly opts?: PostgrestQueryParserOptions;
-    private readonly _params;
-    private _filters;
-    private _paths;
-    constructor(query: string, opts?: PostgrestQueryParserOptions);
-    /**
-     * Getter that returns the paths and their aliases that the query selects. Will do the computation only once.
-     *
-     * ```js
-     * const p = new PostgrestParser(
-     * supabaseClient.from("test")
-     *    .select(
-     *      `name,
-     *       city:cities (
-     *        test:name
-     *      ),
-     *      countries (
-     *        capital,
-     *        population,
-     *        some_ref (
-     *          test:first,
-     *          second
-     *        )
-     *      )`
-     *    );
-     * console.log(p.paths);
-     * //  [
-     * //    { alias: undefined, path: "name" },
-     * //    { alias: "city.test", path: "cities.name" },
-     * //    { alias: undefined, path: "countries.capital" },
-     * //    { alias: undefined, path: "countries.population" },
-     * //    {
-     * //      alias: "countries.some_ref.test",
-     * //      path: "countries.some_ref.first",
-     * //    },
-     * //    { alias: undefined, path: "countries.some_ref.second" },
-     * //  ];
-     * ```
-     *
-     * @returns an array of paths that the query selects, containing the columns and aliases
-     */
-    get paths(): Path[];
-    /**
-     * Getter that returns the filters that this query applies in a json object.
-     *
-     * ```js
-     * const p = new PostgrestParser(
-     * supabaseClient.from("test").select('*')
-     *  .or("full_name.eq.20,test.neq.true,and(full_name.eq.Test Name,email.eq.test@mail.com)")
-     *  .eq("id", "123")
-     *  .contains("id", "456")
-     * );
-     *
-     * console.log(p.filters);
-     *
-     * // [
-     * //   {
-     * //     or: [
-     * //       {
-     * //         path: "full_name",
-     * //         negate: false,
-     * //         operator: "eq",
-     * //         value: 20,
-     * //       },
-     * //       {
-     * //         path: "test",
-     * //         negate: false,
-     * //         operator: "neq",
-     * //         value: true,
-     * //       },
-     * //       {
-     * //         and: [
-     * //           {
-     * //             path: "full_name",
-     * //             negate: false,
-     * //             operator: "eq",
-     * //             value: "Test Name",
-     * //           },
-     * //           {
-     * //             path: "email",
-     * //             negate: false,
-     * //             operator: "eq",
-     * //             value: "test@mail.com",
-     * //           },
-     * //         ],
-     * //       },
-     * //     ],
-     * //   },
-     * //   {
-     * //     path: "id",
-     * //     negate: false,
-     * //     operator: "eq",
-     * //     value: 123,
-     * //   },
-     * //   {
-     * //     path: "id",
-     * //     negate: false,
-     * //     operator: "cs",
-     * //     value: 456,
-     * //   },
-     * // ];
-     * ```
-     *
-     * @returns a FilterDefinitions object
-     */
-    get filters(): FilterDefinitions;
-    private parseFilterString;
-}
-
-declare class PostgrestParser<Result> extends PostgrestQueryParser {
-    readonly opts?: PostgrestQueryParserOptions;
-    private readonly _url;
-    private readonly _headers;
-    private readonly _body;
-    readonly method: "GET" | "HEAD" | "POST" | "PATCH" | "DELETE";
-    readonly select: string;
-    readonly queryKey: string;
-    readonly bodyKey: string | undefined;
-    readonly count: string | null;
-    readonly schema: string;
-    readonly table: string;
-    readonly isHead: boolean | undefined;
-    readonly limit: number | undefined;
-    readonly offset: number | undefined;
-    readonly orderBy: OrderDefinition[];
-    readonly orderByKey: string;
-    readonly searchParams: URLSearchParams;
-    constructor(fb: PostgrestBuilder<any, Result>, opts?: PostgrestQueryParserOptions);
-}
-
-declare class PostgrestFilter<Result extends Record<string, unknown>> {
-    readonly params: {
-        filters: FilterDefinitions;
-        paths: Path[];
-    };
-    private _fn;
-    private _selectFn;
-    private _filtersFn;
-    private _filterPaths;
-    constructor(params: {
-        filters: FilterDefinitions;
-        paths: Path[];
-    });
-    static fromQuery(query: string, opts?: PostgrestQueryParserOptions): PostgrestFilter<Record<string, unknown>>;
-    static fromBuilder<Result extends Record<string, unknown> = Record<string, unknown>>(fb: PostgrestBuilder<any, Result>, opts?: PostgrestQueryParserOptions): PostgrestFilter<Result>;
-    denormalize<Type extends Record<string, unknown>>(obj: Type): Type;
-    apply(obj: unknown): obj is Result;
-    applyFilters(obj: unknown): obj is Result;
-    hasFiltersOnPaths(paths: string[]): boolean;
-    applyFiltersOnPaths(obj: unknown, paths: string[]): obj is Result;
-    hasPaths(obj: unknown): obj is Result;
-    private hasPathRecursive;
-    private applyFilterFn;
-    private buildFilterFn;
-}
-
-/**
- * Denormalize a normalized response object using the paths of the target query
- * **/
-declare const denormalize: <R extends Record<string, unknown>>(paths: Path[], obj: R) => R;
-
-declare function binarySearch<Type>(arr: Type[], el: Type, compare: (a: Type, b: Type) => number): number;
-
-type AnyPostgrestResponse<Result> = PostgrestSingleResponse<Result> | PostgrestMaybeSingleResponse<Result> | PostgrestResponse<Result>;
-declare const isAnyPostgrestResponse: <Result>(q: unknown) => q is AnyPostgrestResponse<Result>;
-type PostgrestPaginationResponse<Result> = Result[];
-declare const isPostgrestPaginationResponse: <Result>(q: unknown) => q is PostgrestPaginationResponse<Result>;
-type PostgrestHasMorePaginationResponse<Result> = {
-    data: Result[];
-    hasMore: boolean;
-};
-declare const isPostgrestHasMorePaginationResponse: <Result>(q: unknown) => q is PostgrestHasMorePaginationResponse<Result>;
-
-type PostgrestPaginationCacheData<Result> = Result[][];
-declare const isPostgrestPaginationCacheData: <Result>(q: unknown) => q is PostgrestPaginationCacheData<Result>;
-type PostgrestHasMorePaginationCacheData<Result> = PostgrestHasMorePaginationResponse<Result>[];
-declare const isPostgrestHasMorePaginationCacheData: <Result>(q: unknown) => q is PostgrestHasMorePaginationCacheData<Result>;
-
-/**
- * Encodes an object by url-encoding an ordered lists of all paths and their values.
- */
-declare const encodeObject: (obj: Record<string, unknown>) => string;
-
-declare const extractPathsFromFilters: (f: FilterDefinitions, p: Path[]) => Path[];
-
-declare const filterFilterDefinitionsByPaths: (f: FilterDefinitions, paths: string[]) => FilterDefinitions;
-
-declare const findFilters: (f: FilterDefinitions, by: Partial<FilterDefinition>) => FilterDefinition[];
-
-declare const findIndexOrdered: <Type extends Record<string, unknown>>(input: Type, currentData: Type[], orderBy: OrderDefinition[]) => number;
-
-/**
- * Returns the index of the last element in the array where predicate is true, and -1
- * otherwise.
- * @param array The source array to search in
- * @param predicate find calls predicate once for each element of the array, in descending
- * order, until it finds one where predicate returns true. If such an element is found,
- * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
- */
-declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
-
-declare const get: (obj: any, path: string, defaultValue?: any) => any;
-
-declare const getTable: (query: PostgrestBuilder<any, any> | PostgrestQueryBuilder<any, any, any>) => string;
-
-type NestedPath = {
-    alias?: string;
-    path: string;
-    declaration: string;
-    paths: (Path | NestedPath)[];
-};
-declare const isNestedPath: (p: Path | NestedPath) => p is NestedPath;
-declare const groupPathsRecursive: (paths: Path[]) => (Path | NestedPath)[];
-
-declare const ifDateGetTime: (v: unknown) => unknown;
-
-/**
- * Check if a value is a valid ISO DateTime string
- * @param v
- * @returns
- */
-declare const isISODateString: (v: unknown) => boolean;
-
-/**
- *
- * @param i Ahhh gotta love typescript
- * @returns
- */
-declare const isNotNull: <I>(i: I | null) => i is I;
-
-declare const isObject: (v: unknown) => v is Record<string, unknown>;
-
-declare const isPostgrestBuilder: <Result>(q: unknown) => q is PostgrestBuilder<any, Result>;
-
-/**
- * An object containing all PostgrestFilterOperator implementations
- */
-declare const OPERATOR_MAP: {
-    [Key in PostgrestFilterOperator]?: OperatorFn;
-};
-
-/**
- * Parses orderByKey back to OrderDefinition
- * @param key generated by PostgrestParser
- * @returns The parsed OrderDefinition
- */
-declare const parseOrderByKey: (v: string) => OrderDefinition[];
-
-declare const parseSelectParam: (s: string, currentPath?: Path) => Path[];
-
-/**
- * Safely parse any value to a ValueType
- * @param v Any value
- * @returns a ValueType
- */
-declare const parseValue: (v: any) => ValueType;
-
-declare const removeAliasFromDeclaration: (d: string) => string;
-
-declare const removeFirstPathElement: (p: Path) => Path;
-
-declare const setFilterValue: (searchParams: URLSearchParams, path: string, op: string, value: string) => void;
-
-declare const sortSearchParams: (params: URLSearchParams) => URLSearchParams;
-
-declare const buildSortedComparator: <Type extends Record<string, unknown>>(orderBy: OrderDefinition[]) => (a: Type, b: Type) => 0 | 1 | -1;
-
-export { type AnyPostgrestResponse, type FilterDefinition, type FilterDefinitions, type FilterFn, type NestedPath, OPERATOR_MAP, type OperatorFn, type OrderDefinition, type Path, PostgrestFilter, type PostgrestFilterOperator, type PostgrestHasMorePaginationCacheData, type PostgrestHasMorePaginationResponse, type PostgrestPaginationCacheData, type PostgrestPaginationResponse, PostgrestParser, PostgrestQueryParser, type PostgrestQueryParserOptions, SUPPORTED_OPERATORS, type 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 };

package/dist/powersync-bridge/index.d.ts

@@ -1,284 +0,0 @@
-import { SyncStatus, SyncControl } from '../core/index.js';
-export { P as PowerSyncDatabase } from '../executor-CB4KHyYG.js';
-
-/**
- * PowerSync Bridge for @pol-studios/db
- *
- * This module provides integration utilities between @pol-studios/db and
- * @pol-studios/powersync packages. It re-exports key types and provides
- * helper functions for type-safe integration.
- *
- * The @pol-studios/powersync package is an optional peer dependency.
- * This bridge allows the db package to work seamlessly with or without
- * the powersync package installed.
- *
- * @example
- * ```typescript
- * import { isPowerSyncAvailable, usePowerSyncDatabase } from '@pol-studios/db/powersync-bridge';
- *
- * if (isPowerSyncAvailable()) {
- *   // Use PowerSync features
- * }
- * ```
- */
-/**
- * Re-export core types from @pol-studios/powersync for convenience.
- * These types are defined here to avoid runtime dependency on the package.
- */
-/**
- * Abstract interface for PowerSync database operations.
- * This matches the interface from @pol-studios/powersync/core.
- */
-interface AbstractPowerSyncDatabase {
-    /** Execute a query and return all results */
-    getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    /** Execute a query and return first result or null */
-    get<T>(sql: string, params?: unknown[]): Promise<T | null>;
-    /** Execute a SQL statement (INSERT, UPDATE, DELETE) */
-    execute(sql: string, params?: unknown[]): Promise<{
-        rowsAffected: number;
-    }>;
-    /** Whether the database is currently connected */
-    connected: boolean;
-    /** Current sync status */
-    currentStatus: {
-        connected: boolean;
-        connecting: boolean;
-        hasSynced: boolean;
-        lastSyncedAt: Date | null;
-        dataFlowStatus?: {
-            uploading: boolean;
-            downloading: boolean;
-        };
-        downloadProgress?: {
-            downloadedFraction: number;
-            downloadedOperations: number;
-            totalOperations: number;
-        };
-    };
-    /** Initialize the database */
-    init(): Promise<void>;
-    /** Close the database connection */
-    close(): Promise<void>;
-    /** Connect to the PowerSync service */
-    connect(connector: unknown): Promise<void>;
-    /** Disconnect from the PowerSync service */
-    disconnect(): Promise<void>;
-    /** Register a listener for status changes */
-    registerListener(listener: {
-        statusChanged?: (status: unknown) => void;
-    }): () => void;
-    /** Get the next pending CRUD transaction */
-    getNextCrudTransaction(): Promise<unknown>;
-}
-/**
- * Sync status from @pol-studios/powersync.
- */
-interface PowerSyncSyncStatus {
-    /** Whether connected to the PowerSync service */
-    connected: boolean;
-    /** Whether currently attempting to connect */
-    connecting: boolean;
-    /** Whether initial sync has completed */
-    hasSynced: boolean;
-    /** Timestamp of last successful sync */
-    lastSyncedAt: Date | null;
-    /** Whether currently uploading local changes */
-    uploading: boolean;
-    /** Whether currently downloading remote changes */
-    downloading: boolean;
-    /** Download progress details */
-    downloadProgress: {
-        current: number;
-        target: number;
-        percentage: number;
-    } | null;
-}
-/**
- * Connection health status from @pol-studios/powersync.
- */
-interface PowerSyncConnectionHealth {
-    /** Current connection status */
-    status: "healthy" | "degraded" | "disconnected";
-    /** Last measured query latency in milliseconds */
-    latency: number | null;
-    /** Timestamp of the last health check */
-    lastHealthCheck: Date | null;
-    /** Number of consecutive health check failures */
-    consecutiveFailures: number;
-    /** Total reconnection attempts since last successful connection */
-    reconnectAttempts: number;
-}
-/**
- * Sync metrics from @pol-studios/powersync.
- */
-interface PowerSyncMetrics {
-    /** Total number of sync operations attempted */
-    totalSyncs: number;
-    /** Number of successful sync operations */
-    successfulSyncs: number;
-    /** Number of failed sync operations */
-    failedSyncs: number;
-    /** Duration of the last sync in milliseconds */
-    lastSyncDuration: number | null;
-    /** Average sync duration in milliseconds */
-    averageSyncDuration: number | null;
-    /** Total bytes downloaded across all syncs */
-    totalDataDownloaded: number;
-    /** Total bytes uploaded across all syncs */
-    totalDataUploaded: number;
-    /** Last sync error details */
-    lastError: {
-        type: string;
-        message: string;
-        timestamp: Date;
-    } | null;
-}
-/**
- * Sync control actions from @pol-studios/powersync.
- */
-interface PowerSyncControlActions {
-    /** Trigger a sync operation */
-    triggerSync: () => Promise<void>;
-    /** Pause sync operations */
-    pause: () => Promise<void>;
-    /** Resume sync operations */
-    resume: () => Promise<void>;
-    /** Disconnect from the PowerSync service */
-    disconnect: () => Promise<void>;
-    /** Set the sync scope for selective sync */
-    setScope: (scope: {
-        type: string;
-        ids: string[];
-    } | null) => void;
-}
-/**
- * Check if @pol-studios/powersync is available.
- *
- * This function performs a lazy check to see if the powersync package
- * is installed and can be imported. The result is cached for subsequent calls.
- *
- * @returns true if @pol-studios/powersync is available, false otherwise
- *
- * @example
- * ```typescript
- * import { isPowerSyncAvailable } from '@pol-studios/db/powersync-bridge';
- *
- * if (isPowerSyncAvailable()) {
- *   // Safe to use PowerSync features
- *   const { usePowerSync } = await import('@pol-studios/powersync');
- * }
- * ```
- */
-declare function isPowerSyncAvailable(): boolean;
-/**
- * Reset the availability check cache.
- * Useful for testing or when package installation state might change.
- */
-declare function resetPowerSyncAvailabilityCache(): void;
-/**
- * Type guard to check if a value is an AbstractPowerSyncDatabase.
- *
- * @param value - The value to check
- * @returns true if value implements AbstractPowerSyncDatabase interface
- */
-declare function isAbstractPowerSyncDatabase(value: unknown): value is AbstractPowerSyncDatabase;
-/**
- * Type guard to check if a value is a PowerSyncSyncStatus.
- *
- * @param value - The value to check
- * @returns true if value matches PowerSyncSyncStatus interface
- */
-declare function isPowerSyncSyncStatus(value: unknown): value is PowerSyncSyncStatus;
-/**
- * Convert PowerSync sync status to the V3 DataLayer SyncStatus format.
- *
- * This utility helps bridge the sync status from @pol-studios/powersync
- * to the format expected by @pol-studios/db's DataLayerProvider.
- *
- * @param powerSyncStatus - The sync status from @pol-studios/powersync
- * @param pendingCount - Number of pending uploads (from pendingMutations)
- * @returns SyncStatus in @pol-studios/db format
- */
-declare function convertToDataLayerSyncStatus(powerSyncStatus: PowerSyncSyncStatus, pendingCount?: number): SyncStatus;
-/**
- * Convert PowerSync sync control to the V3 DataLayer SyncControl format.
- *
- * @param powerSyncControl - The sync control actions from @pol-studios/powersync
- * @returns SyncControl in @pol-studios/db format
- */
-declare function convertToDataLayerSyncControl(powerSyncControl: PowerSyncControlActions): SyncControl;
-/**
- * Create a database instance getter that works with PowerSync context.
- *
- * This is useful for integrating PowerSyncProvider with DataLayerProvider
- * by providing a way to get the database instance from the PowerSync context.
- *
- * @param getPowerSyncDb - Function to get the PowerSync database from context
- * @returns A function that returns the database or null
- */
-declare function createDatabaseGetter(getPowerSyncDb: () => AbstractPowerSyncDatabase | null): () => AbstractPowerSyncDatabase | null;
-/**
- * Options for setting up DataLayerProvider with PowerSync integration.
- */
-interface PowerSyncIntegrationOptions {
-    /**
-     * The PowerSync database instance from PowerSyncProvider.
-     */
-    database: AbstractPowerSyncDatabase | null;
-    /**
-     * Whether the PowerSync database is ready.
-     */
-    isReady: boolean;
-    /**
-     * Current sync status from PowerSyncProvider.
-     */
-    syncStatus?: PowerSyncSyncStatus;
-    /**
-     * Sync control actions from PowerSyncProvider.
-     */
-    syncControl?: PowerSyncControlActions;
-    /**
-     * Number of pending mutations.
-     */
-    pendingCount?: number;
-}
-/**
- * Get the powerSyncInstance prop for DataLayerProvider from PowerSync context values.
- *
- * This helper extracts the necessary values from @pol-studios/powersync hooks
- * and returns them in a format suitable for DataLayerProvider.
- *
- * @param options - The PowerSync integration options
- * @returns The powerSyncInstance to pass to DataLayerProvider, or null if not ready
- *
- * @example
- * ```typescript
- * // Inside a component wrapped with PowerSyncProvider
- * const { db, isReady } = usePowerSync();
- * const { status, pendingCount } = useSyncStatus();
- * const syncControl = useSyncControl();
- *
- * const powerSyncInstance = getPowerSyncInstance({
- *   database: db,
- *   isReady,
- *   syncStatus: status,
- *   syncControl,
- *   pendingCount,
- * });
- *
- * return (
- *   <DataLayerProvider
- *     config={config}
- *     powerSyncInstance={powerSyncInstance}
- *     supabaseClient={supabase}
- *     queryClient={queryClient}
- *   >
- *     {children}
- *   </DataLayerProvider>
- * );
- * ```
- */
-declare function getPowerSyncInstance(options: PowerSyncIntegrationOptions): AbstractPowerSyncDatabase | null;
-
-export { type AbstractPowerSyncDatabase, type PowerSyncConnectionHealth, type PowerSyncControlActions, type PowerSyncIntegrationOptions, type PowerSyncMetrics, type PowerSyncSyncStatus, convertToDataLayerSyncControl, convertToDataLayerSyncStatus, createDatabaseGetter, getPowerSyncInstance, isAbstractPowerSyncDatabase, isPowerSyncAvailable, isPowerSyncSyncStatus, resetPowerSyncAvailabilityCache };