@aws-amplify/data-schema 1.9.2 → 1.10.1

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

@@ -4,7 +4,7 @@ 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 { ModelRelationshipField } from '../../ModelRelationshipField';
 import type { EnumType } from '../../EnumType';
 import type { CustomType, CustomTypeParamShape } from '../../CustomType';
 import type { RefType } from '../../RefType';
@@ -69,7 +69,7 @@ type Not<T extends boolean> = T extends true ? false : true;
  */
 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 ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationshipField<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';
@@ -108,7 +108,7 @@ export type IndexQueryInput<Bag extends Record<string, unknown>, Idx extends Pri
  *       \/
  */
 /**
- * All required fields and relational fields, exclude readonly fields
+ * All required fields and relationship 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];

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

@@ -1,5 +1,5 @@
 import { BaseModelField } from '../../ModelField';
-import { ModelRelationalField, ModelRelationalFieldParamShape } from '../../ModelRelationalField';
+import { ModelRelationshipField, ModelRelationshipFieldParamShape } from '../../ModelRelationshipField';
 import { EnumType } from '../../EnumType';
 import { CustomType } from '../../CustomType';
 import { RefType, RefTypeParamShape } from '../../RefType';
@@ -22,12 +22,12 @@ export type ResolveFields<Bag extends Record<string, any>, T> = ShallowPretty<{
 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;
+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 ModelRelationshipField<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;
 /**
  * Resolves to never if the related model has disabled list or get ops for hasOne/hasMany or belongsTo respectively
  */
-type ResolveRelationship<Bag extends Record<string, any>, RelationshipShape extends ModelRelationalFieldParamShape> = DependentLazyLoaderOpIsAvailable<Bag, RelationshipShape> extends true ? LazyLoader<RelationshipShape['valueRequired'] extends true ? Bag[RelationshipShape['relatedModel']]['type'] : Bag[RelationshipShape['relatedModel']]['type'] | null, RelationshipShape['array']> : never;
-type DependentLazyLoaderOpIsAvailable<Bag extends Record<string, any>, RelationshipShape extends ModelRelationalFieldParamShape> = RelationshipShape['relationshipType'] extends 'hasOne' | 'hasMany' ? 'list' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations'] ? false : true : 'get' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations'] ? false : true;
-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 ResolveRelationship<Bag extends Record<string, any>, RelationshipShape extends ModelRelationshipFieldParamShape> = DependentLazyLoaderOpIsAvailable<Bag, RelationshipShape> extends true ? LazyLoader<RelationshipShape['valueRequired'] extends true ? Bag[RelationshipShape['relatedModel']]['type'] : Bag[RelationshipShape['relatedModel']]['type'] | null, RelationshipShape['array']> : never;
+type DependentLazyLoaderOpIsAvailable<Bag extends Record<string, any>, RelationshipShape extends ModelRelationshipFieldParamShape> = RelationshipShape['relationshipType'] extends 'hasOne' | 'hasMany' ? 'list' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations'] ? false : true : 'get' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations'] ? false : true;
+type IsRequired<T> = T extends BaseModelField<infer FieldShape> ? null extends FieldShape ? false : true : T extends RefType<infer RefShape, any, any> ? IsRefRequired<RefShape> : T extends ModelRelationshipField<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/CustomOperation.d.ts

@@ -51,6 +51,13 @@ export type CustomOperationParamShape = {
     handlers: Handler | null;
     input?: CustomOperationInput;
 };
+/**
+ * Custom operation definition interface
+ *
+ * @param T - The shape of the custom operation
+ * @param K - The keys already defined
+ * @param B - The brand of the custom operation
+ */
 export type CustomOperation<T extends CustomOperationParamShape, K extends keyof CustomOperation<T> = never, B extends CustomOperationBrand = CustomOperationBrand> = Omit<{
     arguments<Arguments extends CustomArguments>(args: Arguments): CustomOperation<SetTypeSubArg<T, 'arguments', Arguments>, K | 'arguments', B>;
     returns<ReturnType extends CustomReturnType>(returnType: ReturnType): CustomOperation<SetTypeSubArg<T, 'returnType', ReturnType>, K | 'returns', B>;

package/dist/esm/CustomType.d.ts

@@ -21,6 +21,11 @@ type InternalCustomTypeData = CustomTypeData & {
 export type CustomTypeParamShape = {
     fields: CustomTypeFields;
 };
+/**
+ * Custom type container
+ *
+ * @param T - The shape of the custom type container
+ */
 export type CustomType<T extends CustomTypeParamShape> = T & Brand<'customType'>;
 /**
  * Internal representation of CustomType that exposes the `data` property.

package/dist/esm/EnumType.d.ts

@@ -3,6 +3,11 @@ type EnumTypeParamShape<values extends readonly string[] = readonly string[]> =
     type: 'enum';
     values: values;
 };
+/**
+ * Enum type definition content
+ *
+ * @param values - The values of the enum
+ */
 export interface EnumType<values extends readonly string[] = readonly string[]> extends EnumTypeParamShape<values> {
     [brandSymbol]: 'enum';
 }

package/dist/esm/Handler.d.ts

@@ -111,7 +111,7 @@ export type FunctionHandler = {
      *     // 3. set the function has the handler
      *     .handler(a.handler.function(echoHandler).async())
      *
-     * @see {@link https://docs.amplify.aws/react/build-a-backend/data/INSERT_PATH_WHEN_READY}
+     * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/#async-function-handlers}
      * @returns A function handler for query / mutation that is asynchronously invoked.
      */
     async(): AsyncFunctionHandler;

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

@@ -1,7 +1,7 @@
 import { type UnionToIntersection, type ExcludeEmpty } from '@aws-amplify/data-schema-types';
 import type { PrimaryIndexIrShape } from '../util';
 import type { ModelType } from '../ModelType';
-import type { ModelRelationalFieldParamShape } from '../ModelRelationalField';
+import type { ModelRelationshipFieldParamShape } from '../ModelRelationshipField';
 export type ModelIdentifier<T> = {
     [Property in keyof T]: T[Property] extends ModelType<infer R, any> ? R['identifier'] extends PrimaryIndexIrShape ? {
         identifier: R['identifier'];
@@ -12,14 +12,14 @@ export type ModelSecondaryIndexes<T> = {
         secondaryIndexes: R['secondaryIndexes'];
     } : never : never;
 };
-export type RelationalMetadata<ResolvedSchema, ResolvedFields extends Record<string, unknown>, IdentifierMeta extends Record<string, {
+export type RelationshipMetadata<ResolvedSchema, ResolvedFields extends Record<string, unknown>, IdentifierMeta extends Record<string, {
     identifier: PrimaryIndexIrShape;
 }>> = UnionToIntersection<ExcludeEmpty<{
     [ModelName in keyof ResolvedSchema]: {
-        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasOne' | 'belongsTo' ? ModelName : never : never]: ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany' ? {
-            relationalInputFields: Partial<Record<`${Uncapitalize<ModelName & string>}`, NormalizeInputFields<ResolvedFields[ModelName & string], ExtractModelIdentifier<ModelName, IdentifierMeta>>>>;
+        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasOne' | 'belongsTo' ? ModelName : never : never]: ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany' ? {
+            relationshipInputFields: Partial<Record<`${Uncapitalize<ModelName & string>}`, NormalizeInputFields<ResolvedFields[ModelName & string], ExtractModelIdentifier<ModelName, IdentifierMeta>>>>;
         } : {
-            relationalInputFields: Partial<Record<Field, NormalizeInputFields<ResolvedFields[ResolvedSchema[ModelName][Field]['relatedModel']], ExtractModelIdentifier<`${Capitalize<Field & string>}`, IdentifierMeta>>>>;
+            relationshipInputFields: Partial<Record<Field, NormalizeInputFields<ResolvedFields[ResolvedSchema[ModelName][Field]['relatedModel']], ExtractModelIdentifier<`${Capitalize<Field & string>}`, IdentifierMeta>>>>;
         } : never : never;
     };
 }[keyof ResolvedSchema]>>;

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

@@ -3,7 +3,7 @@ import type { Authorization, ImpliedAuthFields } from '../Authorization';
 import type { ModelField } from '../ModelField';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
-import type { ModelRelationalField, ModelRelationalFieldParamShape } from '../ModelRelationalField';
+import type { ModelRelationshipField, ModelRelationshipFieldParamShape } from '../ModelRelationshipField';
 import type { PrimaryIndexIrShape } from '../util/';
 import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
 import type { InjectImplicitModelFields } from './ImplicitFieldInjector';
@@ -15,11 +15,11 @@ 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;
-}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema, IdentifierMeta>, FieldsWithRelationships = ResolveModelsRelationalAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>>;
-export type ResolveStaticFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, never>, FieldsWithRelationships = ResolveModelsRelationalAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>>;
-type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationalFieldParamShape, Flat extends boolean, ResolvedModel = ResolveRelationalFieldsForModel<T, RM, Flat>, Model = TypeArg['valueRequired'] extends true ? ResolvedModel : ResolvedModel | null | undefined> = LazyLoader<Model, TypeArg['array']>;
-type ResolveRelationalFieldsForModel<Schema, ModelName extends keyof Schema, Flat extends boolean> = {
-    [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationalFieldParamShape ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelName][FieldName]['relatedModel'], Schema[ModelName][FieldName], Flat> : never : Schema[ModelName][FieldName];
+}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema, IdentifierMeta>, FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>>;
+export type ResolveStaticFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, never>, FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>>;
+type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationshipFieldParamShape, Flat extends boolean, ResolvedModel = ResolveRelationshipFieldsForModel<T, RM, Flat>, Model = TypeArg['valueRequired'] extends true ? ResolvedModel : ResolvedModel | null | undefined> = LazyLoader<Model, TypeArg['array']>;
+type ResolveRelationshipFieldsForModel<Schema, ModelName extends keyof Schema, Flat extends boolean> = {
+    [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationshipFieldParamShape ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelName][FieldName]['relatedModel'], Schema[ModelName][FieldName], Flat> : never : Schema[ModelName][FieldName];
 };
 export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], RefValue = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never, Value = Ref['valueRequired'] extends true ? RefValue : RefValue | null> = ResolveRefValueArrayTraits<Ref, Value>;
 /**
@@ -31,9 +31,9 @@ export type ResolveRefsOfCustomType<NonModelTypes extends NonModelTypesShape, T>
     [Prop in keyof T]: T[Prop] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : T[Prop];
 } extends infer Resolved ? ResolveFieldRequirements<Resolved> : never;
 export type ResolveFieldRequirements<Resolved> = Intersection<ExtractNullableFieldsToOptionalFields<Resolved>, ExtractNonNullableFieldsToRequiredFields<Resolved>>;
-type ResolveModelsRelationalAndRefFields<Schema, NonModelTypes extends NonModelTypesShape, Flat extends boolean = false> = {
+type ResolveModelsRelationshipAndRefFields<Schema, NonModelTypes extends NonModelTypesShape, Flat extends boolean = false> = {
     [ModelProp in keyof Schema]: {
-        [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
+        [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationshipFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
     };
 };
 type FilterFieldTypes<Schema> = {
@@ -60,5 +60,5 @@ export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
     [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>;
+type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationshipField<any, any, any, infer Auth> | RefType<any, any, infer Auth> ? Auth extends Authorization<any, any, any> ? ImpliedAuthFields<Auth> : object : object : object>;
 export {};

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

@@ -1,6 +1,6 @@
 import type { ModelType } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
-import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
+import type { ModelRelationshipField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationshipField';
 import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
 import type { EnumType } from '../EnumType';
@@ -39,14 +39,14 @@ export type FieldTypes<T> = {
             array: false;
             arrayRequired: false;
             authorization: [];
-        }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : never;
+        }> | null : T[ModelProp][FieldProp] extends ModelRelationshipField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : never;
     };
 };
 /**
  * Resolves field types for a CustomType.
  *
  * This utility type is needed in addition to the `FieldTypes` utility type as
- * without checking `ModelRelationalField` can improve ~5% on resolving performance.
+ * without checking `ModelRelationshipField` can improve ~5% on resolving performance.
  *
  * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
  */

package/dist/esm/ModelField.d.ts

@@ -42,6 +42,11 @@ type FieldData = {
     authorization: Authorization<any, any, any>[];
 };
 type ModelFieldTypeParamInner = string | number | boolean | Date | Json | null;
+/**
+ * A precise, recursive Json type blows the type calculation stack without installing
+ * explicit `Json extends T ? short-circuit : ...` type checks all over the place.
+ * We may take that on later. But, this is a good-enough approximation for now.
+ */
 export type Json = null | string | number | boolean | object | any[];
 export type ModelFieldTypeParamOuter = ModelFieldTypeParamInner | Array<ModelFieldTypeParamInner> | null;
 /**

package/dist/esm/{ModelRelationalField.d.ts → ModelRelationshipField.d.ts}

@@ -5,14 +5,17 @@ import { AllowModifier, Authorization } from './Authorization';
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
 export declare const __auth: unique symbol;
-declare const brandName = "modelRelationalField";
+declare const brandName = "modelRelationshipField";
+/**
+ * Model relationship types
+ */
 export declare enum ModelRelationshipTypes {
     hasOne = "hasOne",
     hasMany = "hasMany",
     belongsTo = "belongsTo"
 }
 type RelationshipTypes = `${ModelRelationshipTypes}`;
-type ModelRelationalFieldData = {
+type ModelRelationshipFieldData = {
     fieldType: 'model';
     type: ModelRelationshipTypes;
     relatedModel: string;
@@ -22,7 +25,7 @@ type ModelRelationalFieldData = {
     references: string[];
     authorization: Authorization<any, any, any>[];
 };
-export type ModelRelationalFieldParamShape = {
+export type ModelRelationshipFieldParamShape = {
     type: 'model';
     relationshipType: string;
     relatedModel: string;
@@ -31,33 +34,47 @@ export type ModelRelationalFieldParamShape = {
     references: string[];
     arrayRequired: boolean;
 };
-type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never> = {
+type ModelRelationshipFieldFunctions<T extends ModelRelationshipFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationshipField<T, RM> = never> = {
     /**
      * When set, it requires the value of the relationship type to be required.
      */
-    valueRequired(): ModelRelationalField<SetTypeSubArg<T, 'valueRequired', true>, K | 'valueRequired'>;
+    valueRequired(): ModelRelationshipField<SetTypeSubArg<T, 'valueRequired', true>, K | 'valueRequired'>;
     /**
      * When set, it requires the relationship to always return a value
      */
-    required(): ModelRelationalField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'required'>;
+    required(): ModelRelationshipField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'required'>;
     /**
      * 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: AllowModifier) => AuthRuleType | AuthRuleType[]): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[]): ModelRelationshipField<T, K | 'authorization', K, AuthRuleType>;
 };
-export type ModelRelationalField<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never, Auth = undefined> = Omit<ModelRelationalFieldFunctions<T, RM, K>, K> & {
+/**
+ * Model relationship field definition interface
+ *
+ * @param T - The shape of the model relationship field
+ * @param RM - Adds structural separation with ModelField; easier to identify it when mapping to ClientTypes
+ * @param K - The keys already defined
+ */
+export type ModelRelationshipField<T extends ModelRelationshipFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationshipField<T, RM> = never, Auth = undefined> = Omit<ModelRelationshipFieldFunctions<T, RM, K>, K> & {
     [__auth]?: Auth;
 } & Brand<typeof brandName>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalRelationalField = ModelRelationalField<ModelRelationalFieldParamShape, string, never> & {
-    data: ModelRelationalFieldData;
+export type InternalRelationshipField = ModelRelationshipField<ModelRelationshipFieldParamShape, string, never> & {
+    data: ModelRelationshipFieldData;
 };
 export type RelationTypeFunctionOmitMapping<Type extends ModelRelationshipTypes> = Type extends ModelRelationshipTypes.belongsTo ? 'required' | 'valueRequired' : Type extends ModelRelationshipTypes.hasMany ? 'required' : Type extends ModelRelationshipTypes.hasOne ? 'valueRequired' : never;
-export type ModelRelationalTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean> = {
+/**
+ * Model relationship type definition content
+ *
+ * @param RM - The related model name
+ * @param RT - The relationship type
+ * @param IsArray - Whether the relationship is an array
+ */
+export type ModelRelationshipTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean> = {
     type: 'model';
     relatedModel: RM;
     relationshipType: RT;
@@ -91,7 +108,7 @@ export type ModelRelationalTypeArgFactory<RM extends string, RT extends Relation
  * @param references the field(s) that should be used to reference the related model
  * @returns a one-to-one relationship definition
  */
-export declare function hasOne<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>, RM, "valueRequired", undefined>;
+export declare function hasOne<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>, RM, "valueRequired", undefined>;
 /**
  * Create a one-directional one-to-many relationship between two models using the `hasMany("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
  * @example
@@ -118,7 +135,7 @@ export declare function hasOne<RM extends string>(relatedModel: RM, references:
  * @param references the field(s) that should be used to reference the related model
  * @returns a one-to-many relationship definition
  */
-export declare function hasMany<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>, RM, "required", undefined>;
+export declare function hasMany<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>, RM, "required", undefined>;
 /**
  * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.
  * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from
@@ -166,5 +183,5 @@ export declare function hasMany<RM extends string>(relatedModel: RM, references:
  * @param references the field(s) that should be used to reference the related model
  * @returns a belong-to relationship definition
  */
-export declare function belongsTo<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>, RM, "required" | "valueRequired", undefined>;
+export declare function belongsTo<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>, RM, "required" | "valueRequired", undefined>;
 export {};

package/dist/esm/{ModelRelationalField.mjs → ModelRelationshipField.mjs}

@@ -4,6 +4,9 @@ import { allow } from './Authorization.mjs';
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
 const __auth = Symbol('__auth');
+/**
+ * Model relationship types
+ */
 var ModelRelationshipTypes;
 (function (ModelRelationshipTypes) {
     ModelRelationshipTypes["hasOne"] = "hasOne";
@@ -15,7 +18,7 @@ const relationModifierMap = {
     hasMany: ['valueRequired', 'authorization'],
     hasOne: ['required', 'authorization'],
 };
-function _modelRelationalField(type, relatedModel, references) {
+function _modelRelationshipField(type, relatedModel, references) {
     const data = {
         relatedModel,
         type,
@@ -77,7 +80,7 @@ function _modelRelationalField(type, relatedModel, references) {
  * @returns a one-to-one relationship definition
  */
 function hasOne(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);
 }
 /**
  * Create a one-directional one-to-many relationship between two models using the `hasMany("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
@@ -106,7 +109,7 @@ function hasOne(relatedModel, references) {
  * @returns a one-to-many relationship definition
  */
 function hasMany(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);
 }
 /**
  * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.
@@ -156,8 +159,8 @@ function hasMany(relatedModel, references) {
  * @returns a belong-to relationship definition
  */
 function belongsTo(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);
 }
 
 export { ModelRelationshipTypes, __auth, belongsTo, hasMany, hasOne };
-//# sourceMappingURL=ModelRelationalField.mjs.map
+//# sourceMappingURL=ModelRelationshipField.mjs.map

package/dist/esm/ModelRelationshipField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelRelationshipField.mjs","sources":["../../src/ModelRelationshipField.ts"],"sourcesContent":["import { allow } from './Authorization';\n/**\n * Used to \"attach\" auth types to ModelField without exposing them on the builder.\n */\nexport const __auth = Symbol('__auth');\nconst brandName = 'modelRelationshipField';\n/**\n * Model relationship types\n */\nexport var ModelRelationshipTypes;\n(function (ModelRelationshipTypes) {\n    ModelRelationshipTypes[\"hasOne\"] = \"hasOne\";\n    ModelRelationshipTypes[\"hasMany\"] = \"hasMany\";\n    ModelRelationshipTypes[\"belongsTo\"] = \"belongsTo\";\n})(ModelRelationshipTypes || (ModelRelationshipTypes = {}));\nconst relationshipModifiers = [\n    'required',\n    'valueRequired',\n    'authorization',\n];\nconst relationModifierMap = {\n    belongsTo: ['authorization'],\n    hasMany: ['valueRequired', 'authorization'],\n    hasOne: ['required', 'authorization'],\n};\nfunction _modelRelationshipField(type, relatedModel, references) {\n    const data = {\n        relatedModel,\n        type,\n        fieldType: 'model',\n        array: false,\n        valueRequired: false,\n        arrayRequired: false,\n        references,\n        authorization: [],\n    };\n    data.array = type === 'hasMany';\n    const relationshipBuilderFunctions = {\n        required() {\n            data.arrayRequired = true;\n            return this;\n        },\n        valueRequired() {\n            data.valueRequired = true;\n            return this;\n        },\n        authorization(callback) {\n            const rules = callback(allow);\n            data.authorization = Array.isArray(rules) ? rules : [rules];\n            return this;\n        },\n    };\n    const builder = Object.fromEntries(relationModifierMap[type].map((key) => [\n        key,\n        relationshipBuilderFunctions[key],\n    ]));\n    return {\n        ...builder,\n        data,\n    };\n}\n/**\n * Create one-to-one relationship between two models using the `hasOne(\"MODEL_NAME\", \"REFERENCE_FIELD(s)\")` method.\n * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field\n * unless overwritten with the `identifier()` method.\n * @example\n * const schema = a.schema({\n *   Cart: a.model({\n *     items: a.string().required().array(),\n *     // 1. Create reference field\n *     customerId: a.id(),\n *     // 2. Create relationship field with the reference field\n *     customer: a.belongsTo('Customer', 'customerId'),\n *   }),\n *   Customer: a.model({\n *     name: a.string(),\n *     // 3. Create relationship field with the reference field\n *     //    from the Cart model\n *     activeCart: a.hasOne('Cart', 'customerId')\n *   }),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-a-one-to-one-relationship}\n * @param relatedModel the name of the related model\n * @param references the field(s) that should be used to reference the related model\n * @returns a one-to-one relationship definition\n */\nexport function hasOne(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Create a one-directional one-to-many relationship between two models using the `hasMany(\"MODEL_NAME\", \"REFERENCE_FIELD(s)\")` method.\n * @example\n * const schema = a.schema({\n *   Member: a.model({\n *     name: a.string().required(),\n *     // 1. Create a reference field\n *     teamId: a.id(),\n *     // 2. Create a belongsTo relationship with the reference field\n *     team: a.belongsTo('Team', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n *\n *   Team: a.model({\n *     mantra: a.string().required(),\n *     // 3. Create a hasMany relationship with the reference field\n *     //    from the `Member`s model.\n *     members: a.hasMany('Member', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-one-to-many-relationships}\n * @param relatedModel the name of the related model\n * @param references the field(s) that should be used to reference the related model\n * @returns a one-to-many relationship definition\n */\nexport function hasMany(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.\n * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from\n * parent to the related model.\n *\n * @example\n * // one-to-many relationship\n * const schema = a.schema({\n *   Member: a.model({\n *     name: a.string().required(),\n *     // 1. Create a reference field\n *     teamId: a.id(),\n *     // 2. Create a belongsTo relationship with the reference field\n *     team: a.belongsTo('Team', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n *\n *   Team: a.model({\n *     mantra: a.string().required(),\n *     // 3. Create a hasMany relationship with the reference field\n *     //    from the `Member`s model.\n *     members: a.hasMany('Member', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n * });\n * @example\n * // one-to-one relationship\n * const schema = a.schema({\n *   Cart: a.model({\n *     items: a.string().required().array(),\n *     // 1. Create reference field\n *     customerId: a.id(),\n *     // 2. Create relationship field with the reference field\n *     customer: a.belongsTo('Customer', 'customerId'),\n *   }),\n *   Customer: a.model({\n *     name: a.string(),\n *     // 3. Create relationship field with the reference field\n *     //    from the Cart model\n *     activeCart: a.hasOne('Cart', 'customerId')\n *   }),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/}\n * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model\n * @param references the field(s) that should be used to reference the related model\n * @returns a belong-to relationship definition\n */\nexport function belongsTo(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/ModelSchema.d.ts

@@ -5,7 +5,7 @@ import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type { CustomOperation, CustomOperationParamShape, InternalCustom, MutationCustomOperation, QueryCustomOperation, SubscriptionCustomOperation } from './CustomOperation';
 import { AllowModifier, SchemaAuthorization } from './Authorization';
 import { Brand, RenameUsingTuples } from './util';
-import { ModelRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
+import { ModelRelationshipField, ModelRelationshipFieldParamShape } from './ModelRelationshipField';
 import { ConversationType } from './ai/ConversationType';
 export { ModelType } from './ModelType';
 export { EnumType } from './EnumType';
@@ -50,6 +50,12 @@ export type BaseSchema<T extends ModelSchemaParamShape, IsRDS extends boolean =
     };
 };
 export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<typeof rdsSchemaBrandName | typeof ddbSchemaBrandName>;
+/**
+ * Model schema definition interface
+ *
+ * @param T - The shape of the model schema
+ * @param UsedMethods - The method keys already defined
+ */
 export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'authorization' | 'relationships' = never> = Omit<{
     authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRules | AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
 }, UsedMethods> & BaseSchema<T> & DDBSchemaBrand;
@@ -57,7 +63,7 @@ type RDSModelSchemaFunctions = 'addToSchema' | 'addQueries' | 'addMutations' | '
 type OmitFromEach<Models, Modifier extends string> = {
     [ModelName in keyof Models]: Omit<Models[ModelName], Modifier>;
 };
-type RelationshipTemplate = Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>>;
+type RelationshipTemplate = Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>>;
 export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods extends RDSModelSchemaFunctions = never> = Omit<{
     addToSchema: <AddedTypes extends AddToSchemaContents>(types: AddedTypes) => RDSModelSchema<SetTypeSubArg<T, 'types', T['types'] & AddedTypes>, UsedMethods | 'addToSchema'>;
     /**
@@ -83,7 +89,7 @@ export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods exten
  * Amplify API Next Model Schema shape
  */
 export type ModelSchemaType = ModelSchema<ModelSchemaParamShape>;
-type ModelWithRelationships<Types extends Record<string, any>, Relationships extends ReadonlyArray<Record<string, RelationshipTemplate | undefined>>, ModelName extends keyof Types, RelationshipMap extends UnionToIntersection<Relationships[number]> = UnionToIntersection<Relationships[number]>> = ModelName extends keyof RelationshipMap ? RelationshipMap[ModelName] extends Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>> ? AddRelationshipFieldsToModelTypeFields<Types[ModelName], RelationshipMap[ModelName]> : Types[ModelName] : Types[ModelName];
+type ModelWithRelationships<Types extends Record<string, any>, Relationships extends ReadonlyArray<Record<string, RelationshipTemplate | undefined>>, ModelName extends keyof Types, RelationshipMap extends UnionToIntersection<Relationships[number]> = UnionToIntersection<Relationships[number]>> = ModelName extends keyof RelationshipMap ? RelationshipMap[ModelName] extends Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>> ? AddRelationshipFieldsToModelTypeFields<Types[ModelName], RelationshipMap[ModelName]> : Types[ModelName] : Types[ModelName];
 /**
  * Model Schema type guard
  * @param schema - api-next ModelSchema or string

package/dist/esm/ModelType.d.ts

@@ -1,7 +1,7 @@
 import type { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { type PrimaryIndexIrShape, type SecondaryIndexIrShape } from './util';
 import type { InternalField, BaseModelField } from './ModelField';
-import type { ModelRelationalField, InternalRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
+import type { ModelRelationshipField, InternalRelationshipField, ModelRelationshipFieldParamShape } from './ModelRelationshipField';
 import { type AllowModifier, type Authorization } from './Authorization';
 import type { RefType, RefTypeParamShape } from './RefType';
 import type { EnumType } from './EnumType';
@@ -12,8 +12,8 @@ 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, BaseModelField | ModelRelationalField<any, string, any, any> | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
-type InternalModelFields = Record<string, InternalField | InternalRelationalField>;
+type ModelFields = Record<string, BaseModelField | ModelRelationshipField<any, string, any, any> | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
+type InternalModelFields = Record<string, InternalField | InternalRelationshipField>;
 export type DisableOperationsOptions = 'queries' | 'mutations' | 'subscriptions' | 'list' | 'get' | 'create' | 'update' | 'delete' | 'onCreate' | 'onUpdate' | 'onDelete';
 type ModelData = {
     fields: ModelFields;
@@ -54,9 +54,15 @@ export type ModelTypeParamShape = {
 export type ExtractSecondaryIndexIRFields<T extends ModelTypeParamShape, RequiredOnly extends boolean = false> = {
     [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 AddRelationshipFieldsToModelTypeFields<Model, RelationshipFields extends Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>>> = Model extends ModelType<infer ModelParam extends ModelTypeParamShape, infer HiddenKeys> ? ModelType<SetTypeSubArg<ModelParam, 'fields', ModelParam['fields'] & RelationshipFields>, HiddenKeys> : never;
 export type BaseModelType<T extends ModelTypeParamShape = ModelTypeParamShape> = ModelType<T, UsableModelTypeKey>;
 export type UsableModelTypeKey = methodKeyOf<ModelType>;
+/**
+ * Model type definition interface
+ *
+ * @param T - The shape of the model type
+ * @param UsedMethod - The method keys already defined
+ */
 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'>;
@@ -69,7 +75,7 @@ export type ModelType<T extends ModelTypeParamShape = ModelTypeParamShape, UsedM
  * Used on the complete schema object.
  */
 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>;
+    relationships<Param extends Record<string, ModelRelationshipField<any, string, any, any>> = Record<never, never>>(relationships: Param): Record<ModelName, Param>;
     fields: T extends ModelType<infer R, any> ? R['fields'] : never;
 } : T;
 /**
@@ -85,6 +91,13 @@ export type InternalModel = SchemaModelType<ModelType<ModelTypeParamShape>, stri
  * @returns true if the given value is a ModelSchema
  */
 export declare const isSchemaModelType: (modelType: any | SchemaModelType) => modelType is ModelType<ModelTypeParamShape, "identifier">;
+/**
+ * Model default identifier
+ *
+ * @param pk - primary key
+ * @param sk - secondary key
+ * @param compositeSk - composite secondary key
+ */
 export type ModelDefaultIdentifier = {
     pk: {
         readonly id: string;

package/dist/esm/RefType.d.ts

@@ -21,6 +21,12 @@ export type RefTypeParamShape = {
     authorization: Authorization<any, any, any>[];
 };
 type MutationOperations = 'create' | 'update' | 'delete';
+/**
+ * Reference type definition interface
+ *
+ * @param T - The shape of the reference type
+ * @param K - The keys already defined
+ */
 export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = never, Auth = undefined> = Omit<{
     /**
      * Marks a field as required.