@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/sync-plugins/tanstack-query.d.ts

@@ -1,11 +1,14 @@
 import { SyncedOptions } from '@legendapp/state/sync';
-import { DefaultError, MutationObserverOptions, QueryClient, QueryKey, QueryObserverOptions } from '@tanstack/query-core';
-export interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
+import { QueryKey, QueryObserverOptions, QueryClient, MutationObserverOptions, DefaultError } from '@tanstack/query-core';
+
+interface ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends Omit<QueryObserverOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'> {
     queryKey?: TQueryKey | (() => TQueryKey);
 }
-export interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends SyncedOptions<TData> {
+interface SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey extends QueryKey> extends SyncedOptions<TData> {
     queryClient: QueryClient;
     query: ObservableQueryOptions<TQueryFnData, TError, TData, TQueryKey>;
     mutation?: MutationObserverOptions<TData, TError, void>;
 }
-export declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): NonNullable<TData>;
+declare function syncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): NonNullable<TData>;
+
+export { type ObservableQueryOptions, type SyncedQueryParams, syncedQuery };

package/sync-plugins/tanstack-query.js

@@ -4,68 +4,62 @@ var state = require('@legendapp/state');
 var sync = require('@legendapp/state/sync');
 var queryCore = require('@tanstack/query-core');
 
+// src/sync-plugins/tanstack-query.ts
 function syncedQuery(params) {
-    const { query: options, mutation: mutationOptions, queryClient } = params;
-    const Observer = queryCore.QueryObserver;
-    const defaultedOptions = queryClient.defaultQueryOptions(options);
-    let observer = undefined;
-    let latestOptions = defaultedOptions;
-    let queryKeyFromFn;
-    const origQueryKey = options.queryKey;
-    // If the queryKey is a function, observe it and extract the raw value
-    const isKeyFunction = state.isFunction(origQueryKey);
-    const updateQueryOptions = (obj) => {
-        // Since legend-state mutates the query options, we need to clone it to make Query
-        // see it as changed
-        const options = Object.assign({}, obj);
-        // Use the latest value from the observed queryKey function
-        if (isKeyFunction) {
-            options.queryKey = queryKeyFromFn;
-        }
-        latestOptions = options;
-        // Update the Query options
-        if (observer) {
-            observer.setOptions(options, { listeners: false });
-        }
-    };
+  const { query: options, mutation: mutationOptions, queryClient } = params;
+  const Observer = queryCore.QueryObserver;
+  const defaultedOptions = queryClient.defaultQueryOptions(
+    options
+  );
+  let observer = void 0;
+  let latestOptions = defaultedOptions;
+  let queryKeyFromFn;
+  const origQueryKey = options.queryKey;
+  const isKeyFunction = state.isFunction(origQueryKey);
+  const updateQueryOptions = (obj) => {
+    const options2 = Object.assign({}, obj);
     if (isKeyFunction) {
-        state.observe(() => {
-            queryKeyFromFn = origQueryKey();
-            updateQueryOptions(latestOptions);
-        });
+      options2.queryKey = queryKeyFromFn;
     }
-    // Create the observer
-    observer = new Observer(queryClient, latestOptions);
-    const get = () => {
-        // Get the initial optimistic results if it's already cached
-        const result = observer.getOptimisticResult(latestOptions);
-        return result.data;
-    };
-    const subscribe = ({ update }) => {
-        // Subscribe to Query's observer and update the observable
-        const unsubscribe = observer.subscribe(queryCore.notifyManager.batchCalls((result) => {
-            if (result.status === 'success') {
-                update({ value: result.data });
-            }
-        }));
-        // Update result to make sure we did not miss any query updates
-        // between creating the observer and subscribing to it.
-        observer.updateResult();
-        return unsubscribe;
-    };
-    let set = undefined;
-    if (mutationOptions) {
-        const mutator = new queryCore.MutationObserver(queryClient, mutationOptions);
-        set = ({ value }) => {
-            return mutator.mutate(value);
-        };
+    latestOptions = options2;
+    if (observer) {
+      observer.setOptions(options2, { listeners: false });
     }
-    return sync.synced({
-        get,
-        set,
-        subscribe,
+  };
+  if (isKeyFunction) {
+    state.observe(() => {
+      queryKeyFromFn = origQueryKey();
+      updateQueryOptions(latestOptions);
     });
+  }
+  observer = new Observer(queryClient, latestOptions);
+  const get = () => {
+    const result = observer.getOptimisticResult(latestOptions);
+    return result.data;
+  };
+  const subscribe = ({ update }) => {
+    const unsubscribe = observer.subscribe(
+      queryCore.notifyManager.batchCalls((result) => {
+        if (result.status === "success") {
+          update({ value: result.data });
+        }
+      })
+    );
+    observer.updateResult();
+    return unsubscribe;
+  };
+  let set = void 0;
+  if (mutationOptions) {
+    const mutator = new queryCore.MutationObserver(queryClient, mutationOptions);
+    set = ({ value }) => {
+      return mutator.mutate(value);
+    };
+  }
+  return sync.synced({
+    get,
+    set,
+    subscribe
+  });
 }
 
 exports.syncedQuery = syncedQuery;
-//# sourceMappingURL=tanstack-query.js.map

package/sync-plugins/tanstack-query.mjs

@@ -2,68 +2,62 @@ import { isFunction, observe } from '@legendapp/state';
 import { synced } from '@legendapp/state/sync';
 import { MutationObserver, QueryObserver, notifyManager } from '@tanstack/query-core';
 
+// src/sync-plugins/tanstack-query.ts
 function syncedQuery(params) {
-    const { query: options, mutation: mutationOptions, queryClient } = params;
-    const Observer = QueryObserver;
-    const defaultedOptions = queryClient.defaultQueryOptions(options);
-    let observer = undefined;
-    let latestOptions = defaultedOptions;
-    let queryKeyFromFn;
-    const origQueryKey = options.queryKey;
-    // If the queryKey is a function, observe it and extract the raw value
-    const isKeyFunction = isFunction(origQueryKey);
-    const updateQueryOptions = (obj) => {
-        // Since legend-state mutates the query options, we need to clone it to make Query
-        // see it as changed
-        const options = Object.assign({}, obj);
-        // Use the latest value from the observed queryKey function
-        if (isKeyFunction) {
-            options.queryKey = queryKeyFromFn;
-        }
-        latestOptions = options;
-        // Update the Query options
-        if (observer) {
-            observer.setOptions(options, { listeners: false });
-        }
-    };
+  const { query: options, mutation: mutationOptions, queryClient } = params;
+  const Observer = QueryObserver;
+  const defaultedOptions = queryClient.defaultQueryOptions(
+    options
+  );
+  let observer = void 0;
+  let latestOptions = defaultedOptions;
+  let queryKeyFromFn;
+  const origQueryKey = options.queryKey;
+  const isKeyFunction = isFunction(origQueryKey);
+  const updateQueryOptions = (obj) => {
+    const options2 = Object.assign({}, obj);
     if (isKeyFunction) {
-        observe(() => {
-            queryKeyFromFn = origQueryKey();
-            updateQueryOptions(latestOptions);
-        });
+      options2.queryKey = queryKeyFromFn;
     }
-    // Create the observer
-    observer = new Observer(queryClient, latestOptions);
-    const get = () => {
-        // Get the initial optimistic results if it's already cached
-        const result = observer.getOptimisticResult(latestOptions);
-        return result.data;
-    };
-    const subscribe = ({ update }) => {
-        // Subscribe to Query's observer and update the observable
-        const unsubscribe = observer.subscribe(notifyManager.batchCalls((result) => {
-            if (result.status === 'success') {
-                update({ value: result.data });
-            }
-        }));
-        // Update result to make sure we did not miss any query updates
-        // between creating the observer and subscribing to it.
-        observer.updateResult();
-        return unsubscribe;
-    };
-    let set = undefined;
-    if (mutationOptions) {
-        const mutator = new MutationObserver(queryClient, mutationOptions);
-        set = ({ value }) => {
-            return mutator.mutate(value);
-        };
+    latestOptions = options2;
+    if (observer) {
+      observer.setOptions(options2, { listeners: false });
     }
-    return synced({
-        get,
-        set,
-        subscribe,
+  };
+  if (isKeyFunction) {
+    observe(() => {
+      queryKeyFromFn = origQueryKey();
+      updateQueryOptions(latestOptions);
     });
+  }
+  observer = new Observer(queryClient, latestOptions);
+  const get = () => {
+    const result = observer.getOptimisticResult(latestOptions);
+    return result.data;
+  };
+  const subscribe = ({ update }) => {
+    const unsubscribe = observer.subscribe(
+      notifyManager.batchCalls((result) => {
+        if (result.status === "success") {
+          update({ value: result.data });
+        }
+      })
+    );
+    observer.updateResult();
+    return unsubscribe;
+  };
+  let set = void 0;
+  if (mutationOptions) {
+    const mutator = new MutationObserver(queryClient, mutationOptions);
+    set = ({ value }) => {
+      return mutator.mutate(value);
+    };
+  }
+  return synced({
+    get,
+    set,
+    subscribe
+  });
 }
 
 export { syncedQuery };
-//# sourceMappingURL=tanstack-query.mjs.map

package/sync-plugins/tanstack-react-query.d.mts

@@ -0,0 +1,8 @@
+import { SyncedQueryParams } from '@legendapp/state/sync-plugins/tanstack-query';
+import { DefaultError, QueryKey } from '@tanstack/query-core';
+import { Observable } from '@legendapp/state';
+import { Synced } from '@legendapp/state/sync';
+
+declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Observable<NonNullable<Synced<TData>>>;
+
+export { useObservableSyncedQuery };

package/sync-plugins/tanstack-react-query.d.ts

@@ -1,3 +1,8 @@
 import { SyncedQueryParams } from '@legendapp/state/sync-plugins/tanstack-query';
 import { DefaultError, QueryKey } from '@tanstack/query-core';
-export declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): import("@legendapp/state").Observable<NonNullable<TData>>;
+import { Observable } from '@legendapp/state';
+import { Synced } from '@legendapp/state/sync';
+
+declare function useObservableSyncedQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(params: SyncedQueryParams<TQueryFnData, TError, TData, TQueryKey>): Observable<NonNullable<Synced<TData>>>;
+
+export { useObservableSyncedQuery };

package/sync-plugins/tanstack-react-query.js

@@ -3,9 +3,9 @@
 var react = require('@legendapp/state/react');
 var tanstackQuery = require('@legendapp/state/sync-plugins/tanstack-query');
 
+// src/sync-plugins/tanstack-react-query.ts
 function useObservableSyncedQuery(params) {
-    return react.useObservable(tanstackQuery.syncedQuery(params));
+  return react.useObservable(tanstackQuery.syncedQuery(params));
 }
 
 exports.useObservableSyncedQuery = useObservableSyncedQuery;
-//# sourceMappingURL=tanstack-react-query.js.map

package/sync-plugins/tanstack-react-query.mjs

@@ -1,9 +1,9 @@
 import { useObservable } from '@legendapp/state/react';
 import { syncedQuery } from '@legendapp/state/sync-plugins/tanstack-query';
 
+// src/sync-plugins/tanstack-react-query.ts
 function useObservableSyncedQuery(params) {
-    return useObservable(syncedQuery(params));
+  return useObservable(syncedQuery(params));
 }
 
 export { useObservableSyncedQuery };
-//# sourceMappingURL=tanstack-react-query.mjs.map

package/sync.d.mts

@@ -0,0 +1,351 @@
+import { MMKVConfiguration } from 'react-native-mmkv';
+import { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
+import { ClassConstructor, GetMode, SetParams, NodeValue, UpdateFn, ObservableParam, LinkedOptions, RetryOptions, Change, Observable, ObservableSyncState, UpdateFnParams, Selector, TypeAtPath, ObservableState, RecordValue, ArrayValue } from '@legendapp/state';
+import { SyncedOptionsGlobal as SyncedOptionsGlobal$1 } from '@legendapp/state/sync';
+import { DatabaseReference, Query } from 'firebase/database';
+
+interface PersistOptions<T = any> {
+    name: string;
+    plugin?: ClassConstructor<ObservablePersistPlugin, T[]>;
+    retrySync?: boolean;
+    transform?: SyncTransform<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+interface SyncedGetParams {
+    value: any;
+    lastSync: number | undefined;
+    updateLastSync: (lastSync: number) => void;
+    mode: GetMode;
+    refresh: () => void;
+}
+interface SyncedSetParams<T> extends SetParams<T> {
+    node: NodeValue;
+    valuePrevious: T;
+    update: UpdateFn;
+    refresh: () => void;
+    cancelRetry: () => void;
+    retryNum: number;
+    fromSubscribe: boolean | undefined;
+}
+interface SyncedSubscribeParams<T = any> {
+    node: NodeValue;
+    value$: ObservableParam<T>;
+    update: UpdateFn;
+    refresh: () => void;
+}
+interface SyncedOptions<TRemote = any, TLocal = TRemote> extends Omit<LinkedOptions<TRemote>, 'get' | 'set'> {
+    get?: (params: SyncedGetParams) => Promise<TRemote> | TRemote;
+    set?: (params: SyncedSetParams<TRemote>) => void | Promise<any>;
+    subscribe?: (params: SyncedSubscribeParams<TRemote>) => (() => void) | void;
+    retry?: RetryOptions;
+    persist?: PersistOptions<any>;
+    debounceSet?: number;
+    syncMode?: 'auto' | 'manual';
+    mode?: GetMode;
+    transform?: SyncTransform<TLocal, TRemote>;
+    enableSync?: boolean;
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (message?: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onAfterSet?: () => void;
+    allowSetIfGetError?: boolean;
+}
+interface SyncedOptionsGlobal<T = any> extends Omit<SyncedOptions<T>, 'get' | 'set' | 'persist' | 'initial' | 'waitForSet' | 'waitFor' | 'transform' | 'subscribe'> {
+    persist?: ObservablePersistPluginOptions & Omit<PersistOptions, 'name' | 'transform' | 'options'>;
+}
+interface ObservablePersistPluginOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+interface ObservablePersistPlugin {
+    initialize?(config: ObservablePersistPluginOptions): void | Promise<void>;
+    loadTable?(table: string, config: PersistOptions): Promise<any> | void;
+    getTable<T = any>(table: string, init: object, config: PersistOptions): T;
+    set(table: string, changes: Change[], config: PersistOptions): Promise<any> | void;
+    deleteTable(table: string, config: PersistOptions): Promise<any> | void;
+    getMetadata(table: string, config: PersistOptions): PersistMetadata;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions): Promise<any> | void;
+    deleteMetadata(table: string, config: PersistOptions): Promise<any> | void;
+}
+interface PersistMetadata {
+    id?: '__legend_metadata';
+    lastSync?: number;
+    pending?: any;
+}
+type SyncTransformMethod = 'get' | 'set';
+interface SyncTransform<TLocal = any, TSaved = TLocal> {
+    load?: (value: TSaved, method: SyncTransformMethod) => TLocal | Promise<TLocal>;
+    save?: (value: TLocal) => TSaved | Promise<TSaved>;
+}
+interface ObservableSyncSetParams<T> {
+    syncState: Observable<ObservableSyncState>;
+    value$: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    changes: Change[];
+    value: T;
+    valuePrevious: T;
+}
+interface ObservableSyncGetParams<T> {
+    state: Observable<ObservableSyncState>;
+    value$: ObservableParam<T>;
+    options: SyncedOptions<T>;
+    dateModified?: number;
+    lastSync?: number;
+    mode?: GetMode;
+    onGet: () => void;
+    onError: (error: Error) => void;
+    onChange: (params: UpdateFnParams) => void | Promise<void>;
+}
+type ObservableSyncRemoteGetFnParams<T> = Omit<ObservableSyncGetParams<T>, 'onGet'>;
+interface ObservableSyncClass {
+    get?<T>(params: ObservableSyncGetParams<T>): void;
+    set?<T>(params: ObservableSyncSetParams<T>): void | Promise<void | {
+        changes?: object;
+        dateModified?: number;
+        lastSync?: number;
+        pathStrs?: string[];
+    }>;
+}
+interface ObservableSyncFunctions<T = any> {
+    get?(params: ObservableSyncRemoteGetFnParams<T>): T | Promise<T>;
+    set?(params: ObservableSyncSetParams<T>): void | Promise<void | {
+        changes?: object | undefined;
+        dateModified?: number;
+        lastSync?: number;
+    }>;
+}
+interface SubscribeOptions {
+    node: NodeValue;
+    update: UpdateFn;
+    refresh: () => void;
+}
+type Synced<T> = T;
+
+declare function configureObservableSync(options?: SyncedOptionsGlobal$1): void;
+
+interface PersistTransform<TOrig = any, TSaved = TOrig> {
+    load?: (value: TSaved) => TOrig | Promise<TOrig>;
+    save?: (value: TOrig) => TSaved | Promise<TSaved>;
+}
+interface LegacyPersistOptionsLocal<T = any> {
+    name: string;
+    transform?: PersistTransform<T>;
+    fieldTransforms?: FieldTransforms<T>;
+    readonly?: boolean;
+    mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
+    options?: any;
+}
+type LegacyPersistOptionsRemote<T = any> = ObservablePersistenceConfigRemoteGlobalOptions & {
+    readonly?: boolean;
+    waitForGet?: Selector<any>;
+    waitForSet?: LinkedOptions['waitForSet'];
+    manual?: boolean;
+    fieldTransforms?: FieldTransforms<T>;
+    allowSetIfError?: boolean;
+    transform?: PersistTransform<T>;
+    firebase?: {
+        refPath: (uid: string | undefined) => string;
+        query?: (ref: DatabaseReference) => DatabaseReference | Query;
+        queryByModified?: QueryByModified<T>;
+        ignoreKeys?: string[];
+        requireAuth?: boolean;
+        mode?: 'once' | 'realtime';
+    };
+    offlineBehavior?: false | 'retry';
+    changeTimeout?: number;
+    metadataTimeout?: number;
+    retry?: RetryOptions;
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (message?: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onSet?: () => void;
+};
+interface ObservablePersistenceConfigLocalGlobalOptions {
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    indexedDB?: {
+        databaseName: string;
+        version: number;
+        tableNames: string[];
+    };
+    asyncStorage?: {
+        AsyncStorage: AsyncStorageStatic;
+        preload?: boolean | string[];
+    };
+}
+interface ObservablePersistenceConfigRemoteGlobalOptions {
+    debounceSet?: number;
+    dateModifiedKey?: string;
+    offlineBehavior?: false | 'retry';
+    retry?: RetryOptions;
+    onGetError?: (error: Error) => void;
+    onSetError?: (error: Error) => void;
+    log?: (logLevel: 'verbose' | 'warning' | 'error', message: any, ...optionalParams: any[]) => void;
+    onBeforeSet?: () => void;
+    onAfterSet?: () => void;
+}
+interface ObservablePersistenceConfig {
+    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions;
+    localOptions?: ObservablePersistenceConfigLocalGlobalOptions;
+    remoteOptions?: ObservablePersistenceConfigRemoteGlobalOptions;
+}
+interface LegacyPersistOptions<T = any> {
+    local?: string | LegacyPersistOptionsLocal<T>;
+    remote?: LegacyPersistOptionsRemote<T>;
+    pluginLocal?: ClassConstructor<ObservablePersistPlugin>;
+    pluginRemote?: ClassConstructor<ObservablePersistRemoteClass> | ObservablePersistRemoteFunctions<T>;
+}
+interface ObservableOnChangeParams {
+    value: unknown;
+    path?: string[];
+    pathTypes?: TypeAtPath[];
+    mode?: GetMode;
+    dateModified?: number | undefined;
+    lastSync?: number | undefined;
+}
+interface ObservablePersistRemoteSetParams<T> {
+    syncState: Observable<ObservablePersistState>;
+    obs: ObservableParam<T>;
+    options: LegacyPersistOptions<T>;
+    changes: Change[];
+    value: T;
+}
+interface ObservablePersistRemoteGetParams<T> {
+    state: Observable<ObservablePersistState>;
+    obs: ObservableParam<T>;
+    options: LegacyPersistOptions<T>;
+    dateModified?: number;
+    lastSync?: number;
+    mode?: GetMode;
+    onGet: () => void;
+    onError: (error: Error) => void;
+    onChange: (params: ObservableOnChangeParams) => void | Promise<void>;
+}
+type ObservablePersistRemoteGetFnParams<T> = Omit<ObservablePersistRemoteGetParams<T>, 'onGet'>;
+interface ObservablePersistRemoteClass {
+    get?<T>(params: ObservablePersistRemoteGetParams<T>): void;
+    set?<T>(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
+        changes?: object;
+        dateModified?: number;
+        lastSync?: number;
+        pathStrs?: string[];
+    }>;
+}
+interface ObservablePersistRemoteFunctions<T = any> {
+    get?(params: ObservablePersistRemoteGetFnParams<T>): T | Promise<T>;
+    set?(params: ObservablePersistRemoteSetParams<T>): void | Promise<void | {
+        changes?: object | undefined;
+        dateModified?: number;
+        lastSync?: number;
+    }>;
+}
+interface ObservablePersistStateBase {
+    isLoadedLocal: boolean;
+    isEnabledLocal: boolean;
+    isEnabledRemote: boolean;
+    dateModified?: number;
+    lastSync?: number;
+    syncCount?: number;
+    clearLocal: () => Promise<void>;
+    sync: () => Promise<void>;
+    getPendingChanges: () => Record<string, {
+        p: any;
+        v?: any;
+    }> | undefined;
+}
+type ObservablePersistState = ObservableState & ObservablePersistStateBase;
+declare type ObjectKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string ? T[K] extends Record<string, any> ? T[K] extends any[] ? never : K : never : never;
+}[keyof T]>;
+declare type DictKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string ? (T[K] extends Record<string, Record<string, any>> ? K : never) : never;
+}[keyof T]>;
+declare type ArrayKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string | number ? (T[K] extends any[] ? K : never) : never;
+}[keyof T]>;
+declare type FieldTransforms<T> = (T extends Record<string, Record<string, any>> ? {
+    _dict: FieldTransformsInner<RecordValue<T>>;
+} : never) | FieldTransformsInner<T>;
+declare type FieldTransformsInner<T> = {
+    [K in keyof T]: string;
+} & ({
+    [K in keyof ObjectKeys<T> as `${K}_obj`]?: FieldTransforms<T[K]>;
+} | {
+    [K in keyof DictKeys<T> as `${K}_dict`]?: FieldTransforms<RecordValue<T[K]>>;
+}) & {
+    [K in keyof ArrayKeys<T> as `${K}_arr`]?: FieldTransforms<ArrayValue<T[K]>>;
+} & {
+    [K in keyof ArrayKeys<T> as `${K}_val`]?: FieldTransforms<ArrayValue<T[K]>>;
+};
+type QueryByModified<T> = boolean | {
+    [K in keyof T]?: QueryByModified<T[K]>;
+} | {
+    '*'?: boolean;
+};
+
+declare function removeNullUndefined<T extends Record<string, any>>(a: T, recursive?: boolean): T;
+declare function diffObjects<T extends Record<string, any>>(obj1: T, obj2: T, deep?: boolean): Partial<T>;
+declare function deepEqual<T extends Record<string, any> = any>(a: T, b: T, ignoreFields?: string[], nullVsUndefined?: boolean): boolean;
+declare function combineTransforms<T, T2>(...transforms: Partial<SyncTransform<T2, T>>[]): SyncTransform<T2, T>;
+interface TransformStringifyOptions {
+    stringifyIf?: {
+        number?: boolean;
+        object?: boolean;
+        array?: boolean;
+        date?: boolean;
+    };
+    filterArrays?: boolean;
+}
+type TransformStringifyKeys<TRemote, TLocal> = (keyof TRemote | {
+    from: keyof TRemote;
+    to: keyof TLocal;
+})[];
+type StringToDate<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends string ? string | Date : T[K];
+};
+declare function transformStringifyKeys<TRemote extends Record<string, any>, TLocal extends Record<string, any>>(...keys: TransformStringifyKeys<TRemote, TLocal>): SyncTransform<TLocal, TRemote>;
+type TransformStringsToDates<T extends {}, Keys extends keyof T> = {
+    [K in Keys]: Date | Exclude<T[K], string>;
+} & Omit<T, Keys>;
+declare function transformStringifyDates<TRemote extends Record<string, any>, TLocal extends Record<string, any> = TRemote>(): SyncTransform<TLocal, TRemote>;
+declare function transformStringifyDates<TRemote extends Record<string, any>, Keys extends keyof TRemote = keyof TRemote>(...args: Keys[]): SyncTransform<TransformStringsToDates<TRemote, Keys>, TRemote>;
+declare function transformStringifyDates<TRemote extends Record<string, any>, TLocal extends Record<string, any> = TRemote>(...args: (keyof TRemote)[]): SyncTransform<TRemote, TLocal>;
+
+declare const mapSyncPlugins: WeakMap<ClassConstructor<ObservablePersistPlugin | ObservableSyncClass>, {
+    plugin: ObservablePersistPlugin | ObservableSyncClass;
+    initialized: Observable<boolean>;
+}>;
+declare function onChangeRemote(cb: () => void): void;
+declare function syncObservable<T>(obs$: ObservableParam<T>, syncOptions: SyncedOptions<T>): Observable<ObservableSyncState>;
+declare function syncObservable<T>(obs$: ObservableParam<T>, syncOptions: Synced<T>): Observable<ObservableSyncState>;
+
+declare function synced<TRemote, TLocal = TRemote>(params: SyncedOptions<TRemote, TLocal> | (() => TRemote)): Synced<TLocal>;
+
+declare function isInRemoteChange(): boolean;
+declare const internal: {
+    observableSyncConfiguration: SyncedOptionsGlobal;
+};
+
+export { type FieldTransforms, type FieldTransformsInner, type LegacyPersistOptions, type LegacyPersistOptionsLocal, type LegacyPersistOptionsRemote, type ObservableOnChangeParams, type ObservablePersistPlugin, type ObservablePersistPluginOptions, type ObservablePersistRemoteClass, type ObservablePersistRemoteFunctions, type ObservablePersistRemoteGetFnParams, type ObservablePersistRemoteGetParams, type ObservablePersistRemoteSetParams, type ObservablePersistState, type ObservablePersistStateBase, type ObservablePersistenceConfig, type ObservablePersistenceConfigLocalGlobalOptions, type ObservablePersistenceConfigRemoteGlobalOptions, type ObservableSyncClass, type ObservableSyncFunctions, type ObservableSyncGetParams, type ObservableSyncRemoteGetFnParams, type ObservableSyncSetParams, type PersistMetadata, type PersistOptions, type PersistTransform, type QueryByModified, type StringToDate, type SubscribeOptions, type SyncTransform, type SyncTransformMethod, type Synced, type SyncedGetParams, type SyncedOptions, type SyncedOptionsGlobal, type SyncedSetParams, type SyncedSubscribeParams, type TransformStringifyKeys, type TransformStringifyOptions, type TransformStringsToDates, combineTransforms, configureObservableSync, deepEqual, diffObjects, internal, isInRemoteChange, mapSyncPlugins, onChangeRemote, removeNullUndefined, syncObservable, synced, transformStringifyDates, transformStringifyKeys };