@aws-amplify/data-schema 0.15.0 → 0.16.0

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

@@ -0,0 +1,571 @@
+import { DeepReadOnlyObject, UnwrapArray, UnionToIntersection, Prettify, Equal, ExtractModelMeta } from '@aws-amplify/data-schema-types';
+import type { Observable } from 'rxjs';
+export { __modelMeta__, ExtractModelMeta, } from '@aws-amplify/data-schema-types';
+type Model = Record<string, any>;
+/**
+ * Currently this omits any object-type fields. Update this when we add custom types/enums.
+ */
+type NonRelationalFields<M extends Model> = {
+    [Field in keyof M as UnwrapArray<M[Field]> extends Record<string, unknown> ? never : Field]: M[Field];
+};
+/**
+ * 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
+ */
+type ReturnValue<M extends Model, FlatModel extends Model, Paths extends ReadonlyArray<ModelPath<FlatModel>>> = Paths extends undefined | never[] ? M : CustomSelectionSetReturnValue<FlatModel, Paths[number]>;
+/**
+ * This mapped type traverses the SelectionSetReturnValue result and the original FlatModel, restoring array types
+ * that were flattened in DeepPickFromPath
+ *
+ */
+type RestoreArrays<Result, FlatModel> = {
+    [K in keyof Result]: K extends keyof FlatModel ? FlatModel[K] extends Array<any> ? Array<RestoreArrays<Result[K], UnwrapArray<FlatModel[K]>>> : FlatModel[K] extends Record<string, any> ? RestoreArrays<Result[K], FlatModel[K]> : Result[K] : never;
+};
+/**
+ * Generates flattened, readonly return type using specified custom sel. set
+ */
+type CustomSelectionSetReturnValue<FlatModel extends Model, Paths extends string> = Prettify<DeepReadOnlyObject<RestoreArrays<UnionToIntersection<DeepPickFromPath<FlatModel, Paths>>, FlatModel>>>;
+/**
+ * Picks object properties that match provided dot-separated Path
+ *
+ * @typeParam FlatModel
+ * @typeParam Path - string union of dot-separated paths
+ *
+ * @returns union of object slices
+ *
+ * @example
+ * ### Given
+ * ```ts
+ * FlatModel = {
+    title: string;
+    description?: string | null;
+    comments: {
+        content: string;
+        readonly id: string;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    }[];
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  }
+
+  Path = 'title' | 'comments.id' | 'comments.content'
+ * ```
+ * ### Returns
+ * ```ts
+ * { title: string } | { comments: { id: string} } | { comments: { content: string} }
+ * ```
+ *
+ * @privateRemarks
+ *
+ * Intersections on arrays have unexpected behavior in TypeScript:
+ * see: https://github.com/microsoft/TypeScript/issues/41874 and https://github.com/microsoft/TypeScript/issues/39693
+ *
+ * To work around this limitation, DeepPickFromPath flattens Arrays of Models (e.g. { comments: { id: string}[] } => { comments: { id: string} })
+ * Arrays are then restored downstream in RestoreArrays
+ */
+type DeepPickFromPath<FlatModel extends Model, Path extends string> = FlatModel extends undefined ? DeepPickFromPath<NonNullable<FlatModel>, Path> | undefined : FlatModel extends null ? DeepPickFromPath<NonNullable<FlatModel>, Path> | null : FlatModel extends any[] ? DeepPickFromPath<UnwrapArray<FlatModel>, Path> : Path extends `${infer Head}.${infer Tail}` ? Head extends keyof FlatModel ? Tail extends '*' ? {
+    [k in Head]: NonRelationalFields<UnwrapArray<FlatModel[Head]>>;
+} : {
+    [k in Head]: DeepPickFromPath<FlatModel[Head], Tail>;
+} : never : Path extends keyof FlatModel ? {
+    [K in Path]: FlatModel[Path];
+} : never;
+/**
+ * Generates custom selection set type with up to 6 levels of nested fields
+ *
+ * @returns string[] where each string is a field in the model
+ * recurses over nested objects - such as relationships and custom types - generating a `field.*` type value to select all fields in that nested type,
+ * as well as a dot-delimited set of fields for fine-grained selection of particular fields in the nested type (see example below)
+ *
+ * @example
+ * ```ts
+ * FlatModel = {
+ *   id: string
+ *   title: string
+ *   comments: {
+ *     id:: string
+ *     content: string
+ *   }[]
+ * }
+ *```
+ *
+ * ### Result
+ * ```
+ * 'id' | 'title' | 'comments.*' | 'comments.id' | 'comments.content'
+ * ```
+ *
+ * @privateRemarks
+ *
+ * explicit recursion depth pattern ref: https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5
+ *
+ * this pattern puts an upper bound on the levels of recursion in our mapped type
+ *
+ * it guards against infinite recursion when generating the selection set type for deeply-nested models
+ * and especially for bi-directional relationships which are infinitely recursable by their nature
+ *
+ */
+export type ModelPath<FlatModel extends Record<string, unknown>, Depth extends number = 5, // think of this as the initialization expr. in a for loop (e.g. `let depth = 5`)
+RecursionLoop extends number[] = [-1, 0, 1, 2, 3, 4], Field = keyof FlatModel> = {
+    done: Field extends string ? `${Field}.*` : never;
+    recur: Field extends string ? NonNullable<UnwrapArray<FlatModel[Field]>> extends Record<string, unknown> ? `${Field}.${ModelPath<NonNullable<UnwrapArray<FlatModel[Field]>>, RecursionLoop[Depth]>}` | `${Field}.*` : `${Field}` : never;
+}[Depth extends -1 ? 'done' : 'recur'];
+/**
+ * Flattens model instance type and unwraps async functions into resolved GraphQL shape
+ *
+ * This type is used for generating the base shape for custom selection set input and its return value
+ * Uses same pattern as above to limit recursion depth to maximum usable for selection set.
+ *
+ * @example
+ * ### Given
+ * ```ts
+ * Model = {
+    title: string;
+    comments: () => ListReturnValue<({
+        content: string;
+        readonly id: string;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    } | null | undefined)[]>;
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    description?: string | ... 1 more ... | undefined;
+  }
+ * ```
+ * ### Returns
+ * ```ts
+ * {
+    title: string;
+    comments: {
+        content: string;
+        readonly id: string;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    }[];
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    description: string | null | undefined;
+  }
+ *
+ * ```
+ */
+export 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<Model extends Record<any, any>> = Prettify<Record<Model['identifier'] & string, string>>;
+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 Record<string, unknown>> = Equal<ModelIdentifier<ModelMeta>, {
+    id: string;
+}> extends true ? Partial<ModelIdentifier<ModelMeta>> & Omit<MutationInput<Model>, 'id'> : MutationInput<Model>;
+/**
+ * See: https://spec.graphql.org/draft/#sec-Errors
+ */
+export interface GraphQLFormattedError {
+    /**
+     * A short, human-readable summary of the problem that **SHOULD NOT** change
+     * from occurrence to occurrence of the problem, except for purposes of
+     * localization.
+     */
+    readonly message: string;
+    /**
+     * The AppSync exception category. Indicates the source of the error.
+     */
+    readonly errorType: string;
+    /**
+     * Additional error metadata that can be surfaced via error handling resolver utils:
+     * * JS - https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js
+     * * VTL - https://docs.aws.amazon.com/appsync/latest/devguide/utility-helpers-in-util.html#utility-helpers-in-error
+     */
+    readonly errorInfo: null | {
+        [key: string]: unknown;
+    };
+    /**
+     * If an error can be associated to a particular point in the requested
+     * GraphQL document, it should contain a list of locations.
+     */
+    readonly locations?: ReadonlyArray<SourceLocation>;
+    /**
+     * If an error can be associated to a particular field in the GraphQL result,
+     * it _must_ contain an entry with the key `path` that details the path of
+     * the response field which experienced the error. This allows clients to
+     * identify whether a null result is intentional or caused by a runtime error.
+     */
+    readonly path?: ReadonlyArray<string | number>;
+    /**
+     * Reserved for implementors to extend the protocol however they see fit,
+     * and hence there are no additional restrictions on its contents.
+     */
+    readonly extensions?: {
+        [key: string]: unknown;
+    };
+}
+/**
+ * Represents a location in a Source.
+ */
+export interface SourceLocation {
+    readonly line: number;
+    readonly column: number;
+}
+export type SingularReturnValue<T> = Promise<{
+    data: T;
+    errors?: GraphQLFormattedError[];
+    extensions?: {
+        [key: string]: any;
+    };
+}>;
+export type ListReturnValue<T> = Promise<{
+    data: Array<T>;
+    nextToken?: string | null;
+    errors?: GraphQLFormattedError[];
+    extensions?: {
+        [key: string]: any;
+    };
+}>;
+export type ObservedReturnValue<T> = Observable<T>;
+export type ObserveQueryReturnValue<T> = Observable<{
+    items: T[];
+    isSynced: boolean;
+}>;
+export type LazyLoader<Model, IsArray extends boolean> = (options?: IsArray extends true ? {
+    authMode?: AuthMode;
+    authToken?: string;
+    limit?: number;
+    nextToken?: string | null;
+    headers?: CustomHeaders;
+} : {
+    authMode?: AuthMode;
+    authToken?: string;
+    headers?: CustomHeaders;
+}) => IsArray extends true ? ListReturnValue<Prettify<NonNullable<Model>>> : SingularReturnValue<Prettify<Model>>;
+export type AuthMode = 'apiKey' | 'iam' | 'oidc' | 'userPool' | 'lambda' | 'none';
+type LogicalFilters<Model extends Record<any, any>> = {
+    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.
+ */
+type StringFilter = {
+    attributeExists?: boolean;
+    beginsWith?: string;
+    between?: [string, string];
+    contains?: string;
+    eq?: string;
+    ge?: string;
+    gt?: string;
+    le?: string;
+    lt?: string;
+    ne?: string;
+    notContains?: string;
+    size?: SizeFilter;
+};
+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;
+};
+type ModelFilter<Model extends Record<any, any>> = LogicalFilters<Model> & {
+    [K in keyof Model as Model[K] extends LazyLoader<any, any> ? never : K]?: Model[K] extends boolean ? BooleanFilters : Model[K] extends number ? NumericFilter : StringFilter;
+};
+export type ModelSortDirection = 'ASC' | 'DESC';
+type ModelMetaShape = {
+    secondaryIndexes: SecondaryIndexIrShape[];
+    identifier: string;
+};
+export type ModelTypesClient<Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+    create: (model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    update: (model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    delete: (identifier: ModelIdentifier<ModelMeta>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: ModelIdentifier<ModelMeta>, options?: {
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: Partial<ModelIdentifier<ModelMeta>> & {
+        filter?: ModelFilter<Model>;
+        sortDirection?: ModelSortDirection;
+        limit?: number;
+        nextToken?: string | null;
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    onCreate<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: {
+        filter?: ModelFilter<Model>;
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): ObservedReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    onUpdate<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: {
+        filter?: ModelFilter<Model>;
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): ObservedReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    onDelete<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: {
+        filter?: ModelFilter<Model>;
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): ObservedReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    observeQuery<SelectionSet extends ModelPath<FlatModel>[] = never[]>(options?: {
+        filter?: ModelFilter<Model>;
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+    }): ObserveQueryReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+};
+type ModelTypesSSRCookies<Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+    create: (model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    update: (model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    delete: (identifier: ModelIdentifier<ModelMeta>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: ModelIdentifier<ModelMeta>, options?: {
+        selectionSet?: SelectionSet;
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
+    list<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: Partial<ModelIdentifier<ModelMeta>> & {
+        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 ModelTypesSSRRequest<Model extends Record<string, unknown>, ModelMeta extends ModelMetaShape, FlatModel extends Record<string, unknown> = ResolvedModel<Model>> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+    create: (contextSpec: any, model: Prettify<CreateModelInput<Model, ModelMeta>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    update: (contextSpec: any, model: Prettify<ModelIdentifier<ModelMeta> & Partial<MutationInput<Model>>>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    delete: (contextSpec: any, identifier: ModelIdentifier<ModelMeta>, options?: {
+        authMode?: AuthMode;
+        authToken?: string;
+        headers?: CustomHeaders;
+    }) => SingularReturnValue<Model>;
+    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: any, identifier: ModelIdentifier<ModelMeta>, 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?: Partial<ModelIdentifier<ModelMeta>> & {
+        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 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<Schema[ModelName], ModelMeta[ModelName]> : Context extends 'COOKIES' ? ModelTypesSSRCookies<Schema[ModelName], ModelMeta[ModelName]> : Context extends 'REQUEST' ? ModelTypesSSRRequest<Schema[ModelName], ModelMeta[ModelName]> : never : never : 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>;
+type CustomOperationMethodOptions = {
+    authMode?: AuthMode;
+    authToken?: string;
+    headers?: CustomHeaders;
+};
+/**
+ * Generates Custom Operations function params based on whether .arguments() were specified in the schema builder
+ */
+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']>;
+    }[Context];
+};
+/**
+ * The utility type that is used to infer the type (interface) of the generated
+ * `client.enums` property.
+ *
+ * @example
+ * // The schema:
+ * {
+ *   TodoStatus: a.enum(['Planned' | 'InProgress' | 'Completed']),
+ * }
+ *
+ * // The inferred interface of the `client.enums`:
+ * {
+ *   TodoStatus: {
+ *     values: () => Array<'Planned' | 'InProgress' | 'Completed'>;
+ *   }
+ * }
+ */
+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]>;
+    };
+};
+/**
+ * Request options that are passed to custom header functions.
+ * `method` and `headers` are not included in custom header functions passed to
+ * subscriptions.
+ */
+export type RequestOptions = {
+    url: string;
+    queryString: string;
+    method?: string;
+};
+/**
+ * Custom headers that can be passed either to the client or to individual
+ * model operations, either as a static object or a function that returns a
+ * promise.
+ */
+export type CustomHeaders = Record<string, string> | ((requestOptions?: RequestOptions) => Promise<Record<string, string>>);
+/**
+ * SecondaryIndex index types and query methods
+ */
+export type SecondaryIndexIrShape = {
+    queryField: string;
+    pk: {
+        [key: string]: string | number;
+    };
+    sk: {
+        [key: string]: string | number;
+    };
+};
+type IndexQueryMethodsFromIR<SecondaryIdxTuple extends SecondaryIndexIrShape[], Model extends Record<string, unknown>, Res = unknown> = SecondaryIdxTuple extends [
+    infer A extends SecondaryIndexIrShape,
+    ...infer B extends SecondaryIndexIrShape[]
+] ? IndexQueryMethodsFromIR<B, Model, IndexQueryMethodSignature<A, Model> & Res> : Res;
+type IndexQueryMethodSignature<Idx extends SecondaryIndexIrShape, Model extends Record<string, unknown>> = {
+    [K in Idx['queryField'] & string]: <FlatModel extends Record<string, unknown> = ResolvedModel<Model>, SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(input: Idx['pk'] & {
+        [SKField in keyof Idx['sk']]+?: string extends Idx['sk'][SKField] ? StringFilter : NumericFilter;
+    }, 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<{
+    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<{
+    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<{
+    models: ModelTypes<T, 'COOKIES'>;
+    enums: EnumTypes<T>;
+    queries: CustomQueries<T, 'COOKIES'>;
+    mutations: CustomMutations<T, 'COOKIES'>;
+}>;

package/dist/esm/runtime/client/index.mjs

@@ -0,0 +1,2 @@
+export { __modelMeta__ } from '@aws-amplify/data-schema-types';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/runtime/client/index.mjs.map

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

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

@@ -0,0 +1,15 @@
+import { ExtractModelMeta } from '@aws-amplify/data-schema-types';
+export { __modelMeta__, ExtractModelMeta, } from '@aws-amplify/data-schema-types';
+export type ModelTypes<_T extends Record<any, any> = never, _Context extends string = 'CLIENT', _ModelMeta extends Record<any, any> = any> = any;
+export type EnumTypes<_T extends Record<any, any> = never, _ModelMeta extends Record<any, any> = any> = any;
+export type SelectionSet<_Model, _Path> = any;
+/**
+ * Custom headers that can be passed either to the client or to individual
+ * model operations, either as a static object or a function that returns a
+ * promise.
+ */
+export type CustomHeaders = Record<string, string> | (() => Promise<Record<string, string>>);
+export type CustomQueries<Schema extends Record<any, any>, _Context extends string = 'CLIENT', _ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = any;
+export type CustomMutations<Schema extends Record<any, any>, _Context extends string = 'CLIENT', _ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = any;
+export type CustomSubscriptions<Schema extends Record<any, any>, _Context extends string = 'CLIENT', _ModelMeta extends Record<any, any> = ExtractModelMeta<Schema>> = any;
+export type ModelSortDirection = 'ASC' | 'DESC';

package/dist/esm/runtime/client/index.v3.mjs

@@ -0,0 +1,2 @@
+export { __modelMeta__ } from '@aws-amplify/data-schema-types';
+//# sourceMappingURL=index.v3.mjs.map

package/dist/esm/runtime/client/index.v3.mjs.map

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

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

@@ -0,0 +1,4 @@
+export * from './client';
+export { addSchemaToClient } from './addSchemaToClient';
+export { addSchemaToClientWithInstance } from './addSchemaToClientWithInstance';
+export { BaseClient, ClientInternals } from './bridge-types';

package/dist/esm/runtime/index.mjs

@@ -0,0 +1,4 @@
+export { __modelMeta__ } from '@aws-amplify/data-schema-types';
+export { addSchemaToClient } from './addSchemaToClient.mjs';
+export { addSchemaToClientWithInstance } from './addSchemaToClientWithInstance.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/runtime/index.mjs.map

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

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

@@ -0,0 +1,4 @@
+export * from './client/index.v3';
+export { addSchemaToClient } from './addSchemaToClient';
+export { addSchemaToClientWithInstance } from './addSchemaToClientWithInstance';
+export { BaseClient, ClientInternals } from './bridge-types';

package/dist/esm/runtime/index.v3.mjs

@@ -0,0 +1,4 @@
+export { __modelMeta__ } from '@aws-amplify/data-schema-types';
+export { addSchemaToClient } from './addSchemaToClient.mjs';
+export { addSchemaToClientWithInstance } from './addSchemaToClientWithInstance.mjs';
+//# sourceMappingURL=index.v3.mjs.map

package/dist/esm/runtime/index.v3.mjs.map

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