@aws-amplify/datastore 3.12.6-next.20 → 3.12.6-next.32

package/index.js

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === 'production') {
-	module.exports = require('./dist/aws-amplify-datastore.min.js');
-} else {
-	module.exports = require('./dist/aws-amplify-datastore.js');
-}

package/lib/authModeStrategies/defaultAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy } from '../types';
-export declare const defaultAuthStrategy: AuthModeStrategy;

package/lib/authModeStrategies/index.d.ts

@@ -1,2 +0,0 @@
-export { defaultAuthStrategy } from './defaultAuthStrategy';
-export { multiAuthStrategy } from './multiAuthStrategy';

package/lib/authModeStrategies/multiAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy, AmplifyContext } from '../types';
-export declare const multiAuthStrategy: (amplifyContext: AmplifyContext) => AuthModeStrategy;

package/lib/datastore/datastore.d.ts

@@ -1,66 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { PredicateAll } from '../predicates';
-import { ConflictHandler, DataStoreConfig, ModelInit, ModelInstanceMetadata, NonModelTypeConstructor, ProducerPaginationInput, PersistentModel, PersistentModelConstructor, ProducerModelPredicate, Schema, SubscriptionMessage, DataStoreSnapshot, TypeConstructorMap, ErrorHandler, ObserveQueryOptions } from '../types';
-export declare let syncClasses: TypeConstructorMap;
-declare const initSchema: (userSchema: Schema) => Record<string, NonModelTypeConstructor<any> | PersistentModelConstructor<any, {
-    readOnlyFields: "createdAt" | "updatedAt";
-}>>;
-export declare type ModelInstanceCreator = typeof modelInstanceCreator;
-declare function modelInstanceCreator<T extends PersistentModel = PersistentModel>(modelConstructor: PersistentModelConstructor<T>, init: ModelInit<T> & Partial<ModelInstanceMetadata>): T;
-declare class DataStore {
-    private Auth;
-    private API;
-    private Cache;
-    private amplifyConfig;
-    private authModeStrategy;
-    private conflictHandler;
-    private errorHandler;
-    private fullSyncInterval;
-    private initialized;
-    private initReject;
-    private initResolve;
-    private maxRecordsToSync;
-    private storage;
-    private sync;
-    private syncPageSize;
-    private syncExpressions;
-    private syncPredicates;
-    private sessionId;
-    private storageAdapter;
-    private amplifyContext;
-    getModuleName(): string;
-    start: () => Promise<void>;
-    query: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, id: string): Promise<T | undefined>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ProducerModelPredicate<T> | typeof PredicateAll, paginationProducer?: ProducerPaginationInput<T>): Promise<T[]>;
-    };
-    save: <T extends Readonly<{
-        id: string;
-    } & Record<string, any>>>(model: T, condition?: ProducerModelPredicate<T>) => Promise<T>;
-    setConflictHandler: (config: DataStoreConfig) => ConflictHandler;
-    setErrorHandler: (config: DataStoreConfig) => ErrorHandler;
-    delete: {
-        <T extends PersistentModel>(model: T, condition?: ProducerModelPredicate<T>): Promise<T>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, id: string): Promise<T[]>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition: ProducerModelPredicate<T> | typeof PredicateAll): Promise<T[]>;
-    };
-    observe: {
-        (): Observable<SubscriptionMessage<PersistentModel>>;
-        <T extends PersistentModel>(model: T): Observable<SubscriptionMessage<T>>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: string | ProducerModelPredicate<T>): Observable<SubscriptionMessage<T>>;
-    };
-    observeQuery: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ProducerModelPredicate<T> | typeof PredicateAll, paginationProducer?: ObserveQueryOptions<T>): Observable<DataStoreSnapshot<T>>;
-    };
-    configure: (config?: DataStoreConfig) => void;
-    clear: () => Promise<void>;
-    stop: () => Promise<void>;
-    private processPagination;
-    private processSyncExpressions;
-    private createFromCondition;
-    private unwrapPromise;
-    private weakMapFromEntries;
-    private retrieveSessionId;
-}
-declare const instance: DataStore;
-export { DataStore as DataStoreClass, initSchema, instance as DataStore };

package/lib/index.d.ts

@@ -1,31 +0,0 @@
-export { DataStore, DataStoreClass, initSchema, ModelInstanceCreator, } from './datastore/datastore';
-export { Predicates, ModelPredicateCreator, ModelSortPredicateCreator, } from './predicates';
-export { Adapter as StorageAdapter } from './storage/adapter';
-export declare const utils: {
-    USER: import("./util").NAMESPACES;
-    traverseModel: <T extends Readonly<{
-        id: string;
-    } & Record<string, any>>>(srcModelName: string, instance: T, namespace: import("./types").SchemaNamespace, modelInstanceCreator: <T_1 extends Readonly<{
-        id: string;
-    } & Record<string, any>> = Readonly<{
-        id: string;
-    } & Record<string, any>>>(modelConstructor: import("./types").PersistentModelConstructor<T_1, {
-        readOnlyFields: "createdAt" | "updatedAt";
-    }>, init: Pick<T_1, Exclude<keyof T_1, "id" | "createdAt" | "updatedAt">> & Partial<import("./types").ModelInstanceMetadata>) => T_1, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => import("./types").PersistentModelConstructor<any, {
-        readOnlyFields: "createdAt" | "updatedAt";
-    }>) => {
-        modelName: string;
-        item: T;
-        instance: T;
-    }[];
-    validatePredicate: <T_2 extends Readonly<{
-        id: string;
-    } & Record<string, any>>>(model: T_2, groupType: "and" | "or" | "not", predicatesOrGroups: (import("./types").PredicateObject<T_2> | import("./types").PredicatesGroup<T_2>)[]) => any;
-    isNonModelConstructor: (obj: any) => obj is import("./types").NonModelTypeConstructor<any>;
-    isModelConstructor: <T_3 extends Readonly<{
-        id: string;
-    } & Record<string, any>>>(obj: any) => obj is import("./types").PersistentModelConstructor<T_3, {
-        readOnlyFields: "createdAt" | "updatedAt";
-    }>;
-};
-export * from './types';

package/lib/predicates/index.d.ts

@@ -1,15 +0,0 @@
-import { ModelPredicate, PersistentModel, PredicatesGroup, ProducerModelPredicate, SchemaModel } from '../types';
-export { ModelSortPredicateCreator } from './sort';
-export declare function isPredicatesAll(predicate: any): predicate is typeof PredicateAll;
-export declare const PredicateAll: unique symbol;
-export declare class Predicates {
-    static get ALL(): typeof PredicateAll;
-}
-export declare class ModelPredicateCreator {
-    private static predicateGroupsMap;
-    private static createPredicateBuilder;
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is ModelPredicate<T>;
-    static getPredicates<T extends PersistentModel>(predicate: ModelPredicate<T>, throwOnInvalid?: boolean): PredicatesGroup<any>;
-    static createFromExisting<T extends PersistentModel>(modelDefinition: SchemaModel, existing: ProducerModelPredicate<T>): ModelPredicate<T>;
-    static createForId<T extends PersistentModel>(modelDefinition: SchemaModel, id: string): ModelPredicate<T>;
-}

package/lib/predicates/sort.d.ts

@@ -1,8 +0,0 @@
-import { PersistentModel, SchemaModel, SortPredicate, ProducerSortPredicate, SortPredicatesGroup } from '../types';
-export declare class ModelSortPredicateCreator {
-    private static sortPredicateGroupsMap;
-    private static createPredicateBuilder;
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is SortPredicate<T>;
-    static getPredicates<T extends PersistentModel>(predicate: SortPredicate<T>, throwOnInvalid?: boolean): SortPredicatesGroup<T>;
-    static createFromExisting<T extends PersistentModel>(modelDefinition: SchemaModel, existing: ProducerSortPredicate<T>): SortPredicate<T>;
-}

package/lib/ssr/index.d.ts

@@ -1,3 +0,0 @@
-import { PersistentModel, PersistentModelConstructor } from '@aws-amplify/datastore';
-export declare function deserializeModel<T extends PersistentModel>(Model: PersistentModelConstructor<T>, init: T | T[]): any;
-export declare function serializeModel<T extends PersistentModel>(model: T | T[]): JSON;

package/lib/storage/adapter/AsyncStorageAdapter.d.ts

@@ -1,40 +0,0 @@
-import { Adapter } from './index';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-export declare class AsyncStorageAdapter implements Adapter {
-    private schema;
-    private namespaceResolver;
-    private modelInstanceCreator;
-    private getModelConstructorByModelName;
-    private db;
-    private initPromise;
-    private resolve;
-    private reject;
-    private getStorenameForModel;
-    private getStorename;
-    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    private load;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    private getById;
-    private getAll;
-    private idFromPredicate;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
-    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
-    private deleteItem;
-    /**
-     * Populates the delete Queue with all the items to delete
-     * @param relations
-     * @param models
-     * @param srcModel
-     * @param nameSpace
-     * @param deleteQueue
-     */
-    private deleteTraverse;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-}
-declare const _default: AsyncStorageAdapter;
-export default _default;

package/lib/storage/adapter/AsyncStorageDatabase.d.ts

@@ -1,29 +0,0 @@
-import { ModelInstanceMetadata, OpType, PaginationInput, PersistentModel, QueryOne } from '../../types';
-declare class AsyncStorageDatabase {
-    /**
-     * Maps storeNames to a map of ulid->id
-     */
-    private _collectionInMemoryIndex;
-    private storage;
-    private getCollectionIndex;
-    private getMonotonicFactory;
-    init(): Promise<void>;
-    save<T extends PersistentModel>(item: T, storeName: string): Promise<void>;
-    batchSave<T extends PersistentModel>(storeName: string, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    get<T extends PersistentModel>(id: string, storeName: string): Promise<T>;
-    getOne(firstOrLast: QueryOne, storeName: string): Promise<any>;
-    /**
-     * This function gets all the records stored in async storage for a particular storeName
-     * It then loads all the records for that filtered set of keys using multiGet()
-     */
-    getAll<T extends PersistentModel>(storeName: string, pagination?: PaginationInput<T>): Promise<T[]>;
-    delete(id: string, storeName: string): Promise<void>;
-    /**
-     * Clear the AsyncStorage of all DataStore entries
-     */
-    clear(): Promise<void>;
-    private getKeyForItem;
-    private getLegacyKeyForItem;
-    private getKeyPrefixForStoreItems;
-}
-export default AsyncStorageDatabase;

package/lib/storage/adapter/InMemoryStore.d.ts

@@ -1,11 +0,0 @@
-export declare class InMemoryStore {
-    db: Map<string, string>;
-    getAllKeys: () => Promise<string[]>;
-    multiGet: (keys: string[]) => Promise<any[]>;
-    multiRemove: (keys: string[], callback?: any) => Promise<void>;
-    multiSet: (entries: string[][], callback?: any) => Promise<void>;
-    setItem: (key: string, value: string) => Promise<Map<string, string>>;
-    removeItem: (key: string) => Promise<boolean>;
-    getItem: (key: string) => Promise<string>;
-}
-export declare function createInMemoryStore(): InMemoryStore;

package/lib/storage/adapter/InMemoryStore.native.d.ts

@@ -1 +0,0 @@
-export declare function createInMemoryStore(): AsyncStorage;

package/lib/storage/adapter/IndexedDBAdapter.d.ts

@@ -1,37 +0,0 @@
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne } from '../../types';
-import { Adapter } from './index';
-declare class IndexedDBAdapter implements Adapter {
-    private schema;
-    private namespaceResolver;
-    private modelInstanceCreator;
-    private getModelConstructorByModelName;
-    private db;
-    private initPromise;
-    private resolve;
-    private reject;
-    private dbName;
-    private checkPrivate;
-    private getStorenameForModel;
-    private getStorename;
-    setUp(theSchema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, sessionId?: string): Promise<void>;
-    private _get;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    private load;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    private getById;
-    private getAll;
-    private idFromPredicate;
-    private filterOnPredicate;
-    private inMemoryPagination;
-    private enginePagination;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T | undefined>;
-    delete<T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>): Promise<[T[], T[]]>;
-    private deleteItem;
-    private deleteTraverse;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    private createObjectStoreForModel;
-}
-declare const _default: IndexedDBAdapter;
-export default _default;

package/lib/storage/adapter/getDefaultAdapter/index.d.ts

@@ -1,3 +0,0 @@
-import { Adapter } from '..';
-declare const getDefaultAdapter: () => Adapter;
-export default getDefaultAdapter;

package/lib/storage/adapter/getDefaultAdapter/index.native.d.ts

@@ -1,3 +0,0 @@
-import { Adapter } from '..';
-declare const getDefaultAdapter: () => Adapter;
-export default getDefaultAdapter;

package/lib/storage/adapter/index.d.ts

@@ -1,9 +0,0 @@
-import { ModelInstanceMetadata, ModelPredicate, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne, SystemComponent } from '../../types';
-export interface Adapter extends SystemComponent {
-    clear(): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete: <T extends PersistentModel>(modelOrModelConstructor: T | PersistentModelConstructor<T>, condition?: ModelPredicate<T>) => Promise<[T[], T[]]>;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast: QueryOne): Promise<T | undefined>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-}

package/lib/storage/storage.d.ts

@@ -1,49 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { Patch } from 'immer';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { InternalSchema, ModelInstanceMetadata, ModelPredicate, NamespaceResolver, OpType, PaginationInput, PersistentModel, PersistentModelConstructor, QueryOne, SchemaNamespace, InternalSubscriptionMessage, SubscriptionMessage } from '../types';
-import { Adapter } from './adapter';
-export declare type StorageSubscriptionMessage<T extends PersistentModel> = InternalSubscriptionMessage<T> & {
-    mutator?: Symbol;
-};
-export declare type StorageFacade = Omit<Adapter, 'setUp'>;
-export declare type Storage = InstanceType<typeof StorageClass>;
-declare class StorageClass implements StorageFacade {
-    private readonly schema;
-    private readonly namespaceResolver;
-    private readonly getModelConstructorByModelName;
-    private readonly modelInstanceCreator;
-    private readonly adapter?;
-    private readonly sessionId?;
-    private initialized;
-    private readonly pushStream;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, modelInstanceCreator: ModelInstanceCreator, adapter?: Adapter, sessionId?: string);
-    static getNamespace(): SchemaNamespace;
-    init(): Promise<void>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol, patchesTuple?: [Patch[], PersistentModel]): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    delete<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T>;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, skipOwn?: Symbol): Observable<SubscriptionMessage<T>>;
-    clear(completeObservable?: boolean): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[], mutator?: Symbol): Promise<[T, OpType][]>;
-    private getUpdateMutationInput;
-}
-declare class ExclusiveStorage implements StorageFacade {
-    private storage;
-    private readonly mutex;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, modelInstanceCreator: ModelInstanceCreator, adapter?: Adapter, sessionId?: string);
-    runExclusive<T>(fn: (storage: StorageClass) => Promise<T>): Promise<T>;
-    save<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol, patchesTuple?: [Patch[], PersistentModel]): Promise<[T, OpType.INSERT | OpType.UPDATE][]>;
-    delete<T extends PersistentModel>(model: T, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    delete<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition?: ModelPredicate<T>, mutator?: Symbol): Promise<[T[], T[]]>;
-    query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, pagination?: PaginationInput<T>): Promise<T[]>;
-    queryOne<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, firstOrLast?: QueryOne): Promise<T>;
-    static getNamespace(): SchemaNamespace;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T>, predicate?: ModelPredicate<T>, skipOwn?: Symbol): Observable<SubscriptionMessage<T>>;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    init(): Promise<void>;
-}
-export { ExclusiveStorage };

package/lib/sync/datastoreConnectivity.d.ts

@@ -1,15 +0,0 @@
-import Observable from 'zen-observable-ts';
-declare type ConnectionStatus = {
-    online: boolean;
-};
-export default class DataStoreConnectivity {
-    private connectionStatus;
-    private observer;
-    private subscription;
-    private timeout;
-    constructor();
-    status(): Observable<ConnectionStatus>;
-    unsubscribe(): void;
-    socketDisconnected(): void;
-}
-export {};

package/lib/sync/datastoreReachability/index.d.ts

@@ -1,3 +0,0 @@
-export declare const ReachabilityMonitor: import("zen-observable-ts").default<{
-    online: boolean;
-}>;

package/lib/sync/datastoreReachability/index.native.d.ts

@@ -1,3 +0,0 @@
-export declare const ReachabilityMonitor: import("zen-observable-ts").default<{
-    online: boolean;
-}>;

package/lib/sync/index.d.ts

@@ -1,63 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { ExclusiveStorage as Storage } from '../storage/storage';
-import { ConflictHandler, ControlMessageType, ErrorHandler, InternalSchema, ModelInit, MutableModel, NamespaceResolver, PersistentModelConstructor, SchemaModel, SchemaNamespace, TypeConstructorMap, ModelPredicate, AuthModeStrategy, AmplifyContext } from '../types';
-import { TransformerMutationType } from './utils';
-declare type StartParams = {
-    fullSyncInterval: number;
-};
-export declare class MutationEvent {
-    constructor(init: ModelInit<MutationEvent>);
-    static copyOf(src: MutationEvent, mutator: (draft: MutableModel<MutationEvent>) => void | MutationEvent): MutationEvent;
-    readonly id: string;
-    readonly model: string;
-    readonly operation: TransformerMutationType;
-    readonly modelId: string;
-    readonly condition: string;
-    data: string;
-}
-export declare enum ControlMessage {
-    SYNC_ENGINE_STORAGE_SUBSCRIBED = "storageSubscribed",
-    SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED = "subscriptionsEstablished",
-    SYNC_ENGINE_SYNC_QUERIES_STARTED = "syncQueriesStarted",
-    SYNC_ENGINE_SYNC_QUERIES_READY = "syncQueriesReady",
-    SYNC_ENGINE_MODEL_SYNCED = "modelSynced",
-    SYNC_ENGINE_OUTBOX_MUTATION_ENQUEUED = "outboxMutationEnqueued",
-    SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED = "outboxMutationProcessed",
-    SYNC_ENGINE_OUTBOX_STATUS = "outboxStatus",
-    SYNC_ENGINE_NETWORK_STATUS = "networkStatus",
-    SYNC_ENGINE_READY = "ready"
-}
-export declare class SyncEngine {
-    private readonly schema;
-    private readonly namespaceResolver;
-    private readonly modelClasses;
-    private readonly userModelClasses;
-    private readonly storage;
-    private readonly modelInstanceCreator;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly amplifyContext;
-    private online;
-    private readonly syncQueriesProcessor;
-    private readonly subscriptionsProcessor;
-    private readonly mutationsProcessor;
-    private readonly modelMerger;
-    private readonly outbox;
-    private readonly datastoreConnectivity;
-    private readonly modelSyncedStatus;
-    getModelSyncedStatus(modelConstructor: PersistentModelConstructor<any>): boolean;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, modelClasses: TypeConstructorMap, userModelClasses: TypeConstructorMap, storage: Storage, modelInstanceCreator: ModelInstanceCreator, conflictHandler: ConflictHandler, errorHandler: ErrorHandler, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, amplifyContext: AmplifyContext);
-    start(params: StartParams): Observable<ControlMessageType<ControlMessage>>;
-    private getModelsMetadataWithNextFullSync;
-    private syncQueriesObservable;
-    private disconnectionHandler;
-    unsubscribeConnectivity(): void;
-    private setupModels;
-    private getModelsMetadata;
-    private getModelMetadata;
-    private getModelDefinition;
-    static getNamespace(): SchemaNamespace;
-}
-export {};

package/lib/sync/merger.d.ts

@@ -1,11 +0,0 @@
-import { Storage } from '../storage/storage';
-import { ModelInstanceMetadata, OpType, PersistentModelConstructor } from '../types';
-import { MutationEventOutbox } from './outbox';
-declare class ModelMerger {
-    private readonly outbox;
-    private readonly ownSymbol;
-    constructor(outbox: MutationEventOutbox, ownSymbol: Symbol);
-    merge<T extends ModelInstanceMetadata>(storage: Storage, model: T): Promise<OpType>;
-    mergePage(storage: Storage, modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[]): Promise<[ModelInstanceMetadata, OpType][]>;
-}
-export { ModelMerger };

package/lib/sync/outbox.d.ts

@@ -1,27 +0,0 @@
-import { MutationEvent } from './index';
-import { ExclusiveStorage as Storage, StorageFacade, Storage as StorageClass } from '../storage/storage';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { InternalSchema, PersistentModel, PersistentModelConstructor } from '../types';
-import { TransformerMutationType } from './utils';
-declare class MutationEventOutbox {
-    private readonly schema;
-    private readonly MutationEvent;
-    private readonly modelInstanceCreator;
-    private readonly ownSymbol;
-    private inProgressMutationEventId;
-    constructor(schema: InternalSchema, MutationEvent: PersistentModelConstructor<MutationEvent>, modelInstanceCreator: ModelInstanceCreator, ownSymbol: Symbol);
-    enqueue(storage: Storage, mutationEvent: MutationEvent): Promise<void>;
-    dequeue(storage: StorageClass, record?: PersistentModel, recordOp?: TransformerMutationType): Promise<MutationEvent>;
-    /**
-     * Doing a peek() implies that the mutation goes "inProgress"
-     *
-     * @param storage
-     */
-    peek(storage: StorageFacade): Promise<MutationEvent>;
-    getForModel<T extends PersistentModel>(storage: StorageFacade, model: T): Promise<MutationEvent[]>;
-    getModelIds(storage: StorageFacade): Promise<Set<string>>;
-    private syncOutboxVersionsOnDequeue;
-    private mergeUserFields;
-    private removeTimestampFields;
-}
-export { MutationEventOutbox };

package/lib/sync/processors/errorMaps.d.ts

@@ -1,17 +0,0 @@
-import { ErrorType } from '../../types';
-export declare type ErrorMap = Partial<{
-    [key in ErrorType]: (error: Error) => boolean;
-}>;
-export declare const mutationErrorMap: ErrorMap;
-export declare const subscriptionErrorMap: ErrorMap;
-export declare const syncErrorMap: ErrorMap;
-export declare function getMutationErrorType(error: Error): ErrorType;
-export declare function getSubscriptionErrorType(error: Error): ErrorType;
-export declare function getSyncErrorType(error: Error): ErrorType;
-/**
- * Categorizes an error with a broad error type, intended to make
- * customer error handling code simpler.
- * @param errorMap Error names and a list of patterns that indicate them (each pattern as a regex or function)
- * @param error The underying error to categorize.
- */
-export declare function mapErrorToType(errorMap: ErrorMap, error: Error): ErrorType;

package/lib/sync/processors/mutation.d.ts

@@ -1,56 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { MutationEvent } from '../';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { ExclusiveStorage as Storage } from '../../storage/storage';
-import { AuthModeStrategy, ConflictHandler, ErrorHandler, InternalSchema, PersistentModel, PersistentModelConstructor, SchemaModel, TypeConstructorMap, AmplifyContext } from '../../types';
-import { MutationEventOutbox } from '../outbox';
-import { TransformerMutationType } from '../utils';
-declare type MutationProcessorEvent = {
-    operation: TransformerMutationType;
-    modelDefinition: SchemaModel;
-    model: PersistentModel;
-    hasMore: boolean;
-};
-declare class MutationProcessor {
-    private readonly schema;
-    private readonly storage;
-    private readonly userClasses;
-    private readonly outbox;
-    private readonly modelInstanceCreator;
-    private readonly MutationEvent;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly conflictHandler;
-    private readonly amplifyContext;
-    private observer;
-    private readonly typeQuery;
-    private processing;
-    constructor(schema: InternalSchema, storage: Storage, userClasses: TypeConstructorMap, outbox: MutationEventOutbox, modelInstanceCreator: ModelInstanceCreator, MutationEvent: PersistentModelConstructor<MutationEvent>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, conflictHandler: ConflictHandler, amplifyContext: AmplifyContext);
-    private generateQueries;
-    private isReady;
-    start(): Observable<MutationProcessorEvent>;
-    resume(): Promise<void>;
-    private jitteredRetry;
-    private createQueryVariables;
-    private opTypeFromTransformerOperation;
-    pause(): void;
-}
-declare const originalJitteredBackoff: import("@aws-amplify/core/lib-esm/types").DelayFunction;
-/**
- * @private
- * Internal use of Amplify only.
- *
- * Wraps the jittered backoff calculation to retry Network Errors indefinitely.
- * Backs off according to original jittered retry logic until the original retry
- * logic hits its max. After this occurs, if the error is a Network Error, we
- * ignore the attempt count and return MAX_RETRY_DELAY_MS to retry forever (until
- * the request succeeds).
- *
- * @param attempt ignored
- * @param _args ignored
- * @param error tested to see if `.message` is 'Network Error'
- * @returns number | false :
- */
-export declare const safeJitteredBackoff: typeof originalJitteredBackoff;
-export { MutationProcessor };

package/lib/sync/processors/subscription.d.ts

@@ -1,31 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { InternalSchema, PersistentModel, SchemaModel, ModelPredicate, AuthModeStrategy, ErrorHandler, AmplifyContext } from '../../types';
-import { TransformerMutationType } from '../utils';
-export declare enum CONTROL_MSG {
-    CONNECTED = "CONNECTED"
-}
-export declare enum USER_CREDENTIALS {
-    'none' = 0,
-    'unauth' = 1,
-    'auth' = 2
-}
-declare class SubscriptionProcessor {
-    private readonly schema;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly amplifyContext;
-    private readonly typeQuery;
-    private buffer;
-    private dataObserver;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext?: AmplifyContext);
-    private buildSubscription;
-    private getAuthorizationInfo;
-    private hubQueryCompletionListener;
-    start(): [Observable<CONTROL_MSG>, Observable<[TransformerMutationType, SchemaModel, PersistentModel]>];
-    private passesPredicateValidation;
-    private pushToBuffer;
-    private drainBuffer;
-}
-export { SubscriptionProcessor };

package/lib/sync/processors/sync.d.ts

@@ -1,27 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { InternalSchema, ModelInstanceMetadata, SchemaModel, ModelPredicate, AuthModeStrategy, ErrorHandler, AmplifyContext } from '../../types';
-declare class SyncProcessor {
-    private readonly schema;
-    private readonly syncPredicates;
-    private readonly amplifyConfig;
-    private readonly authModeStrategy;
-    private readonly errorHandler;
-    private readonly amplifyContext;
-    private readonly typeQuery;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext: AmplifyContext);
-    private generateQueries;
-    private graphqlFilterFromPredicate;
-    private retrievePage;
-    private partialDataFeatureFlagEnabled;
-    private jitteredRetry;
-    start(typesLastSync: Map<SchemaModel, [string, number]>): Observable<SyncModelPage>;
-}
-export declare type SyncModelPage = {
-    namespace: string;
-    modelDefinition: SchemaModel;
-    items: ModelInstanceMetadata[];
-    startedAt: number;
-    done: boolean;
-    isFullSync: boolean;
-};
-export { SyncProcessor };