@aws-amplify/datastore 5.0.1-unstable.cfbde4c.0 → 5.0.1

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<T>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-}

package/lib/storage/relationship.d.ts

@@ -1,149 +0,0 @@
-import { ModelMeta } from '../types';
-/**
- * Defines a relationship from a LOCAL model.field to a REMOTE model.field and helps
- * navigate the relationship, providing a simplified peek at the relationship details
- * pertinent to setting FK's and constructing join conditions.
- *
- * Because I mean, relationships are tough.
- *
- */
-export declare class ModelRelationship<T> {
-    private localModel;
-    private _field;
-    /**
-     * @param modelDefinition The "local" model.
-     * @param field The "local" model field.
-     */
-    constructor(model: ModelMeta<T>, field: string);
-    /**
-     * Returns a ModelRelationship for the the given model and field if the pair
-     * indicates a relationship to another model. Else, returns `null`.
-     *
-     * @param model The model the relationship field exists in.
-     * @param field The field that may relates the local model to the remote model.
-     */
-    static from<T>(model: ModelMeta<T>, field: string): ModelRelationship<T>;
-    /**
-     * Enumerates all valid `ModelRelationship`'s on the given model.
-     *
-     * @param model The model definition to enumerate relationships of.
-     */
-    static allFrom<T>(model: ModelMeta<T>): ModelRelationship<T>[];
-    private get localDefinition();
-    /**
-     * The virtual/computed field on the local model that should contain
-     * the related model.
-     */
-    get field(): string;
-    /**
-     * The constructor that can be used to query DataStore or create instance for
-     * the local model.
-     */
-    get localConstructor(): import("../types").PersistentModelConstructor<T>;
-    /**
-     * The name/type of the relationship the local model has with the remote model
-     * via the defined local model field.
-     */
-    get type(): "HAS_MANY" | "HAS_ONE" | "BELONGS_TO";
-    /**
-     * Raw details about the local FK as-is from the local model's field definition in
-     * the schema. This field requires interpretation.
-     *
-     * @see localJoinFields
-     * @see localAssociatedWith
-     */
-    private get localAssocation();
-    /**
-     * The field names on the local model that can be used to query or queried to match
-     * with instances of the remote model.
-     *
-     * Fields are returned in-order to match the order of `this.remoteKeyFields`.
-     */
-    get localJoinFields(): string[];
-    /**
-     * The field names on the local model that uniquely identify it.
-     *
-     * These fields may or may not be relevant to the join fields.
-     */
-    get localPKFields(): string[];
-    get remoteDefinition(): import("../types").SchemaModel;
-    private get remoteModelType();
-    /**
-     * Constructor that can be used to query DataStore or create instances for
-     * the remote model.
-     */
-    get remoteModelConstructor(): import("../types").PersistentModelConstructor<Readonly<Record<string, any>>>;
-    /**
-     * The field names on the remote model that uniquely identify it.
-     *
-     * These fields may or may not be relevant to the join fields.
-     */
-    get remotePKFields(): string[];
-    /**
-     * The `associatedWith` fields from the local perspective.
-     *
-     * When present, these fields indicate which fields on the remote model to use
-     * when looking for a remote association and/or determining the final remote
-     * key fields.
-     */
-    private get localAssociatedWith();
-    /**
-     * The `remote` model's associated field's `assocation` metadata, if
-     * present.
-     *
-     * This is used when determining if the remote model's associated field
-     * specifies which FK fields to use. If this value is `undefined`, the
-     * name of the remote field (`this.localAssociatedWith`) *is* the remote
-     * key field.
-     */
-    private get explicitRemoteAssociation();
-    /**
-     * The field names on the remote model that can used to query or queried to match
-     * with instances of the local model.
-     *
-     * Fields are returned in-order to match the order of `this.localKeyFields`.
-     */
-    get remoteJoinFields(): string[];
-    /**
-     * Whether this relationship everything necessary to get, set, and query from
-     * the perspective of the local model provided at instantiation.
-     */
-    get isComplete(): boolean;
-    /**
-     * Creates an FK mapper object with respect to the given related instance.
-     *
-     * E.g., if the local FK fields are `[parentId, parentName]` and point to
-     * `[customId, name]` on the remote model, `createLocalFKObject(remote)`
-     * will return:
-     *
-     * ```
-     * {
-     * 	parentId: remote.customId,
-     * 	parentName: remote.name
-     * }
-     * ```
-     *
-     * @param remote The remote related instance.
-     */
-    createLocalFKObject(remote: any): Record<string, string>;
-    /**
-     * Creates an query mapper object to help fetch the remote instance(s) or
-     * `null` if any of the necessary local fields are `null` or `undefined`.
-     *
-     * E.g., if the local FK fields are `[parentId, parentName]` and point to
-     * `[customId, name]` on the remote model, `createLocalFKObject(remote)`
-     * will return:
-     *
-     * ```
-     * {
-     * 	customId: local.parentId
-     * 	name: local.parentName
-     * }
-     * ```
-     *
-     * If the local fields are not populated, returns
-     *
-     * @param local The local instance.
-     */
-    createRemoteQueryObject(local: T): Record<string, string>;
-}

package/lib/storage/storage.d.ts

@@ -1,50 +0,0 @@
-import { Observable } from 'rxjs';
-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 { NAMESPACES } from '../util';
-import { Adapter } from './adapter';
-export type StorageSubscriptionMessage<T extends PersistentModel> = InternalSubscriptionMessage<T> & {
-    mutator?: Symbol;
-};
-export type StorageFacade = Omit<Adapter, 'setUp'>;
-export 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: NAMESPACES, 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 | undefined>;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T> | null, predicate?: ModelPredicate<T> | null, 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 getChangedFieldsInput;
-}
-declare class ExclusiveStorage implements StorageFacade {
-    private storage;
-    private readonly mutex;
-    constructor(schema: InternalSchema, namespaceResolver: NamespaceResolver, getModelConstructorByModelName: (namsespaceName: NAMESPACES, 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 | undefined>;
-    static getNamespace(): SchemaNamespace;
-    observe<T extends PersistentModel>(modelConstructor?: PersistentModelConstructor<T> | null, predicate?: ModelPredicate<T> | null, skipOwn?: Symbol): Observable<SubscriptionMessage<T>>;
-    clear(): Promise<void>;
-    batchSave<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, items: ModelInstanceMetadata[]): Promise<[T, OpType][]>;
-    init(): Promise<void>;
-}
-export { ExclusiveStorage };

package/lib/sync/datastoreConnectivity.d.ts

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

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

@@ -1 +0,0 @@
-export declare const ReachabilityMonitor: import("rxjs").Observable<import("@aws-amplify/core/lib-esm/Reachability/types").NetworkStatus>;

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

@@ -1 +0,0 @@
-export declare const ReachabilityMonitor: import("rxjs").Observable<import("@aws-amplify/core/lib-esm/Reachability/types").NetworkStatus>;

package/lib/sync/index.d.ts

@@ -1,103 +0,0 @@
-import { Observable } from 'rxjs';
-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, ManagedIdentifier, OptionallyManagedIdentifier, AmplifyContext } from '../types';
-import type { __modelMeta__ } from '../types';
-import DataStoreConnectivity from './datastoreConnectivity';
-import { TransformerMutationType } from './utils';
-type StartParams = {
-    fullSyncInterval: number;
-};
-export declare class MutationEvent {
-    readonly [__modelMeta__]: {
-        identifier: OptionallyManagedIdentifier<MutationEvent, 'id'>;
-    };
-    readonly id: string;
-    readonly model: string;
-    readonly operation: TransformerMutationType;
-    readonly modelId: string;
-    readonly condition: string;
-    readonly data: string;
-    constructor(init: ModelInit<MutationEvent>);
-    static copyOf(src: MutationEvent, mutator: (draft: MutableModel<MutationEvent>) => void | MutationEvent): MutationEvent;
-}
-export declare class ModelMetadata {
-    readonly [__modelMeta__]: {
-        identifier: ManagedIdentifier<ModelMetadata, 'id'>;
-    };
-    readonly id: string;
-    readonly namespace: string;
-    readonly model: string;
-    readonly fullSyncInterval: number;
-    readonly lastSync?: number;
-    readonly lastFullSync?: number;
-    readonly lastSyncPredicate?: null | string;
-    constructor(init: ModelInit<ModelMetadata>);
-    static copyOf(src: ModelMetadata, mutator: (draft: MutableModel<ModelMetadata>) => void | ModelMetadata): ModelMetadata;
-}
-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 readonly connectivityMonitor?;
-    private online;
-    private readonly syncQueriesProcessor;
-    private readonly subscriptionsProcessor;
-    private readonly mutationsProcessor;
-    private readonly modelMerger;
-    private readonly outbox;
-    private readonly datastoreConnectivity;
-    private readonly modelSyncedStatus;
-    private unsleepSyncQueriesObservable;
-    private waitForSleepState;
-    private syncQueriesObservableStartSleeping;
-    private stopDisruptionListener;
-    private connectionDisrupted;
-    private runningProcesses;
-    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> | null>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, amplifyContext: AmplifyContext, connectivityMonitor?: DataStoreConnectivity);
-    start(params: StartParams): Observable<ControlMessageType<ControlMessage>>;
-    private getModelsMetadataWithNextFullSync;
-    private syncQueriesObservable;
-    private disconnectionHandler;
-    unsubscribeConnectivity(): void;
-    /**
-     * Stops all subscription activities and resolves when all activies report
-     * that they're disconnected, done retrying, etc..
-     */
-    stop(): Promise<void>;
-    private setupModels;
-    private getModelsMetadata;
-    private getModelMetadata;
-    private getModelDefinition;
-    static getNamespace(): SchemaNamespace;
-    /**
-     * listen for websocket connection disruption
-     *
-     * May indicate there was a period of time where messages
-     * from AppSync were missed. A sync needs to be triggered to
-     * retrieve the missed data.
-     */
-    private startDisruptionListener;
-    private scheduleSync;
-}
-export {};

package/lib/sync/merger.d.ts

@@ -1,17 +0,0 @@
-import { Storage } from '../storage/storage';
-import { ModelInstanceMetadata, OpType, PersistentModelConstructor, SchemaModel } from '../types';
-import { MutationEventOutbox } from './outbox';
-declare class ModelMerger {
-    private readonly outbox;
-    private readonly ownSymbol;
-    constructor(outbox: MutationEventOutbox, ownSymbol: Symbol);
-    /**
-     *
-     * @param storage Storage adapter that contains the data.
-     * @param model The model from an outbox mutation.
-     * @returns The type of operation (INSERT/UPDATE/DELETE)
-     */
-    merge<T extends ModelInstanceMetadata>(storage: Storage, model: T, modelDefinition: SchemaModel): Promise<OpType>;
-    mergePage(storage: Storage, modelConstructor: PersistentModelConstructor<any>, items: ModelInstanceMetadata[], modelDefinition: SchemaModel): 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, SchemaModel } 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, userModelDefinition: SchemaModel): 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 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/subscription.d.ts

@@ -1,42 +0,0 @@
-import { Observable } from 'rxjs';
-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;
-    private runningProcesses;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any> | null>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext?: AmplifyContext);
-    private buildSubscription;
-    private getAuthorizationInfo;
-    private hubQueryCompletionListener;
-    start(): [
-        Observable<CONTROL_MSG>,
-        Observable<[TransformerMutationType, SchemaModel, PersistentModel]>
-    ];
-    stop(): Promise<void>;
-    private passesPredicateValidation;
-    private pushToBuffer;
-    private drainBuffer;
-    /**
-     * @returns true if the service returned an RTF subscription error
-     * @remarks logs a warning with remediation instructions
-     *
-     */
-    private catchRTFError;
-}
-export { SubscriptionProcessor };

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

@@ -1,28 +0,0 @@
-import { Observable } from 'rxjs';
-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;
-    private runningProcesses;
-    constructor(schema: InternalSchema, syncPredicates: WeakMap<SchemaModel, ModelPredicate<any> | null>, amplifyConfig: Record<string, any>, authModeStrategy: AuthModeStrategy, errorHandler: ErrorHandler, amplifyContext: AmplifyContext);
-    private generateQueries;
-    private graphqlFilterFromPredicate;
-    private retrievePage;
-    private jitteredRetry;
-    start(typesLastSync: Map<SchemaModel, [string, number]>): Observable<SyncModelPage>;
-    stop(): Promise<void>;
-}
-export type SyncModelPage = {
-    namespace: string;
-    modelDefinition: SchemaModel;
-    items: ModelInstanceMetadata[];
-    startedAt: number;
-    done: boolean;
-    isFullSync: boolean;
-};
-export { SyncProcessor };

package/lib/sync/utils.d.ts

@@ -1,107 +0,0 @@
-import { GraphQLAuthError } from '@aws-amplify/api';
-import { GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { AuthorizationRule, GraphQLCondition, GraphQLFilter, ModelInstanceMetadata, OpType, PersistentModel, PersistentModelConstructor, PredicatesGroup, RelationshipType, SchemaModel, SchemaNamespace, SchemaNonModel, ModelOperation, InternalSchema, AuthModeStrategy } from '../types';
-import { MutationEvent } from './';
-declare enum GraphQLOperationType {
-    LIST = "query",
-    CREATE = "mutation",
-    UPDATE = "mutation",
-    DELETE = "mutation",
-    GET = "query"
-}
-export declare enum TransformerMutationType {
-    CREATE = "Create",
-    UPDATE = "Update",
-    DELETE = "Delete",
-    GET = "Get"
-}
-export declare function getMetadataFields(): ReadonlyArray<string>;
-export declare function generateSelectionSet(namespace: SchemaNamespace, modelDefinition: SchemaModel | SchemaNonModel): string;
-export declare function getAuthorizationRules(modelDefinition: SchemaModel): AuthorizationRule[];
-export declare function buildSubscriptionGraphQLOperation(namespace: SchemaNamespace, modelDefinition: SchemaModel, transformerMutationType: TransformerMutationType, isOwnerAuthorization: boolean, ownerField: string, filterArg?: boolean): [TransformerMutationType, string, string];
-export declare function buildGraphQLOperation(namespace: SchemaNamespace, modelDefinition: SchemaModel, graphQLOpType: keyof typeof GraphQLOperationType): [TransformerMutationType, string, string][];
-export declare function createMutationInstanceFromModelOperation<T extends PersistentModel>(relationships: RelationshipType, modelDefinition: SchemaModel, opType: OpType, model: PersistentModelConstructor<T>, element: T, condition: GraphQLCondition, MutationEventConstructor: PersistentModelConstructor<MutationEvent>, modelInstanceCreator: ModelInstanceCreator, id?: string): MutationEvent;
-export declare function predicateToGraphQLCondition(predicate: PredicatesGroup<any>, modelDefinition: SchemaModel): GraphQLCondition;
-/**
- * @param predicatesGroup - Predicate Group
-    @returns GQL Filter Expression from Predicate Group
-    
-    @remarks Flattens redundant list predicates
-    @example
-
-    ```js
-    { and:[{ and:[{ username:  { eq: 'bob' }}] }] }
-    ```
-    Becomes
-    ```js
-    { and:[{ username: { eq: 'bob' }}] }
-    ```
-    */
-export declare function predicateToGraphQLFilter(predicatesGroup: PredicatesGroup<any>, fieldsToOmit?: string[], root?: boolean): GraphQLFilter;
-/**
- *
- * @param group - selective sync predicate group
- * @returns set of distinct field names in the filter group
- */
-export declare function filterFields(group?: PredicatesGroup<any>): Set<string>;
-/**
- *
- * @param modelDefinition
- * @returns set of field names used with dynamic auth modes configured for the provided model definition
- */
-export declare function dynamicAuthFields(modelDefinition: SchemaModel): Set<string>;
-/**
- *
- * @param group - selective sync predicate group
- * @returns the total number of OR'd predicates in the filter group
- *
- * @example returns 2
- * ```js
- * { type: "or", predicates: [
- * { field: "username", operator: "beginsWith", operand: "a" },
- * { field: "title", operator: "contains", operand: "abc" },
- * ]}
- * ```
- */
-export declare function countFilterCombinations(group?: PredicatesGroup<any>): number;
-/**
- *
- * @param group - selective sync predicate group
- * @returns name of repeated field | null
- *
- * @example returns "username"
- * ```js
- * { type: "and", predicates: [
- * 		{ field: "username", operator: "beginsWith", operand: "a" },
- * 		{ field: "username", operator: "contains", operand: "abc" },
- * ] }
- * ```
- */
-export declare function repeatedFieldInGroup(group?: PredicatesGroup<any>): string | null;
-export declare enum RTFError {
-    UnknownField = 0,
-    MaxAttributes = 1,
-    MaxCombinations = 2,
-    RepeatedFieldname = 3,
-    NotGroup = 4,
-    FieldNotInType = 5
-}
-export declare function generateRTFRemediation(errorType: RTFError, modelDefinition: SchemaModel, predicatesGroup: PredicatesGroup<any> | undefined): string;
-export declare function getUserGroupsFromToken(token: {
-    [field: string]: any;
-}, rule: AuthorizationRule): string[];
-export declare function getModelAuthModes({ authModeStrategy, defaultAuthMode, modelName, schema, }: {
-    authModeStrategy: AuthModeStrategy;
-    defaultAuthMode: GraphQLAuthMode;
-    modelName: string;
-    schema: InternalSchema;
-}): Promise<{
-    [key in ModelOperation]: GraphQLAuthMode[];
-}>;
-export declare function getForbiddenError(error: any): any;
-export declare function resolveServiceErrorStatusCode(error: unknown): number | null;
-export declare function getClientSideAuthError(error: any): GraphQLAuthError;
-export declare function getTokenForCustomAuth(authMode: GraphQLAuthMode, amplifyConfig?: Record<string, any>): Promise<string | undefined>;
-export declare function getIdentifierValue(modelDefinition: SchemaModel, model: ModelInstanceMetadata | PersistentModel): string;
-export {};