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

package/lib/sync/utils.d.ts

@@ -1,41 +0,0 @@
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
-import { GraphQLAuthError } from '@aws-amplify/api';
-import { ModelInstanceCreator } from '../datastore/datastore';
-import { AuthorizationRule, GraphQLCondition, GraphQLFilter, 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): [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>): GraphQLCondition;
-export declare function predicateToGraphQLFilter(predicatesGroup: PredicatesGroup<any>): GraphQLFilter;
-export declare function getUserGroupsFromToken(token: {
-    [field: string]: any;
-}, rule: AuthorizationRule): string[];
-export declare function getModelAuthModes({ authModeStrategy, defaultAuthMode, modelName, schema, }: {
-    authModeStrategy: AuthModeStrategy;
-    defaultAuthMode: GRAPHQL_AUTH_MODE;
-    modelName: string;
-    schema: InternalSchema;
-}): Promise<{
-    [key in ModelOperation]: GRAPHQL_AUTH_MODE[];
-}>;
-export declare function getForbiddenError(error: any): any;
-export declare function getClientSideAuthError(error: any): GraphQLAuthError;
-export declare function getTokenForCustomAuth(authMode: GRAPHQL_AUTH_MODE, amplifyConfig?: Record<string, any>): Promise<string | undefined>;
-export {};

package/lib/types.d.ts

@@ -1,462 +0,0 @@
-import { ModelInstanceCreator } from './datastore/datastore';
-import { PredicateAll } from './predicates';
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
-import { Auth } from '@aws-amplify/auth';
-import { API } from '@aws-amplify/api';
-import Cache from '@aws-amplify/cache';
-import { Adapter } from './storage/adapter';
-export declare type Schema = UserSchema & {
-    version: string;
-};
-export declare type UserSchema = {
-    models: SchemaModels;
-    nonModels?: SchemaNonModels;
-    relationships?: RelationshipType;
-    keys?: ModelKeys;
-    enums: SchemaEnums;
-    modelTopologicalOrdering?: Map<string, string[]>;
-};
-export declare type InternalSchema = {
-    namespaces: SchemaNamespaces;
-    version: string;
-};
-export declare type SchemaNamespaces = Record<string, SchemaNamespace>;
-export declare type SchemaNamespace = UserSchema & {
-    name: string;
-};
-export declare type SchemaModels = Record<string, SchemaModel>;
-export declare type SchemaModel = {
-    name: string;
-    pluralName: string;
-    attributes?: ModelAttributes;
-    fields: ModelFields;
-    syncable?: boolean;
-};
-export declare function isSchemaModel(obj: any): obj is SchemaModel;
-export declare type SchemaNonModels = Record<string, SchemaNonModel>;
-export declare type SchemaNonModel = {
-    name: string;
-    fields: ModelFields;
-};
-declare type SchemaEnums = Record<string, SchemaEnum>;
-declare type SchemaEnum = {
-    name: string;
-    values: string[];
-};
-export declare type ModelAssociation = AssociatedWith | TargetNameAssociation;
-declare type AssociatedWith = {
-    connectionType: 'HAS_MANY' | 'HAS_ONE';
-    associatedWith: string;
-    targetName?: string;
-};
-export declare function isAssociatedWith(obj: any): obj is AssociatedWith;
-declare type TargetNameAssociation = {
-    connectionType: 'BELONGS_TO';
-    targetName: string;
-};
-export declare function isTargetNameAssociation(obj: any): obj is TargetNameAssociation;
-export declare type ModelAttributes = ModelAttribute[];
-declare type ModelAttribute = {
-    type: string;
-    properties?: Record<string, any>;
-};
-export declare type ModelAuthRule = {
-    allow: string;
-    provider?: string;
-    operations?: string[];
-    ownerField?: string;
-    identityClaim?: string;
-    groups?: string[];
-    groupClaim?: string;
-    groupsField?: string;
-};
-export declare type ModelAttributeAuth = {
-    type: 'auth';
-    properties: {
-        rules: ModelAuthRule[];
-    };
-};
-export declare function isModelAttributeAuth(attr: ModelAttribute): attr is ModelAttributeAuth;
-declare type ModelAttributeKey = {
-    type: 'key';
-    properties: {
-        name?: string;
-        fields: string[];
-    };
-};
-declare type ModelAttributePrimaryKey = {
-    type: 'key';
-    properties: {
-        fields: string[];
-    };
-};
-declare type ModelAttributeCompositeKey = {
-    type: 'key';
-    properties: {
-        name: string;
-        fields: [string, string, string, string?, string?];
-    };
-};
-export declare function isModelAttributeKey(attr: ModelAttribute): attr is ModelAttributeKey;
-export declare function isModelAttributePrimaryKey(attr: ModelAttribute): attr is ModelAttributePrimaryKey;
-export declare function isModelAttributeCompositeKey(attr: ModelAttribute): attr is ModelAttributeCompositeKey;
-export declare type ModelAttributeAuthProperty = {
-    allow: ModelAttributeAuthAllow;
-    identityClaim?: string;
-    groupClaim?: string;
-    groups?: string[];
-    operations?: string[];
-    ownerField?: string;
-    provider?: ModelAttributeAuthProvider;
-};
-export declare enum ModelAttributeAuthAllow {
-    CUSTOM = "custom",
-    OWNER = "owner",
-    GROUPS = "groups",
-    PRIVATE = "private",
-    PUBLIC = "public"
-}
-export declare enum ModelAttributeAuthProvider {
-    FUNCTION = "function",
-    USER_POOLS = "userPools",
-    OIDC = "oidc",
-    IAM = "iam",
-    API_KEY = "apiKey"
-}
-export declare type ModelFields = Record<string, ModelField>;
-export declare enum GraphQLScalarType {
-    ID = 0,
-    String = 1,
-    Int = 2,
-    Float = 3,
-    Boolean = 4,
-    AWSDate = 5,
-    AWSTime = 6,
-    AWSDateTime = 7,
-    AWSTimestamp = 8,
-    AWSEmail = 9,
-    AWSJSON = 10,
-    AWSURL = 11,
-    AWSPhone = 12,
-    AWSIPAddress = 13
-}
-export declare namespace GraphQLScalarType {
-    function getJSType(scalar: keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'>): 'string' | 'number' | 'boolean' | 'object';
-    function getValidationFunction(scalar: keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'>): ((val: string | number) => boolean) | undefined;
-}
-export declare type AuthorizationRule = {
-    identityClaim: string;
-    ownerField: string;
-    provider: 'userPools' | 'oidc' | 'iam' | 'apiKey';
-    groupClaim: string;
-    groups: [string];
-    authStrategy: 'owner' | 'groups' | 'private' | 'public';
-    areSubscriptionsPublic: boolean;
-};
-export declare function isGraphQLScalarType(obj: any): obj is keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'>;
-export declare type ModelFieldType = {
-    model: string;
-};
-export declare function isModelFieldType(obj: any): obj is ModelFieldType;
-export declare type NonModelFieldType = {
-    nonModel: string;
-};
-export declare function isNonModelFieldType(obj: any): obj is NonModelFieldType;
-declare type EnumFieldType = {
-    enum: string;
-};
-export declare function isEnumFieldType(obj: any): obj is EnumFieldType;
-export declare type ModelField = {
-    name: string;
-    type: keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'> | ModelFieldType | NonModelFieldType | EnumFieldType;
-    isArray: boolean;
-    isRequired?: boolean;
-    isReadOnly?: boolean;
-    isArrayNullable?: boolean;
-    association?: ModelAssociation;
-    attributes?: ModelAttributes[];
-};
-export declare type NonModelTypeConstructor<T> = {
-    new (init: T): T;
-};
-export declare type PersistentModelConstructor<T extends PersistentModel, K extends PersistentModelMetaData = {
-    readOnlyFields: 'createdAt' | 'updatedAt';
-}> = {
-    new (init: ModelInit<T, K>): T;
-    copyOf(src: T, mutator: (draft: MutableModel<T, K>) => void): T;
-};
-export declare type TypeConstructorMap = Record<string, PersistentModelConstructor<any> | NonModelTypeConstructor<any>>;
-export declare type PersistentModelMetaData = {
-    readOnlyFields: string;
-};
-export declare type PersistentModel = Readonly<{
-    id: string;
-} & Record<string, any>>;
-export declare type ModelInit<T, K extends PersistentModelMetaData = {
-    readOnlyFields: 'createdAt' | 'updatedAt';
-}> = Omit<T, 'id' | K['readOnlyFields']>;
-declare type DeepWritable<T> = {
-    -readonly [P in keyof T]: T[P] extends TypeName<T[P]> ? T[P] : DeepWritable<T[P]>;
-};
-export declare type MutableModel<T extends Record<string, any>, K extends PersistentModelMetaData = {
-    readOnlyFields: 'createdAt' | 'updatedAt';
-}> = DeepWritable<Omit<T, 'id' | K['readOnlyFields']>> & Readonly<Pick<T, 'id' | K['readOnlyFields']>>;
-export declare type ModelInstanceMetadata = {
-    id: string;
-    _version: number;
-    _lastChangedAt: number;
-    _deleted: boolean;
-};
-export declare enum OpType {
-    INSERT = "INSERT",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE"
-}
-export declare type SubscriptionMessage<T extends PersistentModel> = Pick<InternalSubscriptionMessage<T>, 'opType' | 'element' | 'model' | 'condition'>;
-export declare type InternalSubscriptionMessage<T extends PersistentModel> = {
-    opType: OpType;
-    element: T;
-    model: PersistentModelConstructor<T>;
-    condition: PredicatesGroup<T> | null;
-    savedElement?: T;
-};
-export declare type DataStoreSnapshot<T extends PersistentModel> = {
-    items: T[];
-    isSynced: boolean;
-};
-export declare type PredicateExpression<M extends PersistentModel, FT> = TypeName<FT> extends keyof MapTypeToOperands<FT> ? (operator: keyof MapTypeToOperands<FT>[TypeName<FT>], operand: MapTypeToOperands<FT>[TypeName<FT>][keyof MapTypeToOperands<FT>[TypeName<FT>]]) => ModelPredicate<M> : never;
-declare type EqualityOperators<T> = {
-    ne: T;
-    eq: T;
-};
-declare type ScalarNumberOperators<T> = EqualityOperators<T> & {
-    le: T;
-    lt: T;
-    ge: T;
-    gt: T;
-};
-declare type NumberOperators<T> = ScalarNumberOperators<T> & {
-    between: [T, T];
-};
-declare type StringOperators<T> = ScalarNumberOperators<T> & {
-    beginsWith: T;
-    contains: T;
-    notContains: T;
-};
-declare type BooleanOperators<T> = EqualityOperators<T>;
-declare type ArrayOperators<T> = {
-    contains: T;
-    notContains: T;
-};
-export declare type AllOperators = NumberOperators<any> & StringOperators<any> & ArrayOperators<any>;
-declare type MapTypeToOperands<T> = {
-    number: NumberOperators<NonNullable<T>>;
-    string: StringOperators<NonNullable<T>>;
-    boolean: BooleanOperators<NonNullable<T>>;
-    'number[]': ArrayOperators<number>;
-    'string[]': ArrayOperators<string>;
-    'boolean[]': ArrayOperators<boolean>;
-};
-declare type TypeName<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends string[] ? 'string[]' : T extends number[] ? 'number[]' : T extends boolean[] ? 'boolean[]' : never;
-export declare type PredicateGroups<T extends PersistentModel> = {
-    and: (predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>) => ModelPredicate<T>;
-    or: (predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>) => ModelPredicate<T>;
-    not: (predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>) => ModelPredicate<T>;
-};
-export declare type ModelPredicate<M extends PersistentModel> = {
-    [K in keyof M]-?: PredicateExpression<M, NonNullable<M[K]>>;
-} & PredicateGroups<M>;
-export declare type ProducerModelPredicate<M extends PersistentModel> = (condition: ModelPredicate<M>) => ModelPredicate<M>;
-export declare type PredicatesGroup<T extends PersistentModel> = {
-    type: keyof PredicateGroups<T>;
-    predicates: (PredicateObject<T> | PredicatesGroup<T>)[];
-};
-export declare function isPredicateObj<T extends PersistentModel>(obj: any): obj is PredicateObject<T>;
-export declare function isPredicateGroup<T extends PersistentModel>(obj: any): obj is PredicatesGroup<T>;
-export declare type PredicateObject<T extends PersistentModel> = {
-    field: keyof T;
-    operator: keyof AllOperators;
-    operand: any;
-};
-export declare enum QueryOne {
-    FIRST = 0,
-    LAST = 1
-}
-export declare type GraphQLField = {
-    [field: string]: {
-        [operator: string]: string | number | [number, number];
-    };
-};
-export declare type GraphQLCondition = Partial<GraphQLField | {
-    and: [GraphQLCondition];
-    or: [GraphQLCondition];
-    not: GraphQLCondition;
-}>;
-export declare type GraphQLFilter = Partial<GraphQLField | {
-    and: GraphQLFilter[];
-} | {
-    or: GraphQLFilter[];
-} | {
-    not: GraphQLFilter;
-}>;
-export declare type ProducerPaginationInput<T extends PersistentModel> = {
-    sort?: ProducerSortPredicate<T>;
-    limit?: number;
-    page?: number;
-};
-export declare type ObserveQueryOptions<T extends PersistentModel> = Pick<ProducerPaginationInput<T>, 'sort'>;
-export declare type PaginationInput<T extends PersistentModel> = {
-    sort?: SortPredicate<T>;
-    limit?: number;
-    page?: number;
-};
-export declare type ProducerSortPredicate<M extends PersistentModel> = (condition: SortPredicate<M>) => SortPredicate<M>;
-export declare type SortPredicate<T extends PersistentModel> = {
-    [K in keyof T]-?: SortPredicateExpression<T, NonNullable<T[K]>>;
-};
-export declare type SortPredicateExpression<M extends PersistentModel, FT> = TypeName<FT> extends keyof MapTypeToOperands<FT> ? (sortDirection: keyof typeof SortDirection) => SortPredicate<M> : never;
-export declare enum SortDirection {
-    ASCENDING = "ASCENDING",
-    DESCENDING = "DESCENDING"
-}
-export declare type SortPredicatesGroup<T extends PersistentModel> = SortPredicateObject<T>[];
-export declare type SortPredicateObject<T extends PersistentModel> = {
-    field: keyof T;
-    sortDirection: keyof typeof SortDirection;
-};
-export declare type SystemComponent = {
-    setUp(schema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any>, appId: string): Promise<void>;
-};
-export declare type NamespaceResolver = (modelConstructor: PersistentModelConstructor<any>) => string;
-export declare type ControlMessageType<T> = {
-    type: T;
-    data?: any;
-};
-export declare type RelationType = {
-    fieldName: string;
-    modelName: string;
-    relationType: 'HAS_ONE' | 'HAS_MANY' | 'BELONGS_TO';
-    targetName?: string;
-    associatedWith?: string;
-};
-export declare type RelationshipType = {
-    [modelName: string]: {
-        indexes: string[];
-        relationTypes: RelationType[];
-    };
-};
-export declare type KeyType = {
-    primaryKey?: string[];
-    compositeKeys?: Set<string>[];
-};
-export declare type ModelKeys = {
-    [modelName: string]: KeyType;
-};
-export declare type DataStoreConfig = {
-    DataStore?: {
-        authModeStrategyType?: AuthModeStrategyType;
-        conflictHandler?: ConflictHandler;
-        errorHandler?: (error: SyncError<PersistentModel>) => void;
-        maxRecordsToSync?: number;
-        syncPageSize?: number;
-        fullSyncInterval?: number;
-        syncExpressions?: SyncExpression[];
-        authProviders?: AuthProviders;
-        storageAdapter?: Adapter;
-    };
-    authModeStrategyType?: AuthModeStrategyType;
-    conflictHandler?: ConflictHandler;
-    errorHandler?: (error: SyncError<PersistentModel>) => void;
-    maxRecordsToSync?: number;
-    syncPageSize?: number;
-    fullSyncInterval?: number;
-    syncExpressions?: SyncExpression[];
-    authProviders?: AuthProviders;
-    storageAdapter?: Adapter;
-};
-export declare type AuthProviders = {
-    functionAuthProvider: () => {
-        token: string;
-    } | Promise<{
-        token: string;
-    }>;
-};
-export declare enum AuthModeStrategyType {
-    DEFAULT = "DEFAULT",
-    MULTI_AUTH = "MULTI_AUTH"
-}
-export declare type AuthModeStrategyReturn = GRAPHQL_AUTH_MODE | GRAPHQL_AUTH_MODE[] | undefined | null;
-export declare type AuthModeStrategyParams = {
-    schema: InternalSchema;
-    modelName: string;
-    operation: ModelOperation;
-};
-export declare type AuthModeStrategy = (authModeStrategyParams: AuthModeStrategyParams) => AuthModeStrategyReturn | Promise<AuthModeStrategyReturn>;
-export declare enum ModelOperation {
-    CREATE = "CREATE",
-    READ = "READ",
-    UPDATE = "UPDATE",
-    DELETE = "DELETE"
-}
-export declare type ModelAuthModes = Record<string, {
-    [Property in ModelOperation]: GRAPHQL_AUTH_MODE[];
-}>;
-export declare type SyncExpression = Promise<{
-    modelConstructor: any;
-    conditionProducer: (c?: any) => any;
-}>;
-declare type Option0 = [];
-declare type Option1<T extends PersistentModel> = [ModelPredicate<T> | undefined];
-declare type Option<T extends PersistentModel> = Option0 | Option1<T>;
-declare type Lookup<T extends PersistentModel> = {
-    0: ProducerModelPredicate<T> | Promise<ProducerModelPredicate<T>> | typeof PredicateAll;
-    1: ModelPredicate<T> | undefined;
-};
-declare type ConditionProducer<T extends PersistentModel, A extends Option<T>> = (...args: A) => A['length'] extends keyof Lookup<T> ? Lookup<T>[A['length']] : never;
-export declare function syncExpression<T extends PersistentModel, A extends Option<T>>(modelConstructor: PersistentModelConstructor<T>, conditionProducer: ConditionProducer<T, A>): Promise<{
-    modelConstructor: PersistentModelConstructor<T>;
-    conditionProducer: ConditionProducer<T, A>;
-}>;
-export declare type SyncConflict = {
-    modelConstructor: PersistentModelConstructor<any>;
-    localModel: PersistentModel;
-    remoteModel: PersistentModel;
-    operation: OpType;
-    attempts: number;
-};
-export declare type SyncError<T extends PersistentModel> = {
-    message: string;
-    errorType: ErrorType;
-    errorInfo?: string;
-    recoverySuggestion?: string;
-    model?: string;
-    localModel: T;
-    remoteModel: T;
-    process: ProcessName;
-    operation: string;
-    cause?: Error;
-};
-export declare type ErrorType = 'ConfigError' | 'BadModel' | 'BadRecord' | 'Unauthorized' | 'Transient' | 'Unknown';
-export declare enum ProcessName {
-    'sync' = "sync",
-    'mutate' = "mutate",
-    'subscribe' = "subscribe"
-}
-export declare const DISCARD: unique symbol;
-export declare type ConflictHandler = (conflict: SyncConflict) => Promise<PersistentModel | typeof DISCARD> | PersistentModel | typeof DISCARD;
-export declare type ErrorHandler = (error: SyncError<PersistentModel>) => void;
-export declare type DeferredCallbackResolverOptions = {
-    callback: () => void;
-    maxInterval?: number;
-    errorHandler?: (error: string) => void;
-};
-export declare enum LimitTimerRaceResolvedValues {
-    LIMIT = "LIMIT",
-    TIMER = "TIMER"
-}
-export declare type AmplifyContext = {
-    Auth: typeof Auth;
-    API: typeof API;
-    Cache: typeof Cache;
-};
-export {};

package/lib/util.d.ts

@@ -1,113 +0,0 @@
-import { ULID } from 'ulid';
-import { Patch } from 'immer';
-import { ModelInstanceMetadata, PersistentModel, PersistentModelConstructor, PredicateObject, PredicatesGroup, RelationshipType, RelationType, ModelKeys, ModelAttributes, SchemaNamespace, SortPredicatesGroup, NonModelTypeConstructor, DeferredCallbackResolverOptions } from './types';
-export declare enum NAMESPACES {
-    DATASTORE = "datastore",
-    USER = "user",
-    SYNC = "sync",
-    STORAGE = "storage"
-}
-declare const DATASTORE = NAMESPACES.DATASTORE;
-declare const USER = NAMESPACES.USER;
-declare const SYNC = NAMESPACES.SYNC;
-declare const STORAGE = NAMESPACES.STORAGE;
-export { USER, SYNC, STORAGE, DATASTORE };
-export declare const USER_AGENT_SUFFIX_DATASTORE = "/DataStore";
-export declare const exhaustiveCheck: (obj: never, throwOnError?: boolean) => void;
-export declare const isNullOrUndefined: (val: any) => boolean;
-export declare const validatePredicate: <T extends Readonly<{
-    id: string;
-} & Record<string, any>>>(model: T, groupType: "and" | "or" | "not", predicatesOrGroups: (PredicateObject<T> | PredicatesGroup<T>)[]) => any;
-export declare const validatePredicateField: <T>(value: T, operator: "ne" | "eq" | "le" | "lt" | "ge" | "gt" | "between" | "beginsWith" | "contains" | "notContains", operand: T | [T, T]) => boolean;
-export declare const isModelConstructor: <T extends Readonly<{
-    id: string;
-} & Record<string, any>>>(obj: any) => obj is PersistentModelConstructor<T, {
-    readOnlyFields: "createdAt" | "updatedAt";
-}>;
-export declare function registerNonModelClass(clazz: NonModelTypeConstructor<any>): void;
-export declare const isNonModelConstructor: (obj: any) => obj is NonModelTypeConstructor<any>;
-export declare const processCompositeKeys: (attributes: ModelAttributes) => Set<string>[];
-export declare const establishRelationAndKeys: (namespace: SchemaNamespace) => [RelationshipType, ModelKeys];
-export declare const traverseModel: <T extends Readonly<{
-    id: string;
-} & Record<string, any>>>(srcModelName: string, instance: T, namespace: SchemaNamespace, modelInstanceCreator: <T_1 extends Readonly<{
-    id: string;
-} & Record<string, any>> = Readonly<{
-    id: string;
-} & Record<string, any>>>(modelConstructor: PersistentModelConstructor<T_1, {
-    readOnlyFields: "createdAt" | "updatedAt";
-}>, init: Pick<T_1, Exclude<keyof T_1, "id" | "createdAt" | "updatedAt">> & Partial<ModelInstanceMetadata>) => T_1, getModelConstructorByModelName: (namsespaceName: string, modelName: string) => PersistentModelConstructor<any, {
-    readOnlyFields: "createdAt" | "updatedAt";
-}>) => {
-    modelName: string;
-    item: T;
-    instance: T;
-}[];
-export declare const getIndex: (rel: RelationType[], src: string) => string;
-export declare const getIndexFromAssociation: (indexes: string[], src: string) => string;
-export declare const isPrivateMode: () => Promise<unknown>;
-export declare function monotonicUlidFactory(seed?: number): ULID;
-/**
- * Uses performance.now() if available, otherwise, uses Date.now() (e.g. react native without a polyfill)
- *
- * The values returned by performance.now() always increase at a constant rate,
- * independent of the system clock (which might be adjusted manually or skewed
- * by software like NTP).
- *
- * Otherwise, performance.timing.navigationStart + performance.now() will be
- * approximately equal to Date.now()
- *
- * See: https://developer.mozilla.org/en-US/docs/Web/API/Performance/now#Example
- */
-export declare function getNow(): number;
-export declare function sortCompareFunction<T extends PersistentModel>(sortPredicates: SortPredicatesGroup<T>): (a: any, b: any) => number;
-export declare function valuesEqual(valA: any, valB: any, nullish?: boolean): boolean;
-export declare const isAWSDate: (val: string) => boolean;
-export declare const isAWSTime: (val: string) => boolean;
-export declare const isAWSDateTime: (val: string) => boolean;
-export declare const isAWSTimestamp: (val: number) => boolean;
-export declare const isAWSEmail: (val: string) => boolean;
-export declare const isAWSJSON: (val: string) => boolean;
-export declare const isAWSURL: (val: string) => boolean;
-export declare const isAWSPhone: (val: string) => boolean;
-export declare const isAWSIPAddress: (val: string) => boolean;
-export declare class DeferredPromise {
-    promise: Promise<string>;
-    resolve: (value: string | PromiseLike<string>) => void;
-    reject: () => void;
-    constructor();
-}
-export declare class DeferredCallbackResolver {
-    private limitPromise;
-    private timerPromise;
-    private maxInterval;
-    private timer;
-    private raceInFlight;
-    private callback;
-    private errorHandler;
-    private defaultErrorHandler;
-    constructor(options: DeferredCallbackResolverOptions);
-    private startTimer;
-    private racePromises;
-    start(): void;
-    clear(): void;
-    resolve(): void;
-}
-/**
- * merge two sets of patches created by immer produce.
- * newPatches take precedent over oldPatches for patches modifying the same path.
- * In the case many consecutive pathces are merged the original model should
- * always be the root model.
- *
- * Example:
- * A -> B, patches1
- * B -> C, patches2
- *
- * mergePatches(A, patches1, patches2) to get patches for A -> C
- *
- * @param originalSource the original Model the patches should be applied to
- * @param oldPatches immer produce patch list
- * @param newPatches immer produce patch list (will take precedence)
- * @return merged patches
- */
-export declare function mergePatches<T>(originalSource: T, oldPatches: Patch[], newPatches: Patch[]): Patch[];

package/webpack.config.dev.js

@@ -1,6 +0,0 @@
-var config = require('./webpack.config.js');
-
-var entry = {
-	'aws-amplify-datastore': './lib-esm/index.js',
-};
-module.exports = Object.assign(config, { entry, mode: 'development' });