import { type DeepReadOnlyObject, type UnwrapArray, type UnionToIntersection, type Prettify } from '@aws-amplify/data-schema-types';
import type { Observable } from 'rxjs';
import type { ConversationRoute } from '../../ai/ConversationType';
import type { ClientSchemaByEntityType, ClientSchemaByEntityTypeBaseShape } from '../../ClientSchema';
import type { ExtractNestedTypes } from '../../ClientSchema/utilities/';
import type { Select, StringFilter, NumericFilter, BooleanFilters, SubscriptionStringFilter, SubscriptionNumericFilter, SubscriptionBooleanFilters } from '../../util';
import { AmplifyServer } from '../bridge-types';
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 NonRelationshipFields<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 with default selection set; otherwise generates return type from custom sel. set. Optionality is removed from both return types.
 */
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
 *
 * @typeParam Result - this is the result of applying the selection set path to FlatModel; return type of UnionToIntersection<DeepPickFromPath<FlatModel, Paths>>
 * @typeParam FlatModel - the reference model shape; return type of ResolvedModel<Model>
 *
 * Note: we wrap `Result` and `FlatModel` in NonNullable, because recursive invocations of this mapped type
 * can result in the type arguments containing `{} | null | undefined` which breaks indexed access, e.g. Result[K]
 *
 * Using NonNullable<> directly inside the mapped type is significantly more performant here than attempting to pre-compute in the type params,
 * e.g., `type RestoreArrays<Result, FlatModel, NonNullableResult = NonNullable<Result>, NonNullableFlatModel = NonNullable<FlatModel>> = {...}`
 */
type RestoreArrays<Result, FlatModel> = {
    [K in keyof NonNullable<Result>]: K extends keyof NonNullable<FlatModel> ? Array<any> extends NonNullable<FlatModel>[K] ? HandleArrayNullability<NonNullable<Result>[K], NonNullable<FlatModel>[K]> : NonNullable<FlatModel>[K] extends Record<string, any> ? RestoreArrays<NonNullable<Result>[K], NonNullable<FlatModel>[K]> : NonNullable<Result>[K] : never;
};
/**
 * This mapped type gets called by RestoreArrays<T, K> and it restores the expected
 * nullability in array fields (e.g. nullable vs. required value & nullable vs. required array)
 */
type HandleArrayNullability<Result, FlatModel> = Array<any> extends Result ? Result : NonNullable<FlatModel> extends Array<infer InnerValue> ? null extends FlatModel ? null extends InnerValue ? // value and array are nullable - a.ref('SomeType').array()
Array<RestoreArrays<Result, UnwrapArray<FlatModel>> | null> | null : // value required; array nullable - a.ref('SomeType').required().array()
Array<RestoreArrays<Result, UnwrapArray<FlatModel>>> | null : null extends InnerValue ? Array<RestoreArrays<Result, UnwrapArray<FlatModel>> | null> : Array<RestoreArrays<Result, UnwrapArray<FlatModel>>> : 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]: FlatModel[Head] extends Record<string, unknown> ? NonRelationshipFields<FlattenArrays<FlatModel[Head]>> : NonRelationshipFields<UnwrapArray<FlatModel[Head]>>;
} : {
    [k in Head]: DeepPickFromPath<FlatModel[Head], Tail>;
} : never : Path extends keyof FlatModel ? {
    [K in Path]: FlatModel[Path];
} : never;
/**
 * This mapped type gets called by DeepPickFromPath<FlatModel, Path> when user uses selection
 * set on a query to a many-to-many relationship join table. It flattens the Arrays of Models referenced in the join table.
 *
 * (e.g. { customer: { orders: Order[]} } => { customer: { orders: Order} })
 */
type FlattenArrays<T> = {
    [K in keyof T]: UnwrapArray<T[K]>;
};
/**
 * 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
 *
 */
type ModelPathInner<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}.${ModelPathInner<NonNullable<UnwrapArray<FlatModel[Field]>>, RecursionLoop[Depth]>}` | `${Field}.*` : `${Field}` : never;
}[Depth extends -1 ? 'done' : 'recur'];
export type ModelPath<FlatModel extends Record<string, unknown>> = ModelPathInner<FlatModel>;
export type SelectionSet<Model, Path extends ReadonlyArray<ModelPath<FlatModel>>, FlatModel extends Record<string, unknown> = Model extends ClientSchemaByEntityTypeBaseShape['models'][string] ? Model['__meta']['flatModel'] : Record<string, any>> = Model extends ClientSchemaByEntityTypeBaseShape['models'][string] ? WithOptionalsAsNullishOnly<CustomSelectionSetReturnValue<FlatModel, Path[number]>> : any;
/**
 * 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 | null;
    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<T, 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<T>>> : SingularReturnValue<Prettify<T>>;
export type AuthMode = 'apiKey' | 'iam' | 'identityPool' | 'oidc' | 'userPool' | 'lambda' | 'none';
type LogicalFilters<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = {
    and?: ModelFilter<Model> | ModelFilter<Model>[];
    or?: ModelFilter<Model> | ModelFilter<Model>[];
    not?: ModelFilter<Model>;
};
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;
};
type LogicalSubscriptionFilters<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = {
    and?: ModelSubscriptionFilter<Model> | ModelSubscriptionFilter<Model>[];
    or?: ModelSubscriptionFilter<Model> | ModelSubscriptionFilter<Model>[];
    not?: ModelSubscriptionFilter<Model>;
};
type ModelSubscriptionFilter<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = LogicalSubscriptionFilters<Model> & {
    [K in keyof Model['type'] as Model['type'][K] extends LazyLoader<any, any> ? never : K]?: boolean extends Model['type'][K] ? SubscriptionBooleanFilters : number extends Model['type'][K] ? SubscriptionNumericFilter : SubscriptionStringFilter;
};
export type ModelSortDirection = 'ASC' | 'DESC';
type ListCpkOptions<Model extends ClientSchemaByEntityTypeBaseShape['models'][string]> = unknown extends Model['__meta']['listOptionsPkParams'] ? unknown : Model['__meta']['listOptionsPkParams'] & {
    sortDirection?: ModelSortDirection;
};
interface ClientSecondaryIndexField {
    input: object;
}
type IndexQueryMethods<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], Context extends ContextType = 'CLIENT'> = {
    [K in keyof Select<Model['secondaryIndexes'], ClientSecondaryIndexField>]: IndexQueryMethod<Model, Select<Model['secondaryIndexes'], ClientSecondaryIndexField>[K], Context>;
};
type IndexQueryMethod<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], Method extends ClientSecondaryIndexField, Context extends ContextType = 'CLIENT', FlatModel extends Record<string, unknown> = Model['__meta']['flatModel']> = Context extends 'CLIENT' | 'COOKIES' ? <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>>> : <SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: AmplifyServer.ContextSpec, 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> = Model['__meta']['flatModel']> = IndexQueryMethods<Model> & Omit<{
    create<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(model: Model['createType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    update<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(model: Model['updateType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    delete<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: Model['deleteType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    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?: ListCpkOptions<Model> & {
        filter?: ModelFilter<Model>;
        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?: ModelSubscriptionFilter<Model>;
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): ObservedReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    onUpdate<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: {
        filter?: ModelSubscriptionFilter<Model>;
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): ObservedReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    onDelete<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(options?: {
        filter?: ModelSubscriptionFilter<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>>>;
}, keyof Model['__meta']['disabledOperations']>;
type ModelTypesSSRCookies<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Record<string, unknown> = Model['__meta']['flatModel']> = IndexQueryMethods<Model> & Omit<{
    create<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(model: Model['createType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    update<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(model: Model['updateType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    delete<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(identifier: Model['deleteType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    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?: ListCpkOptions<Model> & {
        filter?: ModelFilter<Model>;
        sortDirection?: ModelSortDirection;
        limit?: number;
        nextToken?: string | null;
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
}, keyof Model['__meta']['disabledOperations']>;
type ModelTypesSSRRequest<Model extends ClientSchemaByEntityTypeBaseShape['models'][string], FlatModel extends Record<string, unknown> = Model['__meta']['flatModel']> = IndexQueryMethods<Model, 'REQUEST'> & Omit<{
    create<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: AmplifyServer.ContextSpec, model: Model['createType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    update<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: AmplifyServer.ContextSpec, model: Model['updateType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    delete<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: AmplifyServer.ContextSpec, identifier: Model['deleteType'], options?: {
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): SingularReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
    get<SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[]>(contextSpec: AmplifyServer.ContextSpec, 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: AmplifyServer.ContextSpec, options?: ListCpkOptions<Model> & {
        filter?: ModelFilter<Model>;
        sortDirection?: ModelSortDirection;
        limit?: number;
        nextToken?: string | null;
        selectionSet?: SelectionSet;
        authMode?: AuthMode;
        authToken?: string;
        headers?: CustomHeaders;
    }): ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
}, keyof Model['__meta']['disabledOperations']>;
type ContextType = 'CLIENT' | 'COOKIES' | 'REQUEST';
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<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;
    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<OperationDefs extends ClientSchemaByEntityTypeBaseShape['queries' | 'mutations' | 'subscriptions' | 'generations'], 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: AmplifyServer.ContextSpec, ...params: CustomOperationFnParams<OperationDefs[OpName]['args']>) => SingularReturnValue<OperationDefs[OpName]['type']>;
    }[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<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
 * 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>>);
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'>;
    conversations: ConversationRoutes<T>;
    generations: Generations<T>;
};
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> = {
    models: ModelTypes<T, 'COOKIES'>;
    enums: EnumTypes<T>;
    queries: CustomQueries<T, 'COOKIES'>;
    mutations: CustomMutations<T, 'COOKIES'>;
};
export type ConversationRoutes<T extends Record<any, any>, Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = {
    [ConversationName in keyof Schema['conversations']]: ConversationRoute;
};
export type Generations<T extends Record<any, any>, Schema extends ClientSchemaByEntityType<T> = ClientSchemaByEntityType<T>> = CustomOperations<Schema['generations']>;