@aws-amplify/data-schema 1.2.9 → 1.3.0

package/dist/cjs/ClientSchema/Core/ClientCustomOperations.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ClientCustomOperations.js.map

package/dist/cjs/ClientSchema/Core/ClientCustomOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientCustomOperations.js","sources":["../../../../src/ClientSchema/Core/ClientCustomOperations.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/{MappedTypes/CustomOperations.js → ClientSchema/Core/ClientCustomType.js}

@@ -1,4 +1,4 @@
 'use strict';
 
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=CustomOperations.js.map
+//# sourceMappingURL=ClientCustomType.js.map

package/dist/cjs/ClientSchema/Core/ClientCustomType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientCustomType.js","sources":["../../../../src/ClientSchema/Core/ClientCustomType.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/{ClientSchema.js → ClientSchema/Core/ClientEnum.js}

@@ -1,4 +1,4 @@
 'use strict';
 
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ClientSchema.js.map
+//# sourceMappingURL=ClientEnum.js.map

package/dist/cjs/ClientSchema/Core/ClientEnum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientEnum.js","sources":["../../../../src/ClientSchema/Core/ClientEnum.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/Core/ClientModel.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ClientModel.js.map

package/dist/cjs/ClientSchema/Core/ClientModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientModel.js","sources":["../../../../src/ClientSchema/Core/ClientModel.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/Core/ClientSchemaProperty.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ClientSchemaProperty.js.map

package/dist/cjs/ClientSchema/Core/ClientSchemaProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientSchemaProperty.js","sources":["../../../../src/ClientSchema/Core/ClientSchemaProperty.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/Core/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/cjs/ClientSchema/Core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/ClientSchema/Core/index.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/cjs/ClientSchema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/ClientSchema/index.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/utilities/ExtractNestedTypes.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ExtractNestedTypes.js.map

package/dist/cjs/ClientSchema/utilities/ExtractNestedTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtractNestedTypes.js","sources":["../../../../src/ClientSchema/utilities/ExtractNestedTypes.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/utilities/ResolveField.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResolveField.js.map

package/dist/cjs/ClientSchema/utilities/ResolveField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResolveField.js","sources":["../../../../src/ClientSchema/utilities/ResolveField.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/utilities/ResolveRef.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResolveRef.js.map

package/dist/cjs/ClientSchema/utilities/ResolveRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResolveRef.js","sources":["../../../../src/ClientSchema/utilities/ResolveRef.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/utilities/SchemaMetadata.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SchemaMetadata.js.map

package/dist/cjs/ClientSchema/utilities/SchemaMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaMetadata.js","sources":["../../../../src/ClientSchema/utilities/SchemaMetadata.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/ClientSchema/utilities/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ExtractNestedTypes"), exports);
+tslib_1.__exportStar(require("./ResolveField"), exports);
+tslib_1.__exportStar(require("./ResolveRef"), exports);
+tslib_1.__exportStar(require("./SchemaMetadata"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/ClientSchema/utilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/ClientSchema/utilities/index.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst tslib_1 = require(\"tslib\");\ntslib_1.__exportStar(require(\"./ExtractNestedTypes\"), exports);\ntslib_1.__exportStar(require(\"./ResolveField\"), exports);\ntslib_1.__exportStar(require(\"./ResolveRef\"), exports);\ntslib_1.__exportStar(require(\"./SchemaMetadata\"), exports);\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AACjC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC,CAAC;AAC/D,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC,CAAC;AACzD,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;;"}

package/dist/cjs/util/Filters.js

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * 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"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Filters.js.map

package/dist/cjs/util/Filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filters.js","sources":["../../../src/util/Filters.ts"],"sourcesContent":["\"use strict\";\n/**\n * Not actually sure if/how customer can pass this through as variables yet.\n * Leaving it out for now:\n *\n * attributeType: \"binary\" | \"binarySet\" | \"bool\" | \"list\" | \"map\" | \"number\" | \"numberSet\" | \"string\" | \"stringSet\" | \"_null\"\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/util/IndexShapes.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IndexShapes.js.map

package/dist/cjs/util/IndexShapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexShapes.js","sources":["../../../src/util/IndexShapes.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/util/Select.js

@@ -0,0 +1,4 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Select.js.map

package/dist/cjs/util/Select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Select.js","sources":["../../../src/util/Select.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/esm/Authorization.d.ts

@@ -319,9 +319,9 @@ declare function resourceTo<SELF extends ResourceAuthorization>(this: SELF, oper
  * ```
  */
 export type ImpliedAuthField<T extends Authorization<any, any, any>> = T extends Authorization<infer _Strat, infer Field, infer isMulti> ? Field extends undefined ? never : Field extends string ? isMulti extends true ? {
-    [K in Field]?: string[];
+    [K in Field]?: string[] | null | undefined;
 } : {
-    [K in Field]?: string;
+    [K in Field]?: string | null | undefined;
 } : never : never;
 /**
  * Turns the type from a list of `Authorization` rules like this:
@@ -348,7 +348,7 @@ export type ImpliedAuthFields<T extends Authorization<any, any, any>> = ImpliedA
 export declare const accessData: <T extends Authorization<any, any, any>>(authorization: T) => {
     strategy?: any;
     provider?: "function" | "userPools" | "oidc" | "identityPool" | "apiKey" | undefined;
-    operations?: ("create" | "update" | "delete" | "search" | "read" | "get" | "list" | "sync" | "listen")[] | undefined;
+    operations?: ("search" | "create" | "update" | "delete" | "read" | "get" | "list" | "sync" | "listen")[] | undefined;
     groupOrOwnerField?: any;
     groups?: string[] | undefined;
     multiOwner: any;

package/dist/esm/ClientSchema/Core/ClientCustomOperations.d.ts

@@ -0,0 +1,88 @@
+import type { CustomOperationParamShape } from '../../CustomOperation';
+import type { BaseModelField } from '../../ModelField';
+import type { RefType } from '../../RefType';
+import type { ResolveFieldRequirements } from '../../MappedTypes/ResolveFieldProperties';
+import type { AppSyncResolverHandler } from 'aws-lambda';
+import type { CustomType } from '../../CustomType';
+import type { FieldTypesOfCustomType } from '../../MappedTypes/ResolveSchema';
+import type { ResolveRef } from '../utilities/ResolveRef';
+import { ClientSchemaProperty } from './ClientSchemaProperty';
+type CustomOperationSubType<Op extends CustomOperationParamShape> = `custom${Op['typeName']}`;
+/**
+ * Derives the signature and types for a lambda handler for a particular
+ * custom Query or Mutation from a Schema.
+ */
+export interface ClientCustomOperation<RefBag extends Record<any, any>, Op extends CustomOperationParamShape> extends ClientSchemaProperty {
+    __entityType: CustomOperationSubType<Op>;
+    operationType: Op['typeName'];
+    /**
+     * Handler type for lambda function implementations. E.g.,
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // event and context will be fully typed inside here.
+     * }
+     * ```
+     */
+    functionHandler: AppSyncResolverHandler<CustomOpArguments<Op>, LambdaReturnType<CustomOpReturnType<Op, RefBag>>>;
+    /**
+     * The `context.arguments` type for lambda function implementations.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Provides this type, if needed:
+     *  const args: Schema['echo']['functionHandlerArguments'] = event.arguments;
+     * }
+     * ```
+     */
+    args: CustomOpArguments<Op>;
+    /**
+     * The return type expected by a lambda function handler.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Result type enforced here:
+     *  const result: Schema['echo']['functionHandlerResult'] = buildResult(...);
+     *
+     *  // `Result` type matches expected function return type here:
+     *  return result;
+     * }
+     * ```
+     */
+    returnType: LambdaReturnType<CustomOpReturnType<Op, RefBag>>;
+    type: CustomOpReturnType<Op, RefBag>;
+}
+/**
+ * Digs out custom operation arguments, mapped to the intended graphql types.
+ */
+type CustomOpArguments<Shape extends CustomOperationParamShape> = Shape['arguments'] extends null ? never : ResolveFieldRequirements<{
+    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<infer R> ? R : never;
+}>;
+/**
+ * Removes `null | undefined` from the return type if the operation is a subscription,
+ * since subs don't fire on empty/non-existent values.
+ */
+type Normalize<Shape extends CustomOperationParamShape, RT> = Shape['typeName'] extends 'Subscription' ? Exclude<RT, null | undefined> : RT;
+/**
+ * Computes the return type from the `returnType` of a custom operation shape.
+ *
+ * This entails dereferencing refs and inferring graphql types from field-type defs.
+ */
+type CustomOpReturnType<Shape extends CustomOperationParamShape, RefBag extends Record<string, any>> = Normalize<Shape, Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof RefBag ? ResolveRef<RefShape, RefBag> : never : Shape['returnType'] extends BaseModelField<infer R> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
+    thisCustomType: R['fields'];
+}>['thisCustomType']> | null : never>;
+/**
+ * Returns a return type with lazy loaders removed.
+ *
+ * (Custom handlers should not return lazy loaded fields -- they're *lazy loaded*.)
+ */
+type LambdaReturnType<T> = T extends Array<infer RT> ? Array<LambdaReturnType<RT>> : T extends Record<string, any> ? {
+    [K in keyof Exclude<T, null | undefined> as Exclude<T, null | undefined>[K] extends (...args: any) => any ? never : K]: Exclude<T, null | undefined>[K];
+} : T | (null extends T ? null : never) | (undefined extends T ? undefined : never);
+export {};

package/dist/esm/ClientSchema/Core/ClientCustomOperations.mjs

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

package/dist/esm/ClientSchema/Core/ClientCustomOperations.mjs.map

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

package/dist/esm/ClientSchema/Core/ClientCustomType.d.ts

@@ -0,0 +1,7 @@
+import type { CustomTypeParamShape } from '../../CustomType';
+import { ClientSchemaProperty } from './ClientSchemaProperty';
+import { ResolveFields } from '../utilities/ResolveField';
+export interface ClientCustomType<Bag extends Record<string, unknown>, T extends CustomTypeParamShape> extends ClientSchemaProperty {
+    __entityType: 'customType';
+    type: ResolveFields<Bag, T['fields']>;
+}

package/dist/esm/ClientSchema/Core/ClientCustomType.mjs

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

package/dist/esm/ClientSchema/Core/ClientCustomType.mjs.map

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

package/dist/esm/ClientSchema/Core/ClientEnum.d.ts

@@ -0,0 +1,5 @@
+import { ClientSchemaProperty } from './ClientSchemaProperty';
+export interface ClientEnum<values extends readonly string[]> extends ClientSchemaProperty {
+    __entityType: 'enum';
+    type: values[number];
+}

package/dist/esm/ClientSchema/Core/ClientEnum.mjs

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

package/dist/esm/ClientSchema/Core/ClientEnum.mjs.map

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

package/dist/esm/ClientSchema/Core/ClientModel.d.ts

@@ -0,0 +1,123 @@
+import type { deferredRefResolvingPrefix, ModelTypeParamShape, ModelDefaultIdentifier } from '../../ModelType';
+import type { ClientSchemaProperty } from './ClientSchemaProperty';
+import type { Authorization, ImpliedAuthFields } from '../../Authorization';
+import type { SchemaMetadata, ResolveFields } from '../utilities';
+import type { IsEmptyStringOrNever, UnionToIntersection, Equal, Prettify } from '@aws-amplify/data-schema-types';
+import type { ModelField } from '../../ModelField';
+import type { ModelRelationalField } from '../../ModelRelationalField';
+import type { EnumType } from '../../EnumType';
+import type { CustomType, CustomTypeParamShape } from '../../CustomType';
+import type { RefType } from '../../RefType';
+import type { StringFilter, NumericFilter, ModelPrimaryCompositeKeyInput, PrimaryIndexIrShape, SecondaryIndexIrShape } from '../../util';
+export interface ClientModel<Bag extends Record<string, unknown>, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, T extends ModelTypeParamShape, K extends keyof Bag & string> extends ClientSchemaProperty {
+    __entityType: 'model';
+    type: ShallowPretty<ClientFields<Bag, Metadata, IsRDS, T>>;
+    createType: Prettify<CreateModelInput<ClientModel<Bag, Metadata, IsRDS, T, K>>>;
+    updateType: Prettify<UpdateModelInput<ClientModel<Bag, Metadata, IsRDS, T, K>>>;
+    deleteType: Prettify<ModelIdentifier<Bag, T>>;
+    identifier: ShallowPretty<ModelIdentifier<Bag, T>>;
+    nestedTypes: NestedTypes<ClientFields<Bag, Metadata, IsRDS, T>, T>;
+    secondaryIndexes: IndexQueryMethodsFromIR<Bag, T['secondaryIndexes'], K>;
+    __meta: {
+        listOptionsPkParams: ListOptionsPkParams<Bag, T>;
+    };
+}
+type ShallowPretty<T> = {
+    [K in keyof T]: T[K];
+};
+type ClientFields<Bag extends Record<string, unknown>, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, T extends ModelTypeParamShape> = ResolveFields<Bag, T['fields']> & If<Not<IsRDS>, ImplicitIdentifier<T>> & AuthFields<Metadata, T> & Omit<SystemFields<IsRDS>, keyof ResolveFields<Bag, T['fields']>>;
+type SystemFields<IsRDS extends boolean> = IsRDS extends false ? {
+    readonly createdAt: string;
+    readonly updatedAt: string;
+} : object;
+type ModelIdentifier<Bag extends Record<string, unknown>, T extends ModelTypeParamShape> = ResolveIdentifierFields<ResolveFields<Bag, T['fields']>, T['identifier']['pk'] & (T['identifier']['sk'] extends never ? unknown : T['identifier']['sk'])>;
+/**
+ * Separate util for *injecting* the default implicit identifier for performance
+ * reasons. The full ModelIdentifer util needs to extract types from the fields
+ * matching the explicitly defined field types. Contrast that to **injecting** PK
+ * fields into the model, which is only done specifically when the default of
+ * `readonly id: string` is being injected IF AND ONLY IF another `id` field is
+ * not already present on the model.
+ */
+type ImplicitIdentifier<T extends ModelTypeParamShape> = T['identifier']['pk'] extends ModelDefaultIdentifier['pk'] ? 'id' extends keyof T['fields'] ? unknown : ModelDefaultIdentifier['pk'] : unknown;
+type ResolveIdentifierFields<Model, IdentifierFields> = {
+    [K in keyof IdentifierFields]: K extends keyof Model ? Model[K] : string;
+};
+type If<ConditionResult extends boolean, IfTrueValue, IfFalseValue = unknown> = ConditionResult extends true ? IfTrueValue : IfFalseValue;
+type Not<T extends boolean> = T extends true ? false : true;
+/**
+ * Models with composite PKs defined are expected to contain the model's pk, sk, and sortDirection properties in the `options` param
+ *
+ * @returns an object containing additional `options` properties for models with a composite primary index
+ *
+ */
+export type ListOptionsPkParams<Bag extends Record<string, unknown>, T extends ModelTypeParamShape> = T['identifier']['sk'] extends never ? unknown : Prettify<Partial<IndexQueryInput<Bag, T['identifier']>>>;
+type AuthFields<SchemaMeta extends SchemaMetadata<any>, Model extends ModelTypeParamShape> = (Model['authorization'][number] extends never ? SchemaMeta['authFields'] extends never ? object : SchemaMeta['authFields'] : ImpliedAuthFields<Model['authorization'][number]> extends never ? object : ImpliedAuthFields<Model['authorization'][number]>) & ImpliedAuthFieldsFromFields<Model>;
+type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationalField<any, any, any, infer Auth> | RefType<any, any, infer Auth> ? Auth extends Authorization<any, any, any> ? ImpliedAuthFields<Auth> : object : object : object>;
+type NestedTypes<Bag extends Record<string, unknown>, T extends ModelTypeParamShape> = {
+    [K in keyof T['fields'] as T['fields'][K] extends EnumType | CustomType<CustomTypeParamShape> ? K : never]: K extends keyof Bag ? {
+        __entityType: T['fields'][K] extends EnumType ? 'enum' : 'customType';
+        type: Exclude<Bag[K], null | undefined>;
+    } : never;
+};
+type IndexQueryMethodsFromIR<Bag extends Record<string, unknown>, Indexes, ModelName extends string, Res = unknown> = Indexes extends [
+    infer A extends SecondaryIndexIrShape,
+    ...infer B extends SecondaryIndexIrShape[]
+] ? IndexQueryMethodsFromIR<Bag, B, ModelName, IndexQueryMethodSignature<Bag, A, ModelName> & Res> : Res;
+type IndexQueryMethodSignature<Bag extends Record<string, unknown>, Idx extends SecondaryIndexIrShape, ModelName extends string> = Record<IsEmptyStringOrNever<Idx['queryField']> extends false ? Idx['queryField'] : `list${ModelName}By${Idx['defaultQueryFieldSuffix']}`, {
+    input: IndexQueryInput<Bag, Idx>;
+}>;
+/**
+ * Accepts a PrimaryIndexIr or SecondaryIndexIr and returns resolved parameters
+ *
+ * TODO: Get rid of the `deferredRefResolvingPrefix` reference hack.
+ * Instead, just dereference refs as usual?
+ */
+export type IndexQueryInput<Bag extends Record<string, unknown>, Idx extends PrimaryIndexIrShape> = {
+    [PKField in keyof Idx['pk']]: Idx['pk'][PKField] extends `${deferredRefResolvingPrefix}${infer R}` ? 'type' extends keyof Bag[R] ? Bag[R]['type'] : never : 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}` ? 'type' extends keyof Bag[R] ? Bag[R]['type'] extends string ? StringFilter<Bag[R]['type']> : never : never : 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];
+    }>;
+});
+/**
+ *
+ *      TEMP
+ *    ---++---
+ *       ||
+ *       ||
+ *      \^^/
+ *       \/
+ */
+/**
+ * All required fields and relational fields, exclude readonly fields
+ */
+type MutationInput<Model extends ClientModel<any, any, any, any, any>, WritableFields = Pick<Model['type'], WritableKeys<Model['type']>>> = WithNullablesAsOptionalRecursively<{
+    [Prop in keyof WritableFields as WritableFields[Prop] extends (...args: any) => any ? never : Prop]: WritableFields[Prop];
+}>;
+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];
+type MinusReadonly<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+type WithNullablesAsOptionalRecursively<T> = T extends Array<any> | ((...args: any) => any) ? T : T extends object ? {
+    [K in keyof T as null extends T[K] ? K : never]+?: WithNullablesAsOptionalRecursively<T[K]>;
+} & {
+    [K in keyof T as null extends T[K] ? never : K]: WithNullablesAsOptionalRecursively<T[K]>;
+} : T;
+/**
+ * All identifiers and fields used to create a model
+ */
+type CreateModelInput<Model extends ClientModel<any, any, any, any, any>> = Equal<MinusReadonly<Model['identifier']>, {
+    id: string;
+}> extends true ? Partial<MinusReadonly<Model['identifier']>> & Omit<MutationInput<Model>, 'id'> : MutationInput<Model>;
+type UpdateModelInput<Model extends ClientModel<any, any, any, any, any>> = MinusReadonly<Model['identifier']> & Partial<MutationInput<Model>>;
+export {};

package/dist/esm/ClientSchema/Core/ClientModel.mjs

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

package/dist/esm/ClientSchema/Core/ClientModel.mjs.map

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

package/dist/esm/ClientSchema/Core/ClientSchemaProperty.d.ts

@@ -0,0 +1,4 @@
+export interface ClientSchemaProperty {
+    __entityType: 'model' | 'enum' | 'customType' | 'customQuery' | 'customMutation' | 'customSubscription';
+    type: any;
+}

package/dist/esm/ClientSchema/Core/ClientSchemaProperty.mjs

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

package/dist/esm/ClientSchema/Core/ClientSchemaProperty.mjs.map

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

package/dist/esm/ClientSchema/Core/index.d.ts

@@ -0,0 +1,5 @@
+export { ClientCustomOperation } from './ClientCustomOperations';
+export { ClientEnum } from './ClientEnum';
+export { ClientCustomType } from './ClientCustomType';
+export { ClientModel } from './ClientModel';
+export { ClientSchemaProperty } from './ClientSchemaProperty';

package/dist/esm/ClientSchema/Core/index.mjs

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

package/dist/esm/ClientSchema/Core/index.mjs.map

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

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

@@ -0,0 +1,59 @@
+import type { __modelMeta__ } from '../runtime/client';
+import type { BaseSchema, CustomOperation, CustomType, EnumType, GenericModelSchema, ModelSchemaContents, ModelType } from '../ModelSchema';
+import type { ClientCustomOperation, ClientCustomType, ClientEnum, ClientModel } from './Core';
+import type { CombinedModelSchema, CombinedSchemaIndexesUnion } from '../CombineSchema';
+import type { SchemaMetadata } from './utilities/SchemaMetadata';
+import type { Brand, Select, SpreadTuple } from '../util';
+export type ClientSchema<Schema extends GenericModelSchema<any> | CombinedModelSchema<any>> = Schema extends GenericModelSchema<any> ? InternalClientSchema<Schema> : Schema extends CombinedModelSchema<any> ? InternalCombinedSchema<Schema> : never;
+type InternalClientSchema<CustomerSchema extends ModelSchemaContents | BaseSchema<any, any>, Metadata extends SchemaMetadata<any> = never, IsRDS extends boolean = never> = CustomerSchema extends ModelSchemaContents ? {
+    [K in keyof CustomerSchema as K extends string ? K : never]: K extends string ? ClientSchemaProperty<CustomerSchema, Metadata, IsRDS, K> : never;
+} : CustomerSchema extends BaseSchema<any, any> ? InternalClientSchema<CustomerSchema['data']['types'], SchemaMetadata<CustomerSchema>, CustomerSchema extends Brand<'RDSSchema'> ? true : false> : never;
+type ClientSchemaProperty<T extends ModelSchemaContents, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, K extends keyof T & string> = T[K] extends Brand<'enum'> ? RemapEnum<T, T[K]> : T[K] extends Brand<'customType'> ? RemapCustomType<T, Metadata, IsRDS, T[K]> : T[K] extends Brand<'queryCustomOperation' | 'mutationCustomOperation' | 'subscriptionCustomOperation'> ? RemapCustomOperation<T, Metadata, IsRDS, T[K]> : T[K] extends Brand<'modelType'> ? RemapModel<T, Metadata, IsRDS, T[K], K> : never;
+type RemapEnum<_T extends ModelSchemaContents, E> = E extends EnumType<infer values> ? ClientEnum<values> : never;
+type RemapCustomType<T extends ModelSchemaContents, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, E> = E extends CustomType<infer CT> ? ClientCustomType<InternalClientSchema<T, Metadata, IsRDS>, CT> : never;
+type RemapCustomOperation<T extends ModelSchemaContents, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, E> = E extends CustomOperation<infer CO, any> ? ClientCustomOperation<InternalClientSchema<T, Metadata, IsRDS>, CO> : never;
+type RemapModel<T extends ModelSchemaContents, Metadata extends SchemaMetadata<any>, IsRDS extends boolean, E, K extends keyof T & string> = E extends ModelType<infer MT, any> ? ClientModel<InternalClientSchema<T, Metadata, IsRDS>, Metadata, IsRDS, MT, K> : never;
+type GetInternalClientSchema<Schema> = Schema extends GenericModelSchema<any> ? InternalClientSchema<Schema> : never;
+type CombinedClientSchemas<Schemas extends CombinedModelSchema<any>['schemas']> = {
+    [Index in keyof Schemas]: Index extends CombinedSchemaIndexesUnion ? GetInternalClientSchema<Schemas[Index]> : never;
+};
+/**
+ * Types for unwrapping and combining generic type args into client-consumable types
+ * for multiple schemas
+ *
+ * @typeParam Combined - A container of multiple schemas
+ *
+ * @internal @typeParam ClientSchemas - The tuple of client schemas to combine
+ */
+type InternalCombinedSchema<Combined extends CombinedModelSchema<any>, ClientSchemas extends [...any] = CombinedClientSchemas<Combined['schemas']>> = SpreadTuple<{
+    [I in keyof ClientSchemas]: I extends CombinedSchemaIndexesUnion ? Omit<ClientSchemas[I], typeof __modelMeta__> : never;
+}>;
+export type ClientSchemaByEntityTypeBaseShape = {
+    enums: Record<string, ClientEnum<any>>;
+    customTypes: Record<string, ClientCustomType<any, any>>;
+    models: Record<string, ClientModel<any, any, any, any, any>>;
+    queries: Record<string, ClientCustomOperation<any, any>>;
+    mutations: Record<string, ClientCustomOperation<any, any>>;
+    subscriptions: Record<string, ClientCustomOperation<any, any>>;
+};
+export type ClientSchemaByEntityType<T> = {
+    enums: Select<T, {
+        __entityType: 'enum';
+    }>;
+    customTypes: Select<T, {
+        __entityType: 'customType';
+    }>;
+    models: Select<T, {
+        __entityType: 'model';
+    }>;
+    queries: Select<T, {
+        __entityType: 'customQuery';
+    }>;
+    mutations: Select<T, {
+        __entityType: 'customMutation';
+    }>;
+    subscriptions: Select<T, {
+        __entityType: 'customSubscription';
+    }>;
+};
+export {};

package/dist/esm/ClientSchema/index.mjs

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

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

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

package/dist/esm/ClientSchema/utilities/ExtractNestedTypes.d.ts

@@ -0,0 +1,7 @@
+import { ClientSchemaByEntityTypeBaseShape } from '..';
+import { UnionToIntersection } from '@aws-amplify/data-schema-types';
+export type ExtractNestedTypes<T extends ClientSchemaByEntityTypeBaseShape> = UnionToIntersection<{
+    [ModelName in keyof T['models']]: ModelName extends string ? {
+        [TypeName in keyof T['models'][ModelName]['nestedTypes'] as TypeName extends string ? `${ModelName}${Capitalize<TypeName>}` : never]: T['models'][ModelName]['nestedTypes'][TypeName];
+    } : never;
+}[keyof T['models']]>;

package/dist/esm/ClientSchema/utilities/ExtractNestedTypes.mjs

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

package/dist/esm/ClientSchema/utilities/ExtractNestedTypes.mjs.map

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

package/dist/esm/ClientSchema/utilities/ResolveField.d.ts

@@ -0,0 +1,29 @@
+import { BaseModelField } from '../../ModelField';
+import { ModelRelationalField, ModelRelationalFieldParamShape } from '../../ModelRelationalField';
+import { EnumType } from '../../EnumType';
+import { CustomType } from '../../CustomType';
+import { RefType, RefTypeParamShape } from '../../RefType';
+import { ResolveRef } from './ResolveRef';
+import { LazyLoader } from '../../runtime';
+/**
+ * Takes a `ReturnType<typeof a.model()>` and turns it into a client-consumable type. Fields
+ * definitions (e.g., `a.string()`) are turned into the client facing types (e.g., `string`),
+ * `a.ref()` fields will be resolved, and relationships (e.g., `a.belongsTo()`) will be
+ * turned into `LazyLoader` fields (e.g., `post.comments({...})`).
+ *
+ * The first type parameter (`Bag`) should always just be the top-level `ClientSchema` that
+ * references and related model definitions can be resolved against.
+ */
+export type ResolveFields<Bag extends Record<string, any>, T> = ShallowPretty<{
+    [K in keyof T as IsRequired<T[K]> extends true ? K : never]: ResolveIndividualField<Bag, T[K]>;
+} & {
+    [K in keyof T as IsRequired<T[K]> extends true ? never : K]+?: ResolveIndividualField<Bag, T[K]>;
+}>;
+type ShallowPretty<T> = {
+    [K in keyof T]: T[K];
+};
+export type ResolveIndividualField<Bag extends Record<string, any>, T> = T extends BaseModelField<infer FieldShape> ? FieldShape : T extends RefType<infer RefShape, any, any> ? ResolveRef<RefShape, Bag> : T extends ModelRelationalField<infer RelationshipShape, any, any, any> ? ResolveRelationship<Bag, RelationshipShape> : T extends CustomType<infer CT> ? ResolveFields<Bag, CT['fields']> | null : T extends EnumType<infer values> ? values[number] | null : never;
+type ResolveRelationship<Bag extends Record<string, any>, RelationshipShape extends ModelRelationalFieldParamShape> = LazyLoader<RelationshipShape['valueRequired'] extends true ? Bag[RelationshipShape['relatedModel']]['type'] : Bag[RelationshipShape['relatedModel']]['type'] | null, RelationshipShape['array']>;
+type IsRequired<T> = T extends BaseModelField<infer FieldShape> ? null extends FieldShape ? false : true : T extends RefType<infer RefShape, any, any> ? IsRefRequired<RefShape> : T extends ModelRelationalField<any, any, any, any> ? true : T extends CustomType<any> | EnumType<any> ? false : never;
+type IsRefRequired<T extends RefTypeParamShape> = T['array'] extends true ? T['arrayRequired'] : T['valueRequired'];
+export {};

package/dist/esm/ClientSchema/utilities/ResolveField.mjs

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

package/dist/esm/ClientSchema/utilities/ResolveField.mjs.map

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