@aws-amplify/data-schema 1.2.8 → 1.3.0

package/dist/esm/runtime/client/index.d.ts

@@ -1,6 +1,8 @@
-import { DeepReadOnlyObject, UnwrapArray, UnionToIntersection, Prettify, Equal, ExtractModelMeta, IsEmptyStringOrNever } from '@aws-amplify/data-schema-types';
+import { type DeepReadOnlyObject, type UnwrapArray, type UnionToIntersection, type Prettify } from '@aws-amplify/data-schema-types';
 import type { Observable } from 'rxjs';
-import { deferredRefResolvingPrefix } from '../../ModelType';
+import type { ClientSchemaByEntityType, ClientSchemaByEntityTypeBaseShape } from '../../ClientSchema';
+import type { ExtractNestedTypes } from '../../ClientSchema/utilities/';
+import type { Select, StringFilter, NumericFilter, BooleanFilters } from '../../util';
 export { __modelMeta__, ExtractModelMeta, } from '@aws-amplify/data-schema-types';
 type Model = Record<string, any>;
 /**
@@ -9,12 +11,15 @@ type Model = Record<string, any>;
 type NonRelationalFields<M extends Model> = {
     [Field in keyof M as UnwrapArray<M[Field]> extends Record<string, unknown> ? never : Field]: M[Field];
 };
+type WithOptionalsAsNullishOnly<T> = T extends Array<infer ArrayType> ? Array<WithOptionalsAsNullishOnly<ArrayType>> : T extends (...args: any) => any ? T : T extends object ? {
+    [K in keyof T]-?: WithOptionalsAsNullishOnly<T[K]>;
+} : Exclude<T, undefined>;
 /**
  * Selection set-aware CRUDL operation return value type
  *
- * @returns model type as-is with default selection set; otherwise generates return type from custonm sel. set
+ * @returns model type with default selection set; otherwise generates return type from custom sel. set. Optionality is removed from both return types.
  */
-type ReturnValue<M extends Model, FlatModel extends Model, Paths extends ReadonlyArray<ModelPath<FlatModel>>> = Paths extends undefined | never[] ? M : CustomSelectionSetReturnValue<FlatModel, Paths[number]>;
+type ReturnValue<M extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Model, Paths extends ReadonlyArray<ModelPath<FlatModel>>> = Paths extends undefined | never[] ? WithOptionalsAsNullishOnly<M['type']> : WithOptionalsAsNullishOnly<CustomSelectionSetReturnValue<FlatModel, Paths[number]>>;
 /**
  * This mapped type traverses the SelectionSetReturnValue result and the original FlatModel, restoring array types
  * that were flattened in DeepPickFromPath
@@ -154,34 +159,13 @@ RecursionLoop extends number[] = [-1, 0, 1, 2, 3, 4], Field = keyof FlatModel> =
  *
  * ```
  */
-export type ResolvedModel<Model extends Record<string, unknown>, Depth extends number = 7, RecursionLoop extends number[] = [-1, 0, 1, 2, 3, 4, 5, 6]> = {
+type ResolvedModel<Model extends Record<string, unknown>, Depth extends number = 7, RecursionLoop extends number[] = [-1, 0, 1, 2, 3, 4, 5, 6]> = {
     done: NonRelationalFields<Model>;
     recur: {
         [Field in keyof Model]: Model[Field] extends (...args: any) => ListReturnValue<infer M> ? NonNullable<M> extends Record<string, any> ? ResolvedModel<NonNullable<M>, RecursionLoop[Depth]>[] : never : Model[Field] extends (...args: any) => SingularReturnValue<infer M> ? NonNullable<M> extends Record<string, any> ? ResolvedModel<NonNullable<M>, RecursionLoop[Depth]> : never : Model[Field];
     };
 }[Depth extends -1 ? 'done' : 'recur'];
-export type SelectionSet<Model extends Record<string, unknown>, Path extends ReadonlyArray<ModelPath<FlatModel>>, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = CustomSelectionSetReturnValue<FlatModel, Path[number]>;
-export type ModelIdentifier<ModelMeta extends ModelMetaShape> = ModelMeta['identifier']['pk'] & (ModelMeta['identifier']['sk'] extends never ? unknown : ModelMeta['identifier']['sk']);
-type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
-type WritableKeys<T> = {
-    [P in keyof T]-?: IfEquals<{
-        [Q in P]: T[P];
-    }, {
-        -readonly [Q in P]: T[P];
-    }, P>;
-}[keyof T];
-/**
- * All required fields and relational fields, exclude readonly fields
- */
-type MutationInput<Fields, WritableFields = Pick<Fields, WritableKeys<Fields>>> = {
-    [Prop in keyof WritableFields as WritableFields[Prop] extends (...args: any) => any ? never : Prop]: WritableFields[Prop];
-};
-/**
- * All identifiers and fields used to create a model
- */
-type CreateModelInput<Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape> = Equal<ModelIdentifier<ModelMeta>, {
-    id: string;
-}> extends true ? Partial<ModelIdentifier<ModelMeta>> & Omit<MutationInput<Model>, 'id'> : MutationInput<Model>;
+export type SelectionSet<Model extends Record<string, unknown>, Path extends ReadonlyArray<ModelPath<FlatModel>>, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = WithOptionalsAsNullishOnly<CustomSelectionSetReturnValue<FlatModel, Path[number]>>;
 /**
  * See: https://spec.graphql.org/draft/#sec-Errors
  */
@@ -251,7 +235,7 @@ export type ObserveQueryReturnValue<T> = Observable<{
     items: T[];
     isSynced: boolean;
 }>;
-export type LazyLoader<Model, IsArray extends boolean> = (options?: IsArray extends true ? {
+export type LazyLoader<T, IsArray extends boolean> = (options?: IsArray extends true ? {
     authMode?: AuthMode;
     authToken?: string;
     limit?: number;
@@ -261,138 +245,59 @@ export type LazyLoader<Model, IsArray extends boolean> = (options?: IsArray exte
     authMode?: AuthMode;
     authToken?: string;
     headers?: CustomHeaders;
-}) => IsArray extends true ? ListReturnValue<Prettify<NonNullable<Model>>> : SingularReturnValue<Prettify<Model>>;
+}) => IsArray extends true ? ListReturnValue<Prettify<NonNullable<T>>> : SingularReturnValue<Prettify<T>>;
 export type AuthMode = 'apiKey' | 'iam' | 'identityPool' | 'oidc' | 'userPool' | 'lambda' | 'none';
-type LogicalFilters<Model extends Record<any, any>> = {
+type LogicalFilters<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = {
     and?: ModelFilter<Model> | ModelFilter<Model>[];
     or?: ModelFilter<Model> | ModelFilter<Model>[];
     not?: ModelFilter<Model>;
 };
-/**
- * Filter options that can be used on fields where size checks are supported.
- */
-type SizeFilter = {
-    between?: [number, number];
-    eq?: number;
-    ge?: number;
-    gt?: number;
-    le?: number;
-    lt?: number;
-    ne?: number;
-};
-/**
- * Not actually sure if/how customer can pass this through as variables yet.
- * Leaving it out for now:
- *
- * attributeType: "binary" | "binarySet" | "bool" | "list" | "map" | "number" | "numberSet" | "string" | "stringSet" | "_null"
- */
-/**
- * Filters options that can be used on string-like fields.
- */
-export type StringFilter<T extends string = string> = {
-    attributeExists?: boolean;
-    beginsWith?: string;
-    between?: [string, string];
-    contains?: string;
-    eq?: T;
-    ge?: string;
-    gt?: string;
-    le?: string;
-    lt?: string;
-    ne?: T;
-    notContains?: string;
-    size?: SizeFilter;
-};
-export type NumericFilter = {
-    attributeExists?: boolean;
-    between?: [number, number];
-    eq?: number;
-    ge?: number;
-    gt?: number;
-    le?: number;
-    lt?: number;
-    ne?: number;
-};
-type BooleanFilters = {
-    attributeExists?: boolean;
-    eq?: boolean;
-    ne?: boolean;
-};
-/**
- * A composite SK (in an identifier or secondaryIndex) resolves to this type for
- * list queries and index queries
- *
- * @example
- * Given
- * ```ts
- * MyModel: a
-  .model({
-    pk: a.string().required(),
-    sk1: a.string().required(),
-    sk2: a.integer().required(),
-  })
-  .identifier(['pk', 'sk1', 'sk2']),
- * ```
- * Expected list options:
- * ```ts
- * {
- *   pk?: string
- *   sk1Sk2?: ModelPrimaryCompositeKeyConditionInput
- * }
- * ```
- * Where ModelPrimaryCompositeKeyConditionInput resolves to:
- * ```ts
- * {
- *   eq: {sk1: string; sk2: number};
- *   le: {sk1: string; sk2: number};
- *   lt: {sk1: string; sk2: number};
- *   ge: {sk1: string; sk2: number};
- *   gt: {sk1: string; sk2: number};
- *   between: [ {sk1: string; sk2: number} ];
- *   beginsWith: {sk1: string; sk2: number};
- * }
- * ```
- * */
-export type ModelPrimaryCompositeKeyInput<SkIr extends Record<string, string | number>> = {
-    eq?: SkIr;
-    le?: SkIr;
-    lt?: SkIr;
-    ge?: SkIr;
-    gt?: SkIr;
-    between?: [SkIr];
-    beginsWith?: SkIr;
-};
-type ModelFilter<Model extends Record<any, any>> = LogicalFilters<Model> & {
-    [K in keyof Model as Model[K] extends LazyLoader<any, any> ? never : K]?: boolean extends Model[K] ? BooleanFilters : number extends Model[K] ? NumericFilter : StringFilter;
+type ModelFilter<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = LogicalFilters<Model> & {
+    [K in keyof Model['type'] as Model['type'][K] extends LazyLoader<any, any> ? never : K]?: boolean extends Model['type'][K] ? BooleanFilters : number extends Model['type'][K] ? NumericFilter : StringFilter;
 };
 export type ModelSortDirection = 'ASC' | 'DESC';
-type ModelMetaShape = {
-    secondaryIndexes: SecondaryIndexIrShape[];
-    identifier: PrimaryIndexIrShape;
+type ListCpkOptions<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = unknown extends Model['__meta']['listOptionsPkParams'] ? unknown : Model['__meta']['listOptionsPkParams'] & {
+    sortDirection?: ModelSortDirection;
 };
-export type ModelTypesClient<ModelName extends string, Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, Enums extends Record<string, string>, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model, Enums> & {
-    create: (model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+interface ClientSecondaryIndexField {
+    input: object;
+}
+type IndexQueryMethods<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = {
+    [K in keyof Select<Model['secondaryIndexes'], ClientSecondaryIndexField>]: IndexQueryMethod<Model, Select<Model['secondaryIndexes'], ClientSecondaryIndexField>[K]>;
+};
+type IndexQueryMethod<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], Method extends ClientSecondaryIndexField, FlatModel extends Record<string, unknown> = ResolvedModel<Model['type']>> = <SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(input: Method['input'], options?: {
+    filter?: ModelFilter<Model>;
+    sortDirection?: ModelSortDirection;
+    limit?: number;
+    nextToken?: string | null;
+    selectionSet?: SelectionSet;
+    authMode?: AuthMode;
+    authToken?: string;
+    headers?: CustomHeaders;
+}) => ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+type ModelTypesClient<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Record<string, unknown> = ResolvedModel<Model['type']>> = IndexQueryMethods<Model> & {
+    create: (model: Model['createType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
-    }) => SingularReturnValue<Model>;
-    update: (model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+    }) => SingularReturnValue<Model['type']>;
+    update: (model: Model['updateType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
-    }) => SingularReturnValue<Model>;
-    delete: (identifier: ModelIdentifier<ModelMeta>, options?: {
+    }) => SingularReturnValue<Model['type']>;
+    delete: (identifier: Model['deleteType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
-    }) => SingularReturnValue<Model>;
-    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: ModelIdentifier<ModelMeta>, options?: {
+    }) => SingularReturnValue<Model['type']>;
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: Model['identifier'], options?: {
         selectionSet?: SelectionSet;
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
-    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: ListPkOptions<ModelMeta, Enums> & {
+    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: ListCpkOptions<Model> & {
         filter?: ModelFilter<Model>;
         limit?: number;
         nextToken?: string | null;
@@ -429,29 +334,29 @@ export type ModelTypesClient<ModelName extends string, Model extends Record<stri
         authToken?: string;
     }): ObserveQueryReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
 };
-type ModelTypesSSRCookies<ModelName extends string, Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, Enums extends Record<string, string>, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model, Enums> & {
-    create: (model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+type ModelTypesSSRCookies<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Record<string, unknown> = ResolvedModel<Model['type']>> = IndexQueryMethods<Model> & {
+    create: (model: Model['createType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    update: (model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+    update: (model: Model['updateType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    delete: (identifier: ModelIdentifier<ModelMeta>, options?: {
+    delete: (identifier: Model['deleteType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: ModelIdentifier<ModelMeta>, options?: {
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: Model['identifier'], options?: {
         selectionSet?: SelectionSet;
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
-    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: ListPkOptions<ModelMeta, Enums> & {
+    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: ListCpkOptions<Model> & {
         filter?: ModelFilter<Model>;
         sortDirection?: ModelSortDirection;
         limit?: number;
@@ -462,29 +367,29 @@ type ModelTypesSSRCookies<ModelName extends string, Model extends Record<string,
         headers?: CustomHeaders;
     }): ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
 };
-type ModelTypesSSRRequest<ModelName extends string, Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, Enums extends Record<string, string>, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model, Enums> & {
-    create: (contextSpec: any, model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+type ModelTypesSSRRequest<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Record<string, unknown> = ResolvedModel<Model['type']>> = IndexQueryMethods<Model> & {
+    create: (contextSpec: any, model: Model['createType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    update: (contextSpec: any, model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+    update: (contextSpec: any, model: Model['updateType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    delete: (contextSpec: any, identifier: ModelIdentifier<ModelMeta>, options?: {
+    delete: (contextSpec: any, identifier: Model['deleteType'], options?: {
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }) => SingularReturnValue<Model>;
-    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: any, identifier: ModelIdentifier<ModelMeta>, options?: {
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: any, identifier: Model['identifier'], options?: {
         selectionSet?: SelectionSet;
         authMode?: AuthMode;
         authToken?: string;
         headers?: CustomHeaders;
     }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
-    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: any, options?: ListPkOptions<ModelMeta, Enums> & {
+    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: any, options?: ListCpkOptions<Model> & {
         filter?: ModelFilter<Model>;
         sortDirection?: ModelSortDirection;
         limit?: number;
@@ -496,12 +401,12 @@ type ModelTypesSSRRequest<ModelName extends string, Model extends Record<string,
     }): ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
 };
 type ContextType = 'CLIENT' | 'COOKIES' | 'REQUEST';
-export type ModelTypes<Schema extends Record<any, any>, Context extends ContextType = 'CLIENT', ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = {
-    [ModelName in Exclude<keyof Schema, keyof CustomOperations<Schema, 'Mutation' | 'Query' | 'Subscription', Context, ModelMeta>>]: ModelName extends string ? Schema[ModelName] extends Record<string, unknown> ? Context extends 'CLIENT' ? ModelTypesClient<ModelName, Schema[ModelName]['type'], ModelMeta[ModelName], ModelMeta['enums']> : Context extends 'COOKIES' ? ModelTypesSSRCookies<ModelName, Schema[ModelName]['type'], ModelMeta[ModelName], ModelMeta['enums']> : Context extends 'REQUEST' ? ModelTypesSSRRequest<ModelName, Schema[ModelName]['type'], ModelMeta[ModelName], ModelMeta['enums']> : never : never : never;
+export type ModelTypes<T extends Record<any, any>, Context extends ContextType = 'CLIENT', Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = {
+    [ModelName in keyof Schema['models']]: Context extends 'CLIENT' ? ModelTypesClient<Schema['models'][ModelName]> : Context extends 'COOKIES' ? ModelTypesSSRCookies<Schema['models'][ModelName]> : Context extends 'REQUEST' ? ModelTypesSSRRequest<Schema['models'][ModelName]> : never;
 };
-export type CustomQueries<Schema extends Record<any, any>, Context extends ContextType = 'CLIENT', ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = CustomOperations<Schema, 'Query', Context, ModelMeta>;
-export type CustomMutations<Schema extends Record<any, any>, Context extends ContextType = 'CLIENT', ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = CustomOperations<Schema, 'Mutation', Context, ModelMeta>;
-export type CustomSubscriptions<Schema extends Record<any, any>, Context extends ContextType = 'CLIENT', ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = CustomOperations<Schema, 'Subscription', Context, ModelMeta>;
+export type CustomQueries<T extends Record<any, any>, Context extends ContextType = 'CLIENT', Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = CustomOperations<Schema['queries'], Context>;
+export type CustomMutations<T extends Record<any, any>, Context extends ContextType = 'CLIENT', Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = CustomOperations<Schema['mutations'], Context>;
+export type CustomSubscriptions<T extends Record<any, any>, Context extends ContextType = 'CLIENT', Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = CustomOperations<Schema['subscriptions'], Context>;
 type CustomOperationMethodOptions = {
     authMode?: AuthMode;
     authToken?: string;
@@ -513,11 +418,11 @@ type CustomOperationMethodOptions = {
 type CustomOperationFnParams<Args extends Record<string, unknown> | never> = [
     Args
 ] extends [never] ? [CustomOperationMethodOptions?] : [Args, CustomOperationMethodOptions?];
-export type CustomOperations<Schema extends Record<any, any>, OperationType extends 'Query' | 'Mutation' | 'Subscription', Context extends ContextType = 'CLIENT', ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = {
-    [OpName in keyof ModelMeta['customOperations'] as ModelMeta['customOperations'][OpName]['typeName'] extends OperationType ? OpName : never]: {
-        CLIENT: (...params: CustomOperationFnParams<ModelMeta['customOperations'][OpName]['arguments']>) => ModelMeta['customOperations'][OpName]['typeName'] extends 'Subscription' ? ObservedReturnValue<ModelMeta['customOperations'][OpName]['returnType']> : SingularReturnValue<ModelMeta['customOperations'][OpName]['returnType']>;
-        COOKIES: (...params: CustomOperationFnParams<ModelMeta['customOperations'][OpName]['arguments']>) => SingularReturnValue<ModelMeta['customOperations'][OpName]['returnType']>;
-        REQUEST: (contextSpec: any, ...params: CustomOperationFnParams<ModelMeta['customOperations'][OpName]['arguments']>) => SingularReturnValue<ModelMeta['customOperations'][OpName]['returnType']>;
+export type CustomOperations<OperationDefs extends ClientSchemaByEntityTypeBaseShape['queries' | 'mutations' | 'subscriptions'], Context extends ContextType = 'CLIENT'> = {
+    [OpName in keyof OperationDefs]: {
+        CLIENT: (...params: CustomOperationFnParams<OperationDefs[OpName]['args']>) => OperationDefs[OpName]['operationType'] extends 'Subscription' ? ObservedReturnValue<OperationDefs[OpName]['type']> : SingularReturnValue<OperationDefs[OpName]['type']>;
+        COOKIES: (...params: CustomOperationFnParams<OperationDefs[OpName]['args']>) => SingularReturnValue<OperationDefs[OpName]['type']>;
+        REQUEST: (contextSpec: any, ...params: CustomOperationFnParams<OperationDefs[OpName]['args']>) => SingularReturnValue<OperationDefs[OpName]['type']>;
     }[Context];
 };
 /**
@@ -537,11 +442,14 @@ export type CustomOperations<Schema extends Record<any, any>, OperationType exte
  *   }
  * }
  */
-export type EnumTypes<Schema extends Record<any, any>, ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = {
-    [EnumName in keyof ModelMeta['enums']]: {
-        values: () => Array<ModelMeta['enums'][EnumName]>;
+export type EnumTypes<T extends Record<any, any>> = {
+    [EnumName in keyof AllEnumTypesRecursively<T>]: {
+        values: () => Array<AllEnumTypesRecursively<T>[EnumName]['type']>;
     };
 };
+type AllEnumTypesRecursively<T extends Record<any, any>> = ClientSchemaByEntityType<T>['enums'] & Select<ExtractNestedTypes<ClientSchemaByEntityType<T>>, {
+    __entityType: 'enum';
+}>;
 /**
  * Request options that are passed to custom header functions.
  * `method` and `headers` are not included in custom header functions passed to
@@ -558,76 +466,22 @@ export type RequestOptions = {
  * promise.
  */
 export type CustomHeaders = Record<string, string> | ((requestOptions?: RequestOptions) => Promise<Record<string, string>>);
-/**
- * PrimaryIndex field types and query methods
- */
-export interface PrimaryIndexIrShape {
-    pk: {
-        [key: string]: string | number;
-    };
-    sk: {
-        [key: string]: string | number;
-    } | never;
-    compositeSk: never | string;
-}
-/**
- * SecondaryIndex field types and query methods
- */
-export interface SecondaryIndexIrShape extends PrimaryIndexIrShape {
-    defaultQueryFieldSuffix: string;
-    queryField: string;
-}
-export type IndexQueryMethodsFromIR<SecondaryIdxTuple extends SecondaryIndexIrShape[], ModelName extends string, Model extends Record<string, unknown>, Enums extends Record<string, string>, Res = unknown> = SecondaryIdxTuple extends [
-    infer A extends SecondaryIndexIrShape,
-    ...infer B extends SecondaryIndexIrShape[]
-] ? IndexQueryMethodsFromIR<B, ModelName, Model, Enums, IndexQueryMethodSignature<A, ModelName, Model, Enums> & Res> : Res;
-export type ListPkOptions<ModelMeta extends ModelMetaShape, Enums extends Record<string, string>> = ModelMeta['identifier']['sk'] extends never ? unknown : Prettify<Partial<IndexQueryInput<ModelMeta['identifier'], Enums>> & {
-    sortDirection?: ModelSortDirection;
-}>;
-/**
- * Accepts a PrimaryIndexIr or SecondaryIndexIr and returns resolved parameters
- */
-export type IndexQueryInput<Idx extends PrimaryIndexIrShape, Enums extends Record<string, string>> = {
-    [PKField in keyof Idx['pk']]: Idx['pk'][PKField] extends `${deferredRefResolvingPrefix}${infer R}` ? Enums[R] : Idx['pk'][PKField];
-} & (Idx['compositeSk'] extends never ? {
-    [SKField in keyof Idx['sk']]+?: number extends Idx['sk'][SKField] ? NumericFilter : Idx['sk'][SKField] extends `${deferredRefResolvingPrefix}${infer R}` ? StringFilter<Enums[R]> : StringFilter<Idx['sk'][SKField] & string>;
-} : {
-    [CompositeSk in Idx['compositeSk']]+?: ModelPrimaryCompositeKeyInput<{
-        [SKField in keyof Idx['sk']]: Idx['sk'][SKField] extends `${deferredRefResolvingPrefix}${infer _R}` ? string : Idx['sk'][SKField];
-    }>;
-});
-type IndexQueryMethodSignature<Idx extends SecondaryIndexIrShape, ModelName extends string, Model extends Record<string, unknown>, Enums extends Record<string, string>> = Record<IsEmptyStringOrNever<Idx['queryField']> extends false ? Idx['queryField'] : `list${ModelName}By${Idx['defaultQueryFieldSuffix']}`, <FlatModel extends Record<string, unknown> = ResolvedModel<Model>, SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(input: IndexQueryInput<Idx, Enums>, options?: {
-    filter?: ModelFilter<Model>;
-    sortDirection?: ModelSortDirection;
-    limit?: number;
-    nextToken?: string | null;
-    selectionSet?: SelectionSet;
-    authMode?: AuthMode;
-    authToken?: string;
-    headers?: CustomHeaders;
-}) => ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>>;
-type FilteredKeys<T> = {
-    [P in keyof T]: T[P] extends never ? never : P;
-}[keyof T];
-type ExcludeNeverFields<O> = {
-    [K in FilteredKeys<O>]: O[K];
-};
-export type ClientExtensions<T extends Record<any, any> = never> = ExcludeNeverFields<{
+export type ClientExtensions<T extends Record<any, any> = never> = {
     models: ModelTypes<T, 'CLIENT'>;
     enums: EnumTypes<T>;
     queries: CustomQueries<T, 'CLIENT'>;
     mutations: CustomMutations<T, 'CLIENT'>;
     subscriptions: CustomSubscriptions<T, 'CLIENT'>;
-}>;
-export type ClientExtensionsSSRRequest<T extends Record<any, any> = never> = ExcludeNeverFields<{
+};
+export type ClientExtensionsSSRRequest<T extends Record<any, any> = never> = {
     models: ModelTypes<T, 'REQUEST'>;
     enums: EnumTypes<T>;
     queries: CustomQueries<T, 'REQUEST'>;
     mutations: CustomMutations<T, 'REQUEST'>;
-}>;
-export type ClientExtensionsSSRCookies<T extends Record<any, any> = never> = ExcludeNeverFields<{
+};
+export type ClientExtensionsSSRCookies<T extends Record<any, any> = never> = {
     models: ModelTypes<T, 'COOKIES'>;
     enums: EnumTypes<T>;
     queries: CustomQueries<T, 'COOKIES'>;
     mutations: CustomMutations<T, 'COOKIES'>;
-}>;
+};

package/dist/esm/runtime/internals/generateCustomOperationsProperty.d.ts

@@ -1,8 +1,15 @@
-import { CustomMutations, CustomQueries } from '../client';
+import { CustomMutations, CustomQueries, CustomSubscriptions } from '../client';
 import { BaseClient, ClientInternalsGetter, GraphQLProviderConfig } from '../bridge-types';
 type OpTypes = 'queries' | 'mutations' | 'subscriptions';
-export declare function generateCustomOperationsProperty<T extends Record<any, any>, OpType extends OpTypes>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], operationsType: OpType, getInternals: ClientInternalsGetter): OpType extends 'queries' ? CustomQueries<T> : CustomMutations<T>;
-export declare function generateCustomMutationsProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): CustomMutations<T>;
-export declare function generateCustomQueriesProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): CustomQueries<T>;
-export declare function generateCustomSubscriptionsProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): CustomMutations<T>;
+type CustomOpsProperty<T extends Record<any, any>, OpType extends OpTypes> = OpType extends 'queries' ? CustomQueries<T> : OpType extends 'mutations' ? CustomMutations<T> : OpType extends 'subscriptions' ? CustomSubscriptions<T> : never;
+export declare function generateCustomOperationsProperty<T extends Record<any, any>, OpType extends OpTypes>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], operationsType: OpType, getInternals: ClientInternalsGetter): CustomOpsProperty<T, OpType>;
+export declare function generateCustomMutationsProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): import("../client").CustomOperations<import("../../util").Select<T, {
+    __entityType: "customMutation";
+}>, "CLIENT">;
+export declare function generateCustomQueriesProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): import("../client").CustomOperations<import("../../util").Select<T, {
+    __entityType: "customQuery";
+}>, "CLIENT">;
+export declare function generateCustomSubscriptionsProperty<T extends Record<any, any>>(client: BaseClient, config: GraphQLProviderConfig['GraphQL'], getInternals: ClientInternalsGetter): import("../client").CustomOperations<import("../../util").Select<T, {
+    __entityType: "customSubscription";
+}>, "CLIENT">;
 export {};

package/dist/esm/util/Filters.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Not actually sure if/how customer can pass this through as variables yet.
+ * Leaving it out for now:
+ *
+ * attributeType: "binary" | "binarySet" | "bool" | "list" | "map" | "number" | "numberSet" | "string" | "stringSet" | "_null"
+ */
+/**
+ * Filters options that can be used on string-like fields.
+ */
+export type StringFilter<T extends string = string> = {
+    attributeExists?: boolean;
+    beginsWith?: string;
+    between?: [string, string];
+    contains?: string;
+    eq?: T;
+    ge?: string;
+    gt?: string;
+    le?: string;
+    lt?: string;
+    ne?: T;
+    notContains?: string;
+    size?: SizeFilter;
+};
+export type NumericFilter = {
+    attributeExists?: boolean;
+    between?: [number, number];
+    eq?: number;
+    ge?: number;
+    gt?: number;
+    le?: number;
+    lt?: number;
+    ne?: number;
+};
+/**
+ * Filter options that can be used on fields where size checks are supported.
+ */
+export type SizeFilter = {
+    between?: [number, number];
+    eq?: number;
+    ge?: number;
+    gt?: number;
+    le?: number;
+    lt?: number;
+    ne?: number;
+};
+export type BooleanFilters = {
+    attributeExists?: boolean;
+    eq?: boolean;
+    ne?: boolean;
+};
+/**
+ * A composite SK (in an identifier or secondaryIndex) resolves to this type for
+ * list queries and index queries
+ *
+ * @example
+ * Given
+ * ```ts
+ * MyModel: a
+  .model({
+    pk: a.string().required(),
+    sk1: a.string().required(),
+    sk2: a.integer().required(),
+  })
+  .identifier(['pk', 'sk1', 'sk2']),
+ * ```
+ * Expected list options:
+ * ```ts
+ * {
+ *   pk?: string
+ *   sk1Sk2?: ModelPrimaryCompositeKeyConditionInput
+ * }
+ * ```
+ * Where ModelPrimaryCompositeKeyConditionInput resolves to:
+ * ```ts
+ * {
+ *   eq: {sk1: string; sk2: number};
+ *   le: {sk1: string; sk2: number};
+ *   lt: {sk1: string; sk2: number};
+ *   ge: {sk1: string; sk2: number};
+ *   gt: {sk1: string; sk2: number};
+ *   between: [ {sk1: string; sk2: number} ];
+ *   beginsWith: {sk1: string; sk2: number};
+ * }
+ * ```
+ * */
+export type ModelPrimaryCompositeKeyInput<SkIr extends Record<string, string | number>> = {
+    eq?: SkIr;
+    le?: SkIr;
+    lt?: SkIr;
+    ge?: SkIr;
+    gt?: SkIr;
+    between?: [SkIr];
+    beginsWith?: SkIr;
+};

package/dist/esm/util/Filters.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Filters.mjs.map

package/dist/esm/util/Filters.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filters.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/util/IndexShapes.d.ts

@@ -0,0 +1,13 @@
+export interface PrimaryIndexIrShape {
+    pk: {
+        [key: string]: string | number;
+    };
+    sk: {
+        [key: string]: string | number;
+    } | never;
+    compositeSk: never | string;
+}
+export interface SecondaryIndexIrShape extends PrimaryIndexIrShape {
+    defaultQueryFieldSuffix: string;
+    queryField: string;
+}

package/dist/esm/util/IndexShapes.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IndexShapes.mjs.map

package/dist/esm/util/IndexShapes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexShapes.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/util/Select.d.ts

@@ -0,0 +1,3 @@
+export type Select<T, M> = {
+    [K in keyof T as T[K] extends M ? K : never]: T[K] extends M ? T[K] : never;
+};

package/dist/esm/util/Select.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Select.mjs.map

package/dist/esm/util/Select.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Select.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/util/index.d.ts

@@ -1,3 +1,6 @@
 export { Brand, brand, getBrand } from './Brand';
 export { IndexLimitUnion } from './IndexLimit';
 export { SpreadTuple } from './SpreadTuple';
+export { Select } from './Select';
+export type * from './Filters';
+export type * from './IndexShapes';