@aws-amplify/datastore 5.0.32 → 5.0.33-s-auth.30d0cd2.0

package/dist/esm/types.d.ts

@@ -1,10 +1,10 @@
+import { InternalAPI } from '@aws-amplify/api/internals';
+import { GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
 import { ModelInstanceCreator } from './datastore/datastore';
 import { NAMESPACES } from './util';
 import { PredicateAll } from './predicates';
-import { InternalAPI } from '@aws-amplify/api/internals';
 import { Adapter } from './storage/adapter';
-import { GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
-export type Scalar<T> = T extends Array<infer InnerType> ? InnerType : T;
+export type Scalar<T> = T extends (infer InnerType)[] ? InnerType : T;
 /**
  * @deprecated If you intended to use the Schema for `generateClient`, then you've imported the wrong Schema type.
  * Use `import { type Schema } from '../amplify/data/resource' instead. If you intended to import the type for DataStore
@@ -15,25 +15,25 @@ export type DataStoreSchema = UserSchema & {
     version: string;
     codegenVersion: string;
 };
-export type UserSchema = {
+export interface UserSchema {
     models: SchemaModels;
     nonModels?: SchemaNonModels;
     relationships?: RelationshipType;
     keys?: ModelKeys;
     enums: SchemaEnums;
     modelTopologicalOrdering?: Map<string, string[]>;
-};
-export type InternalSchema = {
+}
+export interface InternalSchema {
     namespaces: SchemaNamespaces;
     version: string;
     codegenVersion: string;
-};
+}
 export type SchemaNamespaces = Record<string, SchemaNamespace>;
 export type SchemaNamespace = UserSchema & {
     name: string;
 };
 export type SchemaModels = Record<string, SchemaModel>;
-export type SchemaModel = {
+export interface SchemaModel {
     name: string;
     pluralName: string;
     attributes?: ModelAttributes;
@@ -46,48 +46,48 @@ export type SchemaModel = {
      */
     allFields?: ModelFields;
     syncable?: boolean;
-};
+}
 export declare function isSchemaModel(obj: any): obj is SchemaModel;
 export declare function isSchemaModelWithAttributes(m: SchemaModel | SchemaNonModel): m is SchemaModel;
 export type SchemaNonModels = Record<string, SchemaNonModel>;
-export type SchemaNonModel = {
+export interface SchemaNonModel {
     name: string;
     fields: ModelFields;
-};
+}
 type SchemaEnums = Record<string, SchemaEnum>;
-type SchemaEnum = {
+interface SchemaEnum {
     name: string;
     values: string[];
-};
-export type ModelMeta<T extends PersistentModel> = {
+}
+export interface ModelMeta<T extends PersistentModel> {
     builder: PersistentModelConstructor<T>;
     schema: SchemaModel;
     pkField: string[];
-};
+}
 export type ModelAssociation = AssociatedWith | TargetNameAssociation;
-type AssociatedWith = {
+interface AssociatedWith {
     connectionType: 'HAS_MANY' | 'HAS_ONE';
     associatedWith: string | string[];
     targetName?: string;
     targetNames?: string[];
-};
+}
 export declare function isAssociatedWith(obj: any): obj is AssociatedWith;
-type TargetNameAssociation = {
+interface TargetNameAssociation {
     connectionType: 'BELONGS_TO';
     targetName?: string;
     targetNames?: string[];
-};
+}
 export declare function isTargetNameAssociation(obj: any): obj is TargetNameAssociation;
-type FieldAssociation = {
+interface FieldAssociation {
     connectionType: 'HAS_ONE' | 'BELONGS_TO' | 'HAS_MANY';
-};
+}
 export declare function isFieldAssociation(obj: any, fieldName: string): obj is FieldAssociation;
 export type ModelAttributes = ModelAttribute[];
-export type ModelAttribute = {
+export interface ModelAttribute {
     type: string;
     properties?: Record<string, any>;
-};
-export type ModelAuthRule = {
+}
+export interface ModelAuthRule {
     allow: string;
     provider?: string;
     operations?: string[];
@@ -96,39 +96,39 @@ export type ModelAuthRule = {
     groups?: string[];
     groupClaim?: string;
     groupsField?: string;
-};
-export type ModelAttributeAuth = {
+}
+export interface ModelAttributeAuth {
     type: 'auth';
     properties: {
         rules: ModelAuthRule[];
     };
-};
+}
 export declare function isModelAttributeAuth(attr: ModelAttribute): attr is ModelAttributeAuth;
-type ModelAttributeKey = {
+interface ModelAttributeKey {
     type: 'key';
     properties: {
         name?: string;
         fields: string[];
     };
-};
-type ModelAttributePrimaryKey = {
+}
+interface ModelAttributePrimaryKey {
     type: 'key';
     properties: {
         name: never;
         fields: string[];
     };
-};
-type ModelAttributeCompositeKey = {
+}
+interface 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 type ModelAttributeAuthProperty = {
+export interface ModelAttributeAuthProperty {
     allow: ModelAttributeAuthAllow;
     identityClaim?: string;
     groupClaim?: string;
@@ -136,7 +136,7 @@ export type ModelAttributeAuthProperty = {
     operations?: string[];
     ownerField?: string;
     provider?: ModelAttributeAuthProvider;
-};
+}
 export declare enum ModelAttributeAuthAllow {
     CUSTOM = "custom",
     OWNER = "owner",
@@ -172,7 +172,7 @@ 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) => boolean) | ((val: number) => boolean) | undefined;
 }
-export type AuthorizationRule = {
+export interface AuthorizationRule {
     identityClaim: string;
     ownerField: string;
     provider: 'userPools' | 'oidc' | 'iam' | 'apiKey';
@@ -181,22 +181,22 @@ export type AuthorizationRule = {
     groupsField: string;
     authStrategy: 'owner' | 'groups' | 'private' | 'public';
     areSubscriptionsPublic: boolean;
-};
+}
 export declare function isGraphQLScalarType(obj: any): obj is keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'>;
-export type ModelFieldType = {
+export interface ModelFieldType {
     model: string;
     modelConstructor?: ModelMeta<PersistentModel>;
-};
-export declare function isModelFieldType<T extends PersistentModel>(obj: any): obj is ModelFieldType;
-export type NonModelFieldType = {
+}
+export declare function isModelFieldType<_ extends PersistentModel>(obj: any): obj is ModelFieldType;
+export interface NonModelFieldType {
     nonModel: string;
-};
+}
 export declare function isNonModelFieldType(obj: any): obj is NonModelFieldType;
-type EnumFieldType = {
+interface EnumFieldType {
     enum: string;
-};
+}
 export declare function isEnumFieldType(obj: any): obj is EnumFieldType;
-export type ModelField = {
+export interface ModelField {
     name: string;
     type: keyof Omit<typeof GraphQLScalarType, 'getJSType' | 'getValidationFunction'> | ModelFieldType | NonModelFieldType | EnumFieldType;
     isArray: boolean;
@@ -205,14 +205,12 @@ export type ModelField = {
     isArrayNullable?: boolean;
     association?: ModelAssociation;
     attributes?: ModelAttributes[];
-};
-export type NonModelTypeConstructor<T> = {
-    new (init: T): T;
-};
-export type PersistentModelConstructor<T extends PersistentModel> = {
+}
+export type NonModelTypeConstructor<T> = new (init: T) => T;
+export interface PersistentModelConstructor<T extends PersistentModel> {
     new (init: ModelInit<T, PersistentModelMetaData<T>>): T;
     copyOf(src: T, mutator: (draft: MutableModel<T, PersistentModelMetaData<T>>) => void): T;
-};
+}
 /**
  * @private
  * Internal use of Amplify only.
@@ -247,7 +245,7 @@ export type OptionallyManagedIdentifier<T, F extends keyof T> = IdentifierBrand<
     field: F extends string ? F : never;
     type: T;
 }, 'OptionallyManagedIdentifier'>;
-export type CompositeIdentifier<T, K extends Array<keyof T>> = IdentifierBrand<{
+export type CompositeIdentifier<T, K extends (keyof T)[]> = IdentifierBrand<{
     fields: K;
     type: T;
 }, 'CompositeIdentifier'>;
@@ -258,10 +256,10 @@ export type Identifier<T> = ManagedIdentifier<T, any> | OptionallyManagedIdentif
 export type IdentifierFields<T extends PersistentModel, M extends PersistentModelMetaData<T> = never> = (MetadataOrDefault<T, M>['identifier'] extends ManagedIdentifier<any, any> | OptionallyManagedIdentifier<any, any> ? MetadataOrDefault<T, M>['identifier']['field'] : MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<T, infer B> ? B[number] : MetadataOrDefault<T, M>['identifier']['field']) & string;
 export type IdentifierFieldsForInit<T extends PersistentModel, M extends PersistentModelMetaData<T>> = MetadataOrDefault<T, M>['identifier'] extends DefaultPersistentModelMetaData | ManagedIdentifier<T, any> ? never : MetadataOrDefault<T, M>['identifier'] extends OptionallyManagedIdentifier<T, any> ? IdentifierFields<T, M> : MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<T, any> ? IdentifierFields<T, M> : never;
 export declare const __modelMeta__: unique symbol;
-export type PersistentModelMetaData<T> = {
+export interface PersistentModelMetaData<T> {
     identifier?: Identifier<T>;
     readOnlyFields?: string;
-};
+}
 export interface AsyncCollection<T> extends AsyncIterable<T> {
     toArray(options?: {
         max?: number;
@@ -278,12 +276,12 @@ type KeysOfSuperType<T, FilterType> = {
 type OptionalRelativesOf<T> = KeysOfType<T, AsyncCollection<any>> | KeysOfSuperType<T, Promise<undefined>>;
 type OmitOptionalRelatives<T> = Omit<T, OptionalRelativesOf<T>>;
 type PickOptionalRelatives<T> = Pick<T, OptionalRelativesOf<T>>;
-export type DefaultPersistentModelMetaData = {
+export interface DefaultPersistentModelMetaData {
     identifier: ManagedIdentifier<{
         id: string;
     }, 'id'>;
     readOnlyFields: never;
-};
+}
 export type MetadataOrDefault<T extends PersistentModel, _ extends PersistentModelMetaData<T> = never> = T extends {
     [__modelMeta__]: PersistentModelMetaData<T>;
 } ? T[typeof __modelMeta__] : DefaultPersistentModelMetaData;
@@ -299,11 +297,11 @@ type DeepWritable<T> = {
     -readonly [P in keyof T]: T[P] extends TypeName<T[P]> ? T[P] : T[P] extends Promise<infer InnerPromiseType> ? undefined extends InnerPromiseType ? InnerPromiseType | null : InnerPromiseType : T[P] extends AsyncCollection<infer InnerCollectionType> ? InnerCollectionType[] | undefined | null : DeepWritable<T[P]>;
 };
 export type MutableModel<T extends PersistentModel, M extends PersistentModelMetaData<T> = {}> = DeepWritable<Omit<T, IdentifierFields<T, M> | MetadataReadOnlyFields<T, M>>> & Readonly<Pick<T, IdentifierFields<T, M> | MetadataReadOnlyFields<T, M>>>;
-export type ModelInstanceMetadata = {
+export interface ModelInstanceMetadata {
     _version: number;
     _lastChangedAt: number;
     _deleted: boolean;
-};
+}
 export type IdentifierFieldValue<T extends PersistentModel, M extends PersistentModelMetaData<T>> = MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<T, any> ? MetadataOrDefault<T, M>['identifier']['fields'] extends [any] ? T[MetadataOrDefault<T, M>['identifier']['fields'][0]] : never : T[MetadataOrDefault<T, M>['identifier']['field']];
 export type IdentifierFieldOrIdentifierObject<T extends PersistentModel, M extends PersistentModelMetaData<T>> = Pick<T, IdentifierFields<T, M>> | IdentifierFieldValue<T, M>;
 export declare function isIdentifierObject<T extends PersistentModel>(obj: any, modelDefinition: SchemaModel): obj is IdentifierFields<T extends PersistentModel ? T : never, any>;
@@ -313,22 +311,22 @@ export declare enum OpType {
     DELETE = "DELETE"
 }
 export type SubscriptionMessage<T extends PersistentModel> = Pick<InternalSubscriptionMessage<T>, 'opType' | 'element' | 'model' | 'condition'>;
-export type InternalSubscriptionMessage<T extends PersistentModel> = {
+export interface InternalSubscriptionMessage<T extends PersistentModel> {
     opType: OpType;
     element: T;
     model: PersistentModelConstructor<T>;
     condition: PredicatesGroup<T> | null;
     savedElement?: T;
-};
-export type DataStoreSnapshot<T extends PersistentModel> = {
+}
+export interface DataStoreSnapshot<T extends PersistentModel> {
     items: T[];
     isSynced: boolean;
-};
+}
 export 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;
-type EqualityOperators<T> = {
+interface EqualityOperators<T> {
     ne: T;
     eq: T;
-};
+}
 type ScalarNumberOperators<T> = EqualityOperators<T> & {
     le: T;
     lt: T;
@@ -344,49 +342,45 @@ type StringOperators<T> = ScalarNumberOperators<T> & {
     notContains: T;
 };
 type BooleanOperators<T> = EqualityOperators<T>;
-type ArrayOperators<T> = {
+interface ArrayOperators<T> {
     contains: T;
     notContains: T;
-};
+}
 export type AllOperators = NumberOperators<any> & StringOperators<any> & ArrayOperators<any>;
-type MapTypeToOperands<T> = {
+interface MapTypeToOperands<T> {
     number: NumberOperators<NonNullable<T>>;
     string: StringOperators<NonNullable<T>>;
     boolean: BooleanOperators<NonNullable<T>>;
     'number[]': ArrayOperators<number>;
     'string[]': ArrayOperators<string>;
     'boolean[]': ArrayOperators<boolean>;
-};
+}
 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 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 interface 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 type ModelPredicate<M extends PersistentModel> = {
     [K in keyof M]-?: PredicateExpression<M, NonNullable<M[K]>>;
 } & PredicateGroups<M>;
 export type ProducerModelPredicate<M extends PersistentModel> = (condition: ModelPredicate<M>) => ModelPredicate<M>;
-export type PredicatesGroup<T extends PersistentModel> = {
+export interface 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 type PredicateObject<T extends PersistentModel> = {
+export interface PredicateObject<T extends PersistentModel> {
     field: keyof T;
     operator: keyof AllOperators;
     operand: any;
-};
+}
 export declare enum QueryOne {
     FIRST = 0,
     LAST = 1
 }
-export type GraphQLField = {
-    [field: string]: {
-        [operator: string]: string | number | [number, number];
-    };
-};
+export type GraphQLField = Record<string, Record<string, string | number | [number, number]>>;
 export type GraphQLCondition = Partial<GraphQLField | {
     and: [GraphQLCondition];
     or: [GraphQLCondition];
@@ -399,17 +393,17 @@ export type GraphQLFilter = Partial<GraphQLField | {
 } | {
     not: GraphQLFilter;
 }>;
-export type ProducerPaginationInput<T extends PersistentModel> = {
+export interface ProducerPaginationInput<T extends PersistentModel> {
     sort?: ProducerSortPredicate<T>;
     limit?: number;
     page?: number;
-};
+}
 export type ObserveQueryOptions<T extends PersistentModel> = Pick<ProducerPaginationInput<T>, 'sort'>;
-export type PaginationInput<T extends PersistentModel> = {
+export interface PaginationInput<T extends PersistentModel> {
     sort?: SortPredicate<T>;
     limit?: number;
     page?: number;
-};
+}
 export type ProducerSortPredicate<M extends PersistentModel> = (condition: SortPredicate<M>) => SortPredicate<M>;
 export type SortPredicate<T extends PersistentModel> = {
     [K in keyof T]-?: SortPredicateExpression<T, NonNullable<T[K]>>;
@@ -420,48 +414,44 @@ export declare enum SortDirection {
     DESCENDING = "DESCENDING"
 }
 export type SortPredicatesGroup<T extends PersistentModel> = SortPredicateObject<T>[];
-export type SortPredicateObject<T extends PersistentModel> = {
+export interface SortPredicateObject<T extends PersistentModel> {
     field: keyof T;
     sortDirection: keyof typeof SortDirection;
-};
-export type SystemComponent = {
+}
+export interface SystemComponent {
     setUp(schema: InternalSchema, namespaceResolver: NamespaceResolver, modelInstanceCreator: ModelInstanceCreator, getModelConstructorByModelName: (namsespaceName: NAMESPACES, modelName: string) => PersistentModelConstructor<any>, appId?: string): Promise<void>;
-};
+}
 export type NamespaceResolver = (modelConstructor: PersistentModelConstructor<any>) => string;
-export type ControlMessageType<T> = {
+export interface ControlMessageType<T> {
     type: T;
     data?: any;
-};
-export type RelationType = {
+}
+export interface RelationType {
     fieldName: string;
     modelName: string;
     relationType: 'HAS_ONE' | 'HAS_MANY' | 'BELONGS_TO';
     targetName?: string;
     targetNames?: string[];
     associatedWith?: string | string[];
-};
-type IndexOptions = {
+}
+interface IndexOptions {
     unique?: boolean;
-};
-export type IndexesType = Array<[string, string[], IndexOptions?]>;
-export type RelationshipType = {
-    [modelName: string]: {
-        indexes: IndexesType;
-        relationTypes: RelationType[];
-    };
-};
-export type KeyType = {
+}
+export type IndexesType = [string, string[], IndexOptions?][];
+export type RelationshipType = Record<string, {
+    indexes: IndexesType;
+    relationTypes: RelationType[];
+}>;
+export interface KeyType {
     primaryKey?: string[];
     compositeKeys?: Set<string>[];
-};
-export type ModelKeys = {
-    [modelName: string]: KeyType;
-};
-export type DataStoreConfig = {
+}
+export type ModelKeys = Record<string, KeyType>;
+export interface DataStoreConfig {
     DataStore?: {
         authModeStrategyType?: AuthModeStrategyType;
         conflictHandler?: ConflictHandler;
-        errorHandler?: (error: SyncError<PersistentModel>) => void;
+        errorHandler?(error: SyncError<PersistentModel>): void;
         maxRecordsToSync?: number;
         syncPageSize?: number;
         fullSyncInterval?: number;
@@ -471,31 +461,31 @@ export type DataStoreConfig = {
     };
     authModeStrategyType?: AuthModeStrategyType;
     conflictHandler?: ConflictHandler;
-    errorHandler?: (error: SyncError<PersistentModel>) => void;
+    errorHandler?(error: SyncError<PersistentModel>): void;
     maxRecordsToSync?: number;
     syncPageSize?: number;
     fullSyncInterval?: number;
     syncExpressions?: SyncExpression[];
     authProviders?: AuthProviders;
     storageAdapter?: Adapter;
-};
-export type AuthProviders = {
-    functionAuthProvider: () => {
+}
+export interface AuthProviders {
+    functionAuthProvider(): {
         token: string;
     } | Promise<{
         token: string;
     }>;
-};
+}
 export declare enum AuthModeStrategyType {
     DEFAULT = "DEFAULT",
     MULTI_AUTH = "MULTI_AUTH"
 }
 export type AuthModeStrategyReturn = GraphQLAuthMode | GraphQLAuthMode[] | undefined | null;
-export type AuthModeStrategyParams = {
+export interface AuthModeStrategyParams {
     schema: InternalSchema;
     modelName: string;
     operation: ModelOperation;
-};
+}
 export type AuthModeStrategy = (authModeStrategyParams: AuthModeStrategyParams) => AuthModeStrategyReturn | Promise<AuthModeStrategyReturn>;
 export declare enum ModelOperation {
     CREATE = "CREATE",
@@ -508,28 +498,28 @@ export type ModelAuthModes = Record<string, {
 }>;
 export type SyncExpression = Promise<{
     modelConstructor: any;
-    conditionProducer: (c?: any) => any;
+    conditionProducer(c?: any): any;
 }>;
 type Option0 = [];
 type Option1<T extends PersistentModel> = [V5ModelPredicate<T> | undefined];
 type Option<T extends PersistentModel> = Option0 | Option1<T>;
-type Lookup<T extends PersistentModel> = {
+interface Lookup<T extends PersistentModel> {
     0: ModelPredicateExtender<T> | Promise<ModelPredicateExtender<T>> | typeof PredicateAll | Promise<typeof PredicateAll | symbol>;
     1: PredicateInternalsKey | undefined;
-};
+}
 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 type SyncConflict = {
+export interface SyncConflict {
     modelConstructor: PersistentModelConstructor<any>;
     localModel: PersistentModel;
     remoteModel: PersistentModel;
     operation: OpType;
     attempts: number;
-};
-export type SyncError<T extends PersistentModel> = {
+}
+export interface SyncError<T extends PersistentModel> {
     message: string;
     errorType: ErrorType;
     errorInfo?: string;
@@ -540,7 +530,7 @@ export type SyncError<T extends PersistentModel> = {
     process: ProcessName;
     operation: string;
     cause?: Error;
-};
+}
 export type ErrorType = 'ConfigError' | 'BadModel' | 'BadRecord' | 'Unauthorized' | 'Transient' | 'Unknown';
 export declare enum ProcessName {
     'sync' = "sync",
@@ -550,18 +540,18 @@ export declare enum ProcessName {
 export declare const DISCARD: unique symbol;
 export type ConflictHandler = (conflict: SyncConflict) => Promise<PersistentModel | typeof DISCARD> | PersistentModel | typeof DISCARD;
 export type ErrorHandler = (error: SyncError<PersistentModel>) => void;
-export type DeferredCallbackResolverOptions = {
-    callback: () => void;
+export interface DeferredCallbackResolverOptions {
+    callback(): void;
     maxInterval?: number;
-    errorHandler?: (error: string) => void;
-};
+    errorHandler?(error: string): void;
+}
 export declare enum LimitTimerRaceResolvedValues {
     LIMIT = "LIMIT",
     TIMER = "TIMER"
 }
-export type AmplifyContext = {
+export interface AmplifyContext {
     InternalAPI: typeof InternalAPI;
-};
+}
 export type MatchableTypes = string | string[] | number | number[] | boolean | boolean[];
 export type AllFieldOperators = keyof AllOperators;
 export type NonNeverKeys<T> = {
@@ -625,7 +615,7 @@ export type RecursiveModelPredicate<RT extends PersistentModel> = {
  */
 export type ModelPredicateExtender<RT extends PersistentModel> = (lambda: V5ModelPredicate<RT>) => PredicateInternalsKey;
 export type ModelPredicateAggregateExtender<RT extends PersistentModel> = (lambda: V5ModelPredicate<RT>) => PredicateInternalsKey[];
-export type ValuePredicate<RT extends PersistentModel, MT extends MatchableTypes> = {
+export type ValuePredicate<_RT extends PersistentModel, MT extends MatchableTypes> = {
     [K in AllFieldOperators]: K extends 'between' ? (inclusiveLowerBound: Scalar<MT>, inclusiveUpperBound: Scalar<MT>) => PredicateInternalsKey : (operand: Scalar<MT>) => PredicateInternalsKey;
 };
 export type V5ModelPredicate<RT extends PersistentModel> = WithoutNevers<{

package/dist/esm/types.mjs

@@ -68,6 +68,7 @@ var GraphQLScalarType;
     GraphQLScalarType[GraphQLScalarType["AWSPhone"] = 12] = "AWSPhone";
     GraphQLScalarType[GraphQLScalarType["AWSIPAddress"] = 13] = "AWSIPAddress";
 })(GraphQLScalarType || (GraphQLScalarType = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
 (function (GraphQLScalarType) {
     function getJSType(scalar) {
         switch (scalar) {
@@ -145,8 +146,8 @@ function isIdentifierObject(obj, modelDefinition) {
     const keys = extractPrimaryKeyFieldNames(modelDefinition);
     return (typeof obj === 'object' && obj && keys.every(k => obj[k] !== undefined));
 }
-//#endregion
-//#region Subscription messages
+// #endregion
+// #region Subscription messages
 var OpType;
 (function (OpType) {
     OpType["INSERT"] = "INSERT";