@aws-amplify/data-schema 1.1.5 → 1.1.6

package/dist/cjs/util/Brand.js

@@ -1,8 +1,8 @@
 'use strict';
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = exports.brand = void 0;
-const brandSymbol = Symbol('brand');
+exports.getBrand = exports.brand = exports.brandSymbol = void 0;
+exports.brandSymbol = Symbol('brand');
 /**
  * Create an object of a specific type Brand
  * string branded type.
@@ -18,7 +18,7 @@ const brandSymbol = Symbol('brand');
  */
 function brand(brand) {
     return {
-        [brandSymbol]: brand,
+        [exports.brandSymbol]: brand,
     };
 }
 exports.brand = brand;
@@ -28,7 +28,7 @@ exports.brand = brand;
  * @returns The string brand value
  */
 function getBrand(branded) {
-    return branded[brandSymbol];
+    return branded[exports.brandSymbol];
 }
 exports.getBrand = getBrand;
 //# sourceMappingURL=Brand.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"Brand.js","sources":["../../../src/util/Brand.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getBrand = exports.brand = void 0;\nconst brandSymbol = Symbol('brand');\n/**\n * Create an object of a specific type Brand\n * string branded type.\n *\n * @param brand: The string to Brand onto a simple object\n * @returns A branded empty object\n *\n * @example\n * brand('example') => {[brandSymbol]: 'example'}\n *\n * Which I might use like this:\n * const myType = {content: \"default content\", ...brand<'example'>}\n */\nfunction brand(brand) {\n    return {\n        [brandSymbol]: brand,\n    };\n}\nexports.brand = brand;\n/**\n *\n * @param branded: Branded object\n * @returns The string brand value\n */\nfunction getBrand(branded) {\n    return branded[brandSymbol];\n}\nexports.getBrand = getBrand;\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;AAC1C,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,KAAK,EAAE;AACtB,IAAI,OAAO;AACX,QAAQ,CAAC,WAAW,GAAG,KAAK;AAC5B,KAAK,CAAC;AACN,CAAC;AACD,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;AACtB;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE;AAC3B,IAAI,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;AAChC,CAAC;AACD,OAAO,CAAC,QAAQ,GAAG,QAAQ;;"}
+{"version":3,"file":"Brand.js","sources":["../../../src/util/Brand.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getBrand = exports.brand = exports.brandSymbol = void 0;\nexports.brandSymbol = Symbol('brand');\n/**\n * Create an object of a specific type Brand\n * string branded type.\n *\n * @param brand: The string to Brand onto a simple object\n * @returns A branded empty object\n *\n * @example\n * brand('example') => {[brandSymbol]: 'example'}\n *\n * Which I might use like this:\n * const myType = {content: \"default content\", ...brand<'example'>}\n */\nfunction brand(brand) {\n    return {\n        [exports.brandSymbol]: brand,\n    };\n}\nexports.brand = brand;\n/**\n *\n * @param branded: Branded object\n * @returns The string brand value\n */\nfunction getBrand(branded) {\n    return branded[exports.brandSymbol];\n}\nexports.getBrand = getBrand;\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC;AAChE,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,KAAK,CAAC,KAAK,EAAE;AACtB,IAAI,OAAO;AACX,QAAQ,CAAC,OAAO,CAAC,WAAW,GAAG,KAAK;AACpC,KAAK,CAAC;AACN,CAAC;AACD,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;AACtB;AACA;AACA;AACA;AACA;AACA,SAAS,QAAQ,CAAC,OAAO,EAAE;AAC3B,IAAI,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;AACxC,CAAC;AACD,OAAO,CAAC,QAAQ,GAAG,QAAQ;;"}

package/dist/cjs/util/usedMethods.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"usedMethods.js","sources":["../../../src/util/usedMethods.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/CustomOperation.d.ts

@@ -1,16 +1,16 @@
 import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { Brand } from './util';
-import { ModelField, InternalField } from './ModelField';
+import { InternalField, type BaseModelField } from './ModelField';
 import { AllowModifierForCustomOperation, Authorization } from './Authorization';
 import { RefType, InternalRef } from './RefType';
-import { EnumType, EnumTypeParamShape } from './EnumType';
+import { EnumType } from './EnumType';
 import { CustomType } from './CustomType';
 import type { CustomHandler, FunctionHandler, HandlerType as Handler } from './Handler';
 declare const queryBrand = "queryCustomOperation";
 declare const mutationBrand = "mutationCustomOperation";
 declare const subscriptionBrand = "subscriptionCustomOperation";
 type CustomOperationBrand = typeof queryBrand | typeof mutationBrand | typeof subscriptionBrand;
-type CustomArguments = Record<string, ModelField<any, any> | EnumType<EnumTypeParamShape>>;
+type CustomArguments = Record<string, BaseModelField | EnumType>;
 type SubscriptionSource = RefType<any, any>;
 type InternalSubscriptionSource = InternalRef;
 type CustomReturnType = RefType<any> | CustomType<any>;

package/dist/esm/CustomType.d.ts

@@ -1,7 +1,7 @@
 import type { Brand } from './util';
-import type { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
+import type { InternalField, BaseModelField } from './ModelField';
 import type { RefType } from './RefType';
-import type { EnumType, EnumTypeParamShape } from './EnumType';
+import type { EnumType } from './EnumType';
 /**
  * Custom Types
  *
@@ -9,7 +9,7 @@ import type { EnumType, EnumTypeParamShape } from './EnumType';
  *
  */
 export type CustomTypeAllowedModifiers = 'authorization' | 'array' | 'required';
-type CustomTypeFields = Record<string, ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any> | RefType<any, any, any> | EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape>>;
+type CustomTypeFields = Record<string, BaseModelField | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
 type InternalModelFields = Record<string, InternalField>;
 type CustomTypeData = {
     fields: CustomTypeFields;

package/dist/esm/EnumType.d.ts

@@ -1,15 +1,13 @@
-import { Brand } from './util';
-export type EnumTypeParamShape = {
+import type { brandSymbol } from './util/Brand.js';
+type EnumTypeParamShape<values extends readonly string[] = readonly string[]> = {
     type: 'enum';
-    values: readonly string[];
-};
-export type EnumType<T extends EnumTypeParamShape> = T & Brand<'enum'>;
-type EnumTypeArgFactory<Values extends readonly string[]> = {
-    type: 'enum';
-    values: Values;
+    values: values;
 };
+export interface EnumType<values extends readonly string[] = readonly string[]> extends EnumTypeParamShape<values> {
+    [brandSymbol]: 'enum';
+}
 /**
  * this type param pattern allows us to infer literal type values from the array without using the `as const` suffix
  */
-export declare function enumType<Value extends string, T extends readonly Value[]>(values: T): EnumType<EnumTypeArgFactory<T>>;
+export declare function enumType<const values extends readonly string[]>(values: values): EnumType<values>;
 export {};

package/dist/esm/MappedTypes/CustomOperations.d.ts

@@ -1,7 +1,7 @@
 import type { GenericModelSchema } from '../ModelSchema';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { ResolveFieldRequirements, ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
 import type { AppSyncResolverHandler } from 'aws-lambda';
@@ -30,14 +30,14 @@ export type CustomOpShapes<Schema extends GenericModelSchema<any>> = {
  * Digs out custom operation arguments, mapped to the intended graphql types.
  */
 export type CustomOpArguments<Shape extends CustomOperationParamShape> = Shape['arguments'] extends null ? never : ResolveFieldRequirements<{
-    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends ModelField<infer R, any, any> ? R : never;
+    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<infer R> ? R : never;
 }>;
 /**
  * Computes the return type from the `returnType` of a custom operation shape.
  *
  * This entails dereferencing refs and inferring graphql types from field-type defs.
  */
-export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[RefShape['link']], FullyResolvedSchema, NonModelTypes, CustomOperations> : ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes, CustomOperations> : Shape['returnType'] extends ModelField<infer R, any, any> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
+export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[RefShape['link']], FullyResolvedSchema, NonModelTypes, CustomOperations> : ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes, CustomOperations> : Shape['returnType'] extends BaseModelField<infer R> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
     thisCustomType: R['fields'];
 }>['thisCustomType']> | null : never;
 /**

package/dist/esm/MappedTypes/ExtractNonModelTypes.d.ts

@@ -1,10 +1,10 @@
 import type { UnionToIntersection } from '@aws-amplify/data-schema-types';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { SchemaTypes, ModelAndCustomTypes, FieldTypesOfCustomType } from './ResolveSchema';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 export type NonModelTypesShape = {
-    enums: Record<string, EnumType<any>>;
+    enums: Record<string, any>;
     customTypes: Record<string, any>;
 };
 export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModelTypes<Schema, ExtractImplicitNonModelTypes<Schema>>>;
@@ -40,7 +40,7 @@ export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModel
  * ```
  */
 export type ExtractAndFlattenImplicitNonModelTypesFromFields<ParentTypeName extends string, Fields> = {
-    [FieldProp in keyof Fields as Fields[FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? FieldProp : never]: (x: NonNullable<Fields[FieldProp]> extends infer FieldType ? FieldType extends EnumType<EnumTypeParamShape> ? {
+    [FieldProp in keyof Fields as Fields[FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? FieldProp : never]: (x: NonNullable<Fields[FieldProp]> extends infer FieldType ? FieldType extends EnumType ? {
         [Key in `${ParentTypeName}${Capitalize<FieldProp & string>}`]: Fields[FieldProp];
     } : FieldType extends CustomType<infer CustomTypeShape extends CustomTypeParamShape> ? // recursively extract to the Nested CustomType, and return the
     ExtractAndFlattenImplicitNonModelTypesFromFields<`${ParentTypeName}${Capitalize<FieldProp & string>}`, CustomTypeShape['fields']> & {
@@ -60,7 +60,7 @@ export type ExtractImplicitNonModelTypes<Schema, Targets = ModelAndCustomTypes<S
 }[keyof Targets]>;
 type ResolveNonModelTypes<Schema, Extracted, ResolvedSchema = SchemaTypes<Schema> & Extracted> = {
     enums: {
-        [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType<EnumTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends EnumType<infer R extends EnumTypeParamShape> ? R['values'][number] : never;
+        [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType ? Model : never]: ResolvedSchema[Model] extends EnumType<infer values> ? values[number] : never;
     };
     customTypes: {
         [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends CustomType<CustomTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends CustomType<infer R extends CustomTypeParamShape> ? R['fields'] : never;

package/dist/esm/MappedTypes/ResolveFieldProperties.d.ts

@@ -11,7 +11,7 @@ import type { ModelIdentifier } from './ModelMetadata';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
     identifier: PrimaryIndexIrShape;
@@ -57,7 +57,7 @@ type Intersection<A = Record<never, never>, B = Record<never, never>, C = Record
     [P in keyof U]: U[P];
 } : never;
 export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
-    [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomOperation<CustomOperationParamShape, any> ? never : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<infer Model, any> ? AllAuthFieldsForModel<Schema, Model> : object;
+    [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType ? never : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomOperation<CustomOperationParamShape, any> ? never : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<infer Model, any> ? AllAuthFieldsForModel<Schema, Model> : object;
 };
 type AllAuthFieldsForModel<Schema extends GenericModelSchema<any>, Model extends Schema['data']['types'][keyof Schema['data']['types']]> = (Model['authorization'][number] extends never ? Schema['data']['authorization'][number] extends never ? object : ImpliedAuthFields<Schema['data']['authorization'][number]> : 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>;

package/dist/esm/MappedTypes/ResolveSchema.d.ts

@@ -1,9 +1,9 @@
 import type { ModelType } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
 import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
@@ -16,14 +16,14 @@ export type SchemaTypes<T> = T extends GenericModelSchema<any> ? T['data']['type
  * added to ModelMeta in ClientSchema.ts
  */
 export type ModelTypes<Schema> = {
-    [Model in keyof Schema as Schema[Model] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<infer R, any> ? R['fields'] : never;
+    [Model in keyof Schema as Schema[Model] extends EnumType | CustomType<CustomTypeParamShape> | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<infer R, any> ? R['fields'] : never;
 };
 /**
  * Gets the collection of all ModelTypes and CustomTypes which are explicitly
  * defined in the schema.
  */
 export type ModelAndCustomTypes<Schema> = {
-    [Model in keyof Schema as Schema[Model] extends EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<any, any> ? Schema[Model] : Schema[Model] extends CustomType<CustomTypeParamShape> ? Schema[Model] : never;
+    [Model in keyof Schema as Schema[Model] extends EnumType | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<any, any> | CustomType<CustomTypeParamShape> ? Schema[Model] : never;
 };
 /**
  * Resolves field types
@@ -32,7 +32,7 @@ export type ModelAndCustomTypes<Schema> = {
  */
 export type FieldTypes<T> = {
     [ModelProp in keyof T]: {
-        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends BaseModelField<infer R> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<ModelProp & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             valueRequired: false;
@@ -52,7 +52,7 @@ export type FieldTypes<T> = {
  */
 export type FieldTypesOfCustomType<T> = {
     [CustomTypeName in keyof T]: {
-        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<infer R, any, any> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends BaseModelField<infer R> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<CustomTypeName & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             valueRequired: false;

package/dist/esm/ModelField.d.ts

@@ -1,5 +1,6 @@
-import { Brand } from './util';
 import { AllowModifier, Authorization } from './Authorization';
+import type { methodKeyOf, satisfy } from './util/usedMethods.js';
+import type { brandSymbol } from './util/Brand.js';
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
@@ -45,42 +46,44 @@ export type ModelFieldTypeParamOuter = ModelFieldTypeParamInner | Array<ModelFie
 export type Nullable<T> = T | null;
 export type Required<T> = Exclude<T, null>;
 export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner] ? Array<T> | null : never;
+export type BaseModelField<T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter> = ModelField<T, UsableModelFieldKey, any>;
+export type UsableModelFieldKey = satisfy<methodKeyOf<ModelField>, 'required' | 'default' | 'authorization'>;
 /**
  * Public API for the chainable builder methods exposed by Model Field.
  * The type is narrowing e.g., after calling .array() it will be omitted from intellisense suggestions
  *
  * @typeParam T - holds the JS data type of the field
- * @typeParam K - union of strings representing already-invoked method names. Used to improve Intellisense
+ * @typeParam UsedMethod - union of strings representing already-invoked method names. Used to improve Intellisense
  */
-export type ModelField<T extends ModelFieldTypeParamOuter, K extends keyof ModelField<T> = never, Auth = undefined> = Omit<{
+export type ModelField<T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter, UsedMethod extends UsableModelFieldKey = never, Auth = undefined> = Omit<{
+    [__auth]?: Auth;
+    [brandSymbol]: typeof brandName;
     /**
      * Marks a field as required.
      */
-    required(): ModelField<Required<T>, K | 'required'>;
+    required(): ModelField<Required<T>, UsedMethod | 'required'>;
     /**
      * Converts a field type definition to an array of the field type.
      */
-    array(): ModelField<ArrayField<T>, Exclude<K, 'required'> | 'array'>;
+    array(): ModelField<ArrayField<T>, Exclude<UsedMethod, 'required'>>;
     /**
      * Sets a default value for the scalar type.
      * @param value the default value
      */
-    default(value: ModelFieldTypeParamOuter): ModelField<T, K | 'default'>;
+    default(value: ModelFieldTypeParamOuter): ModelField<T, UsedMethod | 'default'>;
     /**
      * Configures field-level authorization rules. Pass in an array of authorizations `(allow => allow.____)` to mix and match
      * multiple authorization rules for this field.
      */
-    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelField<T, K | 'authorization', AuthRuleType>;
-}, K> & {
-    [__auth]?: Auth;
-} & Brand<typeof brandName>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelField<T, UsedMethod | 'authorization', AuthRuleType>;
+}, UsedMethod>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalField = ModelField<ModelFieldTypeParamOuter, never> & {
+export interface InternalField extends ModelField {
     data: FieldData;
-};
+}
 /**
  * A unique identifier scalar type. This scalar is serialized like a String but isn't meant to be human-readable.
  * If not specified on create operations, a ULID will be auto-generated service-side.

package/dist/esm/ModelSchema.d.ts

@@ -1,6 +1,6 @@
 import type { DerivedApiDefinition, SetTypeSubArg, SchemaConfiguration, DataSourceConfiguration, DatasourceEngine, UnionToIntersection } from '@aws-amplify/data-schema-types';
-import { type ModelType, type ModelTypeParamShape, type InternalModel, SchemaModelType, AddRelationshipFieldsToModelTypeFields } from './ModelType';
-import type { EnumType, EnumTypeParamShape } from './EnumType';
+import { type InternalModel, SchemaModelType, AddRelationshipFieldsToModelTypeFields, type BaseModelType } from './ModelType';
+import type { EnumType } from './EnumType';
 import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type { CustomOperation, CustomOperationParamShape, InternalCustom, MutationCustomOperation, QueryCustomOperation, SubscriptionCustomOperation } from './CustomOperation';
 import { AllowModifier, SchemaAuthorization } from './Authorization';
@@ -11,7 +11,7 @@ export declare const rdsSchemaBrand: Brand<"RDSSchema">;
 export type RDSSchemaBrand = Brand<typeof rdsSchemaBrandName>;
 export declare const ddbSchemaBrandName = "DDBSchema";
 export type DDBSchemaBrand = Brand<typeof ddbSchemaBrandName>;
-type SchemaContent = ModelType<ModelTypeParamShape, any> | CustomType<CustomTypeParamShape> | EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any>;
+type SchemaContent = BaseModelType | CustomType<CustomTypeParamShape> | EnumType | CustomOperation<CustomOperationParamShape, any>;
 type NonEmpty<T> = keyof T extends never ? never : T;
 type ModelSchemaContents = Record<string, SchemaContent>;
 type InternalSchemaModels = Record<string, InternalModel | EnumType<any> | CustomType<any> | InternalCustom>;
@@ -31,7 +31,7 @@ export type InternalSchema = {
 export type BaseSchema<T extends ModelSchemaParamShape, IsRDS extends boolean = false> = {
     data: T;
     models: {
-        [TypeKey in keyof T['types']]: T['types'][TypeKey] extends ModelType<ModelTypeParamShape, never | 'identifier'> ? SchemaModelType<T['types'][TypeKey], TypeKey & string, IsRDS> : never;
+        [TypeKey in keyof T['types']]: T['types'][TypeKey] extends BaseModelType ? SchemaModelType<T['types'][TypeKey], TypeKey & string, IsRDS> : never;
     };
     transform: () => DerivedApiDefinition;
 };

package/dist/esm/ModelType.d.ts

@@ -1,17 +1,18 @@
 import type { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import type { PrimaryIndexIrShape, SecondaryIndexIrShape } from './runtime';
-import { type Brand } from './util';
-import type { ModelField, InternalField } from './ModelField';
+import type { InternalField, BaseModelField } from './ModelField';
 import type { ModelRelationalField, InternalRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
 import { type AllowModifier, type Authorization } from './Authorization';
 import type { RefType, RefTypeParamShape } from './RefType';
-import type { EnumType, EnumTypeParamShape } from './EnumType';
+import type { EnumType } from './EnumType';
 import type { CustomType, CustomTypeParamShape } from './CustomType';
 import { type ModelIndexType, type InternalModelIndexType } from './ModelIndex';
 import type { PrimaryIndexFieldsToIR, SecondaryIndexToIR } from './MappedTypes/MapIndexes';
+import type { brandSymbol } from './util/Brand.js';
+import type { methodKeyOf } from './util/usedMethods.js';
 declare const brandName = "modelType";
 export type deferredRefResolvingPrefix = 'deferredRefResolving:';
-type ModelFields = Record<string, ModelField<any, any, any> | ModelRelationalField<any, string, any, any> | RefType<any, any, any> | EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape>>;
+type ModelFields = Record<string, BaseModelField | ModelRelationalField<any, string, any, any> | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
 type InternalModelFields = Record<string, InternalField | InternalRelationalField>;
 type ModelData = {
     fields: ModelFields;
@@ -47,21 +48,24 @@ export type ModelTypeParamShape = {
  * packages/data-schema/src/runtime/client/index.ts
  */
 export type ExtractSecondaryIndexIRFields<T extends ModelTypeParamShape, RequiredOnly extends boolean = false> = {
-    [FieldProp in keyof T['fields'] as T['fields'][FieldProp] extends ModelField<infer R, any, any> ? NonNullable<R> extends string | number ? RequiredOnly extends false ? FieldProp : null extends R ? never : FieldProp : never : T['fields'][FieldProp] extends EnumType<EnumTypeParamShape> | RefType<RefTypeParamShape, any, any> ? FieldProp : never]: T['fields'][FieldProp] extends ModelField<infer R, any, any> ? R : T['fields'][FieldProp] extends EnumType<infer R> ? R['values'][number] : T['fields'][FieldProp] extends RefType<infer R, any, any> ? `${deferredRefResolvingPrefix}${R['link']}` : never;
+    [FieldProp in keyof T['fields'] as T['fields'][FieldProp] extends BaseModelField<infer R> ? NonNullable<R> extends string | number ? RequiredOnly extends false ? FieldProp : null extends R ? never : FieldProp : never : T['fields'][FieldProp] extends EnumType | RefType<RefTypeParamShape, any, any> ? FieldProp : never]: T['fields'][FieldProp] extends BaseModelField<infer R> ? R : T['fields'][FieldProp] extends EnumType<infer values> ? values[number] : T['fields'][FieldProp] extends RefType<infer R, any, any> ? `${deferredRefResolvingPrefix}${R['link']}` : never;
 };
 export type AddRelationshipFieldsToModelTypeFields<Model, RelationshipFields extends Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>>> = Model extends ModelType<infer ModelParam extends ModelTypeParamShape, infer HiddenKeys> ? ModelType<SetTypeSubArg<ModelParam, 'fields', ModelParam['fields'] & RelationshipFields>, HiddenKeys> : never;
-export type ModelType<T extends ModelTypeParamShape, K extends keyof ModelType<T> = never> = Omit<{
-    identifier<PrimaryIndexFields = ExtractSecondaryIndexIRFields<T, true>, PrimaryIndexPool extends string = keyof PrimaryIndexFields & string, const ID extends ReadonlyArray<PrimaryIndexPool> = readonly [], const PrimaryIndexIR extends PrimaryIndexIrShape = PrimaryIndexFieldsToIR<ID, PrimaryIndexFields>>(identifier: ID): ModelType<SetTypeSubArg<T, 'identifier', PrimaryIndexIR>, K | 'identifier'>;
-    secondaryIndexes<const SecondaryIndexFields = ExtractSecondaryIndexIRFields<T>, const SecondaryIndexPKPool extends string = keyof SecondaryIndexFields & string, const Indexes extends readonly ModelIndexType<string, string, unknown, readonly [], any>[] = readonly [], const IndexesIR extends readonly any[] = SecondaryIndexToIR<Indexes, SecondaryIndexFields>>(callback: (index: <PK extends SecondaryIndexPKPool>(pk: PK) => ModelIndexType<SecondaryIndexPKPool, PK, ReadonlyArray<Exclude<SecondaryIndexPKPool, PK>>>) => Indexes): ModelType<SetTypeSubArg<T, 'secondaryIndexes', IndexesIR>, K | 'secondaryIndexes'>;
-    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
-}, K> & Brand<typeof brandName>;
+export type BaseModelType<T extends ModelTypeParamShape = ModelTypeParamShape> = ModelType<T, UsableModelTypeKey>;
+export type UsableModelTypeKey = methodKeyOf<ModelType>;
+export type ModelType<T extends ModelTypeParamShape = ModelTypeParamShape, UsedMethod extends UsableModelTypeKey = never> = Omit<{
+    [brandSymbol]: typeof brandName;
+    identifier<PrimaryIndexFields = ExtractSecondaryIndexIRFields<T, true>, PrimaryIndexPool extends string = keyof PrimaryIndexFields & string, const ID extends ReadonlyArray<PrimaryIndexPool> = readonly [], const PrimaryIndexIR extends PrimaryIndexIrShape = PrimaryIndexFieldsToIR<ID, PrimaryIndexFields>>(identifier: ID): ModelType<SetTypeSubArg<T, 'identifier', PrimaryIndexIR>, UsedMethod | 'identifier'>;
+    secondaryIndexes<const SecondaryIndexFields = ExtractSecondaryIndexIRFields<T>, const SecondaryIndexPKPool extends string = keyof SecondaryIndexFields & string, const Indexes extends readonly ModelIndexType<string, string, unknown, readonly [], any>[] = readonly [], const IndexesIR extends readonly any[] = SecondaryIndexToIR<Indexes, SecondaryIndexFields>>(callback: (index: <PK extends SecondaryIndexPKPool>(pk: PK) => ModelIndexType<SecondaryIndexPKPool, PK, ReadonlyArray<Exclude<SecondaryIndexPKPool, PK>>>) => Indexes): ModelType<SetTypeSubArg<T, 'secondaryIndexes', IndexesIR>, UsedMethod | 'secondaryIndexes'>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, UsedMethod | 'authorization'>;
+}, UsedMethod>;
 /**
  * External representation of Model Type that exposes the `relationships` modifier.
  * Used on the complete schema object.
  */
-export type SchemaModelType<T extends ModelType<ModelTypeParamShape, never | 'identifier'> = ModelType<ModelTypeParamShape, never | 'identifier'>, ModelName extends string = string, IsRDS extends boolean = false> = IsRDS extends true ? T & {
+export type SchemaModelType<T extends BaseModelType = ModelType<ModelTypeParamShape, 'identifier'>, ModelName extends string = string, IsRDS extends boolean = false> = IsRDS extends true ? T & {
     relationships<Param extends Record<string, ModelRelationalField<any, string, any, any>> = Record<never, never>>(relationships: Param): Record<ModelName, Param>;
-    fields: T extends ModelType<infer R extends ModelTypeParamShape, any> ? R['fields'] : never;
+    fields: T extends ModelType<infer R, any> ? R['fields'] : never;
 } : T;
 /**
  * Internal representation of Model Type that exposes the `data` property.

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

@@ -1,4 +1,4 @@
-declare const brandSymbol: unique symbol;
+export declare const brandSymbol: unique symbol;
 /**
  * @typeParam BrandStr - String type to brand this object with
  * @returns A branded empty object type
@@ -32,4 +32,3 @@ export declare function brand<BrandStr extends string>(brand: BrandStr): Brand<B
  * @returns The string brand value
  */
 export declare function getBrand(branded: Brand<string>): string;
-export {};

package/dist/esm/util/Brand.mjs

@@ -26,5 +26,5 @@ function getBrand(branded) {
     return branded[brandSymbol];
 }
 
-export { brand, getBrand };
+export { brand, brandSymbol, getBrand };
 //# sourceMappingURL=Brand.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"Brand.mjs","sources":["../../../src/util/Brand.ts"],"sourcesContent":["const brandSymbol = Symbol('brand');\n/**\n * Create an object of a specific type Brand\n * string branded type.\n *\n * @param brand: The string to Brand onto a simple object\n * @returns A branded empty object\n *\n * @example\n * brand('example') => {[brandSymbol]: 'example'}\n *\n * Which I might use like this:\n * const myType = {content: \"default content\", ...brand<'example'>}\n */\nexport function brand(brand) {\n    return {\n        [brandSymbol]: brand,\n    };\n}\n/**\n *\n * @param branded: Branded object\n * @returns The string brand value\n */\nexport function getBrand(branded) {\n    return branded[brandSymbol];\n}\n"],"names":[],"mappings":"AAAA,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,KAAK,CAAC,KAAK,EAAE;AAC7B,IAAI,OAAO;AACX,QAAQ,CAAC,WAAW,GAAG,KAAK;AAC5B,KAAK,CAAC;AACN,CAAC;AACD;AACA;AACA;AACA;AACA;AACO,SAAS,QAAQ,CAAC,OAAO,EAAE;AAClC,IAAI,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;AAChC;;;;"}
+{"version":3,"file":"Brand.mjs","sources":["../../../src/util/Brand.ts"],"sourcesContent":["export const brandSymbol = Symbol('brand');\n/**\n * Create an object of a specific type Brand\n * string branded type.\n *\n * @param brand: The string to Brand onto a simple object\n * @returns A branded empty object\n *\n * @example\n * brand('example') => {[brandSymbol]: 'example'}\n *\n * Which I might use like this:\n * const myType = {content: \"default content\", ...brand<'example'>}\n */\nexport function brand(brand) {\n    return {\n        [brandSymbol]: brand,\n    };\n}\n/**\n *\n * @param branded: Branded object\n * @returns The string brand value\n */\nexport function getBrand(branded) {\n    return branded[brandSymbol];\n}\n"],"names":[],"mappings":"AAAY,MAAC,WAAW,GAAG,MAAM,CAAC,OAAO,EAAE;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,KAAK,CAAC,KAAK,EAAE;AAC7B,IAAI,OAAO;AACX,QAAQ,CAAC,WAAW,GAAG,KAAK;AAC5B,KAAK,CAAC;AACN,CAAC;AACD;AACA;AACA;AACA;AACA;AACO,SAAS,QAAQ,CAAC,OAAO,EAAE;AAClC,IAAI,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;AAChC;;;;"}

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

@@ -0,0 +1,4 @@
+export type methodKeyOf<o> = {
+    [k in keyof o]-?: o[k] extends (...args: never) => unknown ? k : never;
+}[keyof o];
+export type satisfy<base, t extends base> = t;

package/dist/esm/util/usedMethods.mjs

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

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

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