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

package/src/types.ts

@@ -1,27 +1,28 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { InternalAPI } from '@aws-amplify/api/internals';
+import { GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
+
 import { ModelInstanceCreator } from './datastore/datastore';
 import {
+	NAMESPACES,
+	extractPrimaryKeyFieldNames,
 	isAWSDate,
-	isAWSTime,
 	isAWSDateTime,
-	isAWSTimestamp,
 	isAWSEmail,
+	isAWSIPAddress,
 	isAWSJSON,
-	isAWSURL,
 	isAWSPhone,
-	isAWSIPAddress,
-	NAMESPACES,
-	extractPrimaryKeyFieldNames,
+	isAWSTime,
+	isAWSTimestamp,
+	isAWSURL,
 } 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;
 
-//#region Schema types
+// #region Schema types
 /**
  * @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
@@ -34,25 +35,25 @@ export type DataStoreSchema = UserSchema & {
 	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;
@@ -68,10 +69,10 @@ export type SchemaModel = {
 	allFields?: ModelFields;
 
 	syncable?: boolean;
-};
+}
 
 export function isSchemaModel(obj: any): obj is SchemaModel {
-	return obj && (<SchemaModel>obj).pluralName !== undefined;
+	return obj && (obj as SchemaModel).pluralName !== undefined;
 }
 
 export function isSchemaModelWithAttributes(
@@ -81,37 +82,37 @@ export function isSchemaModelWithAttributes(
 }
 
 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 function isAssociatedWith(obj: any): obj is AssociatedWith {
 	return obj && obj.associatedWith;
 }
 
-type TargetNameAssociation = {
+interface TargetNameAssociation {
 	connectionType: 'BELONGS_TO';
 	targetName?: string;
 	targetNames?: string[];
-};
+}
 
 export function isTargetNameAssociation(
 	obj: any,
@@ -119,9 +120,9 @@ export function isTargetNameAssociation(
 	return obj?.targetName || obj?.targetNames;
 }
 
-type FieldAssociation = {
+interface FieldAssociation {
 	connectionType: 'HAS_ONE' | 'BELONGS_TO' | 'HAS_MANY';
-};
+}
 export function isFieldAssociation(
 	obj: any,
 	fieldName: string,
@@ -130,9 +131,12 @@ export function isFieldAssociation(
 }
 
 export type ModelAttributes = ModelAttribute[];
-export type ModelAttribute = { type: string; properties?: Record<string, any> };
+export interface ModelAttribute {
+	type: string;
+	properties?: Record<string, any>;
+}
 
-export type ModelAuthRule = {
+export interface ModelAuthRule {
 	allow: string;
 	provider?: string;
 	operations?: string[];
@@ -141,14 +145,14 @@ export type ModelAuthRule = {
 	groups?: string[];
 	groupClaim?: string;
 	groupsField?: string;
-};
+}
 
-export type ModelAttributeAuth = {
+export interface ModelAttributeAuth {
 	type: 'auth';
 	properties: {
 		rules: ModelAuthRule[];
 	};
-};
+}
 
 export function isModelAttributeAuth(
 	attr: ModelAttribute,
@@ -161,29 +165,29 @@ export function isModelAttributeAuth(
 	);
 }
 
-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 function isModelAttributeKey(
 	attr: ModelAttribute,
@@ -212,7 +216,7 @@ export function isModelAttributeCompositeKey(
 	);
 }
 
-export type ModelAttributeAuthProperty = {
+export interface ModelAttributeAuthProperty {
 	allow: ModelAttributeAuthAllow;
 	identityClaim?: string;
 	groupClaim?: string;
@@ -220,7 +224,7 @@ export type ModelAttributeAuthProperty = {
 	operations?: string[];
 	ownerField?: string;
 	provider?: ModelAttributeAuthProvider;
-};
+}
 
 export enum ModelAttributeAuthAllow {
 	CUSTOM = 'custom',
@@ -256,6 +260,7 @@ export enum GraphQLScalarType {
 	AWSIPAddress,
 }
 
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace GraphQLScalarType {
 	export function getJSType(
 		scalar: keyof Omit<
@@ -318,7 +323,7 @@ export namespace GraphQLScalarType {
 	}
 }
 
-export type AuthorizationRule = {
+export interface AuthorizationRule {
 	identityClaim: string;
 	ownerField: string;
 	provider: 'userPools' | 'oidc' | 'iam' | 'apiKey';
@@ -327,7 +332,7 @@ export type AuthorizationRule = {
 	groupsField: string;
 	authStrategy: 'owner' | 'groups' | 'private' | 'public';
 	areSubscriptionsPublic: boolean;
-};
+}
 
 export function isGraphQLScalarType(
 	obj: any,
@@ -338,11 +343,11 @@ export function isGraphQLScalarType(
 	return obj && GraphQLScalarType[obj] !== undefined;
 }
 
-export type ModelFieldType = {
+export interface ModelFieldType {
 	model: string;
 	modelConstructor?: ModelMeta<PersistentModel>;
-};
-export function isModelFieldType<T extends PersistentModel>(
+}
+export function isModelFieldType<_ extends PersistentModel>(
 	obj: any,
 ): obj is ModelFieldType {
 	const modelField: keyof ModelFieldType = 'model';
@@ -351,7 +356,9 @@ export function isModelFieldType<T extends PersistentModel>(
 	return false;
 }
 
-export type NonModelFieldType = { nonModel: string };
+export interface NonModelFieldType {
+	nonModel: string;
+}
 export function isNonModelFieldType(obj: any): obj is NonModelFieldType {
 	const typeField: keyof NonModelFieldType = 'nonModel';
 	if (obj && obj[typeField]) return true;
@@ -359,7 +366,9 @@ export function isNonModelFieldType(obj: any): obj is NonModelFieldType {
 	return false;
 }
 
-type EnumFieldType = { enum: string };
+interface EnumFieldType {
+	enum: string;
+}
 export function isEnumFieldType(obj: any): obj is EnumFieldType {
 	const modelField: keyof EnumFieldType = 'enum';
 	if (obj && obj[modelField]) return true;
@@ -367,7 +376,7 @@ export function isEnumFieldType(obj: any): obj is EnumFieldType {
 	return false;
 }
 
-export type ModelField = {
+export interface ModelField {
 	name: string;
 	type:
 		| keyof Omit<
@@ -383,22 +392,20 @@ export type ModelField = {
 	isArrayNullable?: boolean;
 	association?: ModelAssociation;
 	attributes?: ModelAttributes[];
-};
-//#endregion
+}
+// #endregion
 
-//#region Model definition
-export type NonModelTypeConstructor<T> = {
-	new (init: T): T;
-};
+// #region Model definition
+export type NonModelTypeConstructor<T> = new (init: T) => T;
 
 // Class for model
-export type PersistentModelConstructor<T extends PersistentModel> = {
+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
@@ -443,7 +450,7 @@ export type OptionallyManagedIdentifier<T, F extends keyof T> = IdentifierBrand<
 >;
 
 // You provide the values
-export type CompositeIdentifier<T, K extends Array<keyof T>> = IdentifierBrand<
+export type CompositeIdentifier<T, K extends (keyof T)[]> = IdentifierBrand<
 	{ fields: K; type: T },
 	'CompositeIdentifier'
 >;
@@ -494,10 +501,10 @@ export type IdentifierFieldsForInit<
 // Instance of model
 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 }): Promise<T[]>;
@@ -538,19 +545,11 @@ type OptionalRelativesOf<T> =
 
 type OmitOptionalRelatives<T> = Omit<T, OptionalRelativesOf<T>>;
 type PickOptionalRelatives<T> = Pick<T, OptionalRelativesOf<T>>;
-type OmitOptionalFields<T> = Omit<
-	T,
-	KeysOfSuperType<T, undefined> | OptionalRelativesOf<T>
->;
-type PickOptionalFields<T> = Pick<
-	T,
-	KeysOfSuperType<T, undefined> | OptionalRelativesOf<T>
->;
 
-export type DefaultPersistentModelMetaData = {
+export interface DefaultPersistentModelMetaData {
 	identifier: ManagedIdentifier<{ id: string }, 'id'>;
 	readOnlyFields: never;
-};
+}
 
 export type MetadataOrDefault<
 	T extends PersistentModel,
@@ -578,6 +577,7 @@ export type MetadataReadOnlyFields<
 // This type makes optional some identifiers in the constructor init object (e.g. OptionallyManagedIdentifier)
 export type ModelInitBase<
 	T extends PersistentModel,
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	M extends PersistentModelMetaData<T> = {},
 > = Omit<
 	T,
@@ -592,6 +592,7 @@ export type ModelInitBase<
 
 export type ModelInit<
 	T extends PersistentModel,
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	M extends PersistentModelMetaData<T> = {},
 > = {
 	[P in keyof OmitOptionalRelatives<ModelInitBase<T, M>>]: SettableFieldType<
@@ -617,6 +618,7 @@ type DeepWritable<T> = {
 
 export type MutableModel<
 	T extends PersistentModel,
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	M extends PersistentModelMetaData<T> = {},
 	// This provides Intellisense with ALL of the properties, regardless of read-only
 	// but will throw a linting error if trying to overwrite a read-only property
@@ -625,11 +627,11 @@ export type MutableModel<
 > &
 	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,
@@ -656,9 +658,9 @@ export function isIdentifierObject<T extends PersistentModel>(
 		typeof obj === 'object' && obj && keys.every(k => obj[k] !== undefined)
 	);
 }
-//#endregion
+// #endregion
 
-//#region Subscription messages
+// #region Subscription messages
 export enum OpType {
 	INSERT = 'INSERT',
 	UPDATE = 'UPDATE',
@@ -670,21 +672,21 @@ export type SubscriptionMessage<T extends PersistentModel> = Pick<
 	'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;
-};
-//#endregion
+}
+// #endregion
 
-//#region Predicates
+// #region Predicates
 
 export type PredicateExpression<M extends PersistentModel, FT> =
 	TypeName<FT> extends keyof MapTypeToOperands<FT>
@@ -695,10 +697,10 @@ export type PredicateExpression<M extends PersistentModel, FT> =
 			) => ModelPredicate<M>
 		: never;
 
-type EqualityOperators<T> = {
+interface EqualityOperators<T> {
 	ne: T;
 	eq: T;
-};
+}
 type ScalarNumberOperators<T> = EqualityOperators<T> & {
 	le: T;
 	lt: T;
@@ -714,22 +716,22 @@ 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'
@@ -745,17 +747,17 @@ type TypeName<T> = T extends string
 						? 'boolean[]'
 						: never;
 
-export type PredicateGroups<T extends PersistentModel> = {
-	and: (
+export interface PredicateGroups<T extends PersistentModel> {
+	and(
 		predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>,
-	) => ModelPredicate<T>;
-	or: (
+	): ModelPredicate<T>;
+	or(
 		predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>,
-	) => ModelPredicate<T>;
-	not: (
+	): ModelPredicate<T>;
+	not(
 		predicate: (predicate: ModelPredicate<T>) => ModelPredicate<T>,
-	) => ModelPredicate<T>;
-};
+	): ModelPredicate<T>;
+}
 
 export type ModelPredicate<M extends PersistentModel> = {
 	[K in keyof M]-?: PredicateExpression<M, NonNullable<M[K]>>;
@@ -765,38 +767,37 @@ 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 function isPredicateObj<T extends PersistentModel>(
 	obj: any,
 ): obj is PredicateObject<T> {
-	return obj && (<PredicateObject<T>>obj).field !== undefined;
+	return obj && (obj as PredicateObject<T>).field !== undefined;
 }
 
 export function isPredicateGroup<T extends PersistentModel>(
 	obj: any,
 ): obj is PredicatesGroup<T> {
-	return obj && (<PredicatesGroup<T>>obj).type !== undefined;
+	return obj && (obj as PredicatesGroup<T>).type !== undefined;
 }
 
-export type PredicateObject<T extends PersistentModel> = {
+export interface PredicateObject<T extends PersistentModel> {
 	field: keyof T;
 	operator: keyof AllOperators;
 	operand: any;
-};
+}
 
 export enum QueryOne {
 	FIRST,
 	LAST,
 }
-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
@@ -820,26 +821,26 @@ export type GraphQLFilter = Partial<
 	  }
 >;
 
-//#endregion
+// #endregion
 
-//#region Pagination
+// #region Pagination
 
-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>,
@@ -862,16 +863,16 @@ export enum SortDirection {
 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;
-};
+}
 
-//#endregion
+// #endregion
 
-//#region System Components
+// #region System Components
 
-export type SystemComponent = {
+export interface SystemComponent {
 	setUp(
 		schema: InternalSchema,
 		namespaceResolver: NamespaceResolver,
@@ -882,62 +883,61 @@ export type SystemComponent = {
 		) => 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;
-};
+}
 
-//#endregion
+// #endregion
 
-//#region Relationship types
-export type RelationType = {
+// #region Relationship types
+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 IndexesType = [string, string[], IndexOptions?][];
 
-export type RelationshipType = {
-	[modelName: string]: {
+export type RelationshipType = Record<
+	string,
+	{
 		indexes: IndexesType;
 		relationTypes: RelationType[];
-	};
-};
+	}
+>;
 
-//#endregion
+// #endregion
 
-//#region Key type
-export type KeyType = {
+// #region Key type
+export interface KeyType {
 	primaryKey?: string[];
 	compositeKeys?: Set<string>[];
-};
+}
 
-export type ModelKeys = {
-	[modelName: string]: KeyType;
-};
+export type ModelKeys = Record<string, KeyType>;
 
-//#endregion
+// #endregion
 
-//#region DataStore config types
-export type DataStoreConfig = {
+// #region DataStore config types
+export interface DataStoreConfig {
 	DataStore?: {
 		authModeStrategyType?: AuthModeStrategyType;
 		conflictHandler?: ConflictHandler; // default : retry until client wins up to x times
-		errorHandler?: (error: SyncError<PersistentModel>) => void; // default : logger.warn
+		errorHandler?(error: SyncError<PersistentModel>): void; // default : logger.warn
 		maxRecordsToSync?: number; // merge
 		syncPageSize?: number;
 		fullSyncInterval?: number;
@@ -947,18 +947,18 @@ export type DataStoreConfig = {
 	};
 	authModeStrategyType?: AuthModeStrategyType;
 	conflictHandler?: ConflictHandler; // default : retry until client wins up to x times
-	errorHandler?: (error: SyncError<PersistentModel>) => void; // default : logger.warn
+	errorHandler?(error: SyncError<PersistentModel>): void; // default : logger.warn
 	maxRecordsToSync?: number; // merge
 	syncPageSize?: number;
 	fullSyncInterval?: number;
 	syncExpressions?: SyncExpression[];
 	authProviders?: AuthProviders;
 	storageAdapter?: Adapter;
-};
+}
 
-export type AuthProviders = {
-	functionAuthProvider: () => { token: string } | Promise<{ token: string }>;
-};
+export interface AuthProviders {
+	functionAuthProvider(): { token: string } | Promise<{ token: string }>;
+}
 
 export enum AuthModeStrategyType {
 	DEFAULT = 'DEFAULT',
@@ -971,11 +971,11 @@ export type AuthModeStrategyReturn =
 	| undefined
 	| null;
 
-export type AuthModeStrategyParams = {
+export interface AuthModeStrategyParams {
 	schema: InternalSchema;
 	modelName: string;
 	operation: ModelOperation;
-};
+}
 
 export type AuthModeStrategy = (
 	authModeStrategyParams: AuthModeStrategyParams,
@@ -997,7 +997,7 @@ export type ModelAuthModes = Record<
 
 export type SyncExpression = Promise<{
 	modelConstructor: any;
-	conditionProducer: (c?: any) => any;
+	conditionProducer(c?: any): any;
 }>;
 
 /*
@@ -1019,14 +1019,14 @@ 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
@@ -1048,15 +1048,15 @@ export async function syncExpression<
 	};
 }
 
-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;
@@ -1067,7 +1067,7 @@ export type SyncError<T extends PersistentModel> = {
 	process: ProcessName;
 	operation: string;
 	cause?: Error;
-};
+}
 
 export type ErrorType =
 	| 'ConfigError'
@@ -1093,21 +1093,21 @@ export type ConflictHandler = (
 	| 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 enum LimitTimerRaceResolvedValues {
 	LIMIT = 'LIMIT',
 	TIMER = 'TIMER',
 }
-//#endregion
+// #endregion
 
-export type AmplifyContext = {
+export interface AmplifyContext {
 	InternalAPI: typeof InternalAPI;
-};
+}
 
 // #region V5 predicate types
 
@@ -1206,7 +1206,7 @@ export type ModelPredicateAggregateExtender<RT extends PersistentModel> = (
 ) => PredicateInternalsKey[];
 
 export type ValuePredicate<
-	RT extends PersistentModel,
+	_RT extends PersistentModel,
 	MT extends MatchableTypes,
 > = {
 	[K in AllFieldOperators]: K extends 'between'
@@ -1240,7 +1240,7 @@ export type ModelPredicateNegation<RT extends PersistentModel> = (
  * that should not be exposed on public customer interfaces.
  */
 export class PredicateInternalsKey {
-	private __isPredicateInternalsKeySentinel: boolean = true;
+	private __isPredicateInternalsKeySentinel = true;
 }
 
 // #endregion