@aws-amplify/data-schema 0.11.0

package/lib-esm/src/MappedTypes/ResolveFieldProperties.d.ts

@@ -0,0 +1,58 @@
+import type { UnionToIntersection, LazyLoader, ExcludeEmpty } from '@aws-amplify/data-schema-types';
+import type { Authorization, ImpliedAuthFields } from '../Authorization';
+import type { ModelField } from '../ModelField';
+import type { ModelType, ModelTypeParamShape } from '../ModelType';
+import type { ModelSchema } from '../ModelSchema';
+import type { ModelRelationalField, ModelRelationalFieldParamShape, ModelRelationalTypeArgFactory } from '../ModelRelationalField';
+import type { AllImpliedFKs } from './ForeignKeys';
+import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
+import type { InjectImplicitModelFields } from './ImplicitFieldInjector';
+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';
+export type ResolveFieldProperties<Schema extends ModelSchema<any>, NonModelTypes extends NonModelTypesShape, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
+    identifier: string;
+}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedModels = InjectImplicitModels<ResolvedSchema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<FieldsWithInjectedModels, IdentifierMeta>, FieldsWithRelationships = ResolveRelationships<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<RequiredFieldTypes<FieldsWithRelationships>>, FilterFieldTypes<OptionalFieldTypes<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>, AllImpliedFKs<ResolvedSchema, IdentifierMeta>>;
+type ExtractImplicitModelNames<Schema> = UnionToIntersection<ExcludeEmpty<{
+    [ModelProp in keyof Schema]: {
+        [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relationName'] extends string ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? never : Schema[ModelProp][FieldProp]['relationName'] : never : never]: {
+            id?: string;
+        } & Record<`${Lowercase<ModelProp & string>}`, ModelRelationalTypeArgFactory<ModelProp & string, 'hasMany', false>>;
+    };
+}[keyof Schema]>>;
+type InjectImplicitModels<Schema> = Schema & ExtractImplicitModelNames<Schema>;
+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];
+};
+type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], Value = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? NonModelTypes['customTypes'][Link] : never> = Ref['required'] extends true ? Value : Value | null;
+type ResolveRelationships<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, never | 'required' | 'authorization', never | Authorization<any, any>> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? Schema[ModelProp][FieldProp]['relationshipType'] extends 'manyToMany' ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relationName'], Schema[ModelProp][FieldProp], Flat> : never : GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
+    };
+};
+type FilterFieldTypes<Schema> = {
+    [ModelProp in keyof Schema]: {
+        [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends undefined ? never : FieldProp]: Schema[ModelProp][FieldProp];
+    };
+};
+type OptionalFieldTypes<Schema> = {
+    [ModelProp in keyof Schema]: Partial<{
+        [FieldProp in keyof Schema[ModelProp]]: null extends Schema[ModelProp][FieldProp] ? Schema[ModelProp][FieldProp] : never;
+    }>;
+};
+type RequiredFieldTypes<Schema> = {
+    [ModelProp in keyof Schema]: {
+        [FieldProp in keyof Schema[ModelProp]]: null extends Schema[ModelProp][FieldProp] ? never : Schema[ModelProp][FieldProp];
+    };
+};
+type Intersection<A, B, C, D> = A & B & C & D extends infer U ? {
+    [P in keyof U]: U[P];
+} : never;
+export type ModelImpliedAuthFields<Schema extends ModelSchema<any>> = {
+    [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape> ? never : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<infer Model, any> ? ImpliedAuthFields<Model['authorization'][number]> & ImpliedAuthFieldsFromFields<Model> : object;
+};
+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> ? ImpliedAuthFields<Auth> : object : object : object>;
+export {};

package/lib-esm/src/MappedTypes/ResolveFieldProperties.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib-esm/src/MappedTypes/ResolveSchema.d.ts

@@ -0,0 +1,35 @@
+import type { ModelType } from '../ModelType';
+import type { ModelSchema } from '../ModelSchema';
+import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
+import type { ModelField } from '../ModelField';
+import type { CustomType, CustomTypeParamShape } from '../CustomType';
+import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { RefType, RefTypeParamShape } from '../RefType';
+import { Authorization } from '../Authorization';
+export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
+export type SchemaTypes<T> = T extends ModelSchema<infer R> ? R['types'] : never;
+/**
+ * Resolves model types
+ *
+ * Removes CustomTypes and Enums from resolved schema.
+ * They are extracted separately in ExtractNonModelTypes.ts and
+ * added to ModelMeta in ClientSchema.ts
+ */
+export type ModelTypes<Schema> = {
+    [Model in keyof Schema as Schema[Model] extends EnumType<EnumTypeParamShape> ? never : Schema[Model] extends CustomType<CustomTypeParamShape> ? never : Model]: Schema[Model] extends ModelType<infer R, any> ? R['fields'] : never;
+};
+/**
+ * Resolves field types
+ *
+ * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
+ */
+export type FieldTypes<T> = {
+    [ModelProp in keyof T]: {
+        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, never | 'required' | 'authorization', never | Authorization<any, any>> ? R['required'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+            link: Capitalize<FieldProp & string>;
+            type: 'ref';
+            required: false;
+            authorization: [];
+        }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : never;
+    };
+};

package/lib-esm/src/MappedTypes/ResolveSchema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib-esm/src/ModelField.d.ts

@@ -0,0 +1,158 @@
+import { Authorization } from './Authorization';
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+export declare const __auth: unique symbol;
+export declare enum ModelFieldType {
+    Id = "ID",
+    String = "String",
+    Integer = "Int",
+    Float = "Float",
+    Boolean = "Boolean",
+    Date = "AWSDate",
+    Time = "AWSTime",
+    DateTime = "AWSDateTime",
+    Timestamp = "AWSTimestamp",
+    Email = "AWSEmail",
+    JSON = "AWSJSON",
+    Phone = "AWSPhone",
+    Url = "AWSURL",
+    IPAddress = "AWSIPAddress"
+}
+export declare enum ModelFieldDataType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Date = "Date",
+    JSON = "any"
+}
+type FieldData = {
+    fieldType: ModelFieldType;
+    required: boolean;
+    array: boolean;
+    arrayRequired: boolean;
+    default: undefined | ModelFieldTypeParamOuter;
+    authorization: Authorization<any, any>[];
+};
+type ModelFieldTypeParamInner = string | number | boolean | Date | null;
+export type ModelFieldTypeParamOuter = ModelFieldTypeParamInner | Array<ModelFieldTypeParamInner> | null;
+/**
+ * Field type arg mutators
+ */
+export type Nullable<T> = T | null;
+export type Required<T> = Exclude<T, null>;
+export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner] ? Array<T> | null : never;
+/**
+ * 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
+ */
+export type ModelField<T extends ModelFieldTypeParamOuter, K extends keyof ModelField<T> = never, Auth = undefined> = Omit<{
+    /**
+     * Marks a field as required.
+     */
+    required(): ModelField<Required<T>, K | 'required'>;
+    /**
+     * Converts a field type definition to an array of the field type.
+     */
+    array(): ModelField<ArrayField<T>, Exclude<K, 'required'> | 'array'>;
+    /**
+     * Sets a default value for the scalar type.
+     * @param value the default value
+     */
+    default(value: ModelFieldTypeParamOuter): ModelField<T, K | 'default'>;
+    /**
+     * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
+     * multiple authorization rules for this field.
+     */
+    authorization<AuthRuleType extends Authorization<any, any>>(rules: AuthRuleType[]): ModelField<T, K | 'authorization', AuthRuleType>;
+}, K> & {
+    [__auth]?: Auth;
+};
+/**
+ * Internal representation of Model Field that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalField = ModelField<ModelFieldTypeParamOuter, never> & {
+    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.
+ * @returns ID field definition
+ */
+export declare function id(): ModelField<Nullable<string>>;
+/**
+ * A string scalar type that is represented server-side as a UTF-8 character sequence.
+ * @returns string field definition
+ */
+export declare function string(): ModelField<Nullable<string>>;
+/**
+ * An integer scalar type with a supported value range between -(2^31) and 2^31-1.
+ * @returns integer field definition
+ */
+export declare function integer(): ModelField<Nullable<number>>;
+/**
+ * A float scalar type following represented server-side as an IEEE 754 floating point value.
+ * @returns float field definition
+ */
+export declare function float(): ModelField<Nullable<number>>;
+/**
+ * A boolean scalar type that can be either true or false.
+ * @returns boolean field definition
+ */
+export declare function boolean(): ModelField<Nullable<boolean>>;
+/**
+ * A date scalar type that is represented server-side as an extended ISO 8601 date string in the format `YYYY-MM-DD`.
+ * @returns date field definition
+ */
+export declare function date(): ModelField<Nullable<string>>;
+/**
+ * A time scalar type that is represented server-side as an extended ISO 8601 time string in the format `hh:mm:ss.sss`.
+ * @returns time field definition
+ */
+export declare function time(): ModelField<Nullable<string>>;
+/**
+ * A date time scalar type that is represented server-side as an extended ISO 8601 date and time string in the format `YYYY-MM-DDThh:mm:ss.sssZ`.
+ * @returns datetime field definition
+ */
+export declare function datetime(): ModelField<Nullable<string>>;
+/**
+ * A timestamp scalar type that is represented by an integer value of the number of seconds before or after `1970-01-01-T00:00Z`.
+ * @returns timestamp field definition
+ */
+export declare function timestamp(): ModelField<Nullable<number>>;
+/**
+ * An email scalar type that is represented server-side in the format `local-part@domain-part` as defined by RFC 822.
+ * @returns email field definition
+ */
+export declare function email(): ModelField<Nullable<string>>;
+/**
+ * A JSON scalar type that is automatically parsed and loaded server-side as maps, lists, or scalar values
+ * rather than as the literal input strings.
+ * @returns JSON field definition
+ */
+export declare function json(): ModelField<Nullable<any>>;
+/**
+ * A phone number scalar type thas is stored as a string server-side. Phone numbers can contain either spaces
+ * or hyphens to separate digit groups. Phone numbers without a country code are assumed to be US/North American numbers adhering
+ * to the North American Numbering Plan.
+ * @returns phone number field definition
+ */
+export declare function phone(): ModelField<Nullable<string>>;
+/**
+ * A URL scalar type as defined by RFC 1738. For example, https://www.amazon.com/dp/B000NZW3KC/ or mailto:example@example.com.
+ * URLs must contain a schema (http, mailto) and can't contain two forward slashes (//) in the path part.
+ * @returns URL field definition
+ */
+export declare function url(): ModelField<Nullable<string>>;
+/**
+ * A valid IPv4 or IPv6 address scalar type. IPv4 addresses are expected in quad-dotted notation (123.12.34.56). IPv6 addresses
+ * are expected in non-bracketed, colon-separated format (1a2b:3c4b:🔢4567). You can include an optional CIDR suffix (123.45.67.89/16)
+ * to indicate subnet mask.
+ * @returns IP address field definition
+ */
+export declare function ipAddress(): ModelField<Nullable<string>>;
+export {};

package/lib-esm/src/ModelField.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipAddress = exports.url = exports.phone = exports.json = exports.email = exports.timestamp = exports.datetime = exports.time = exports.date = exports.boolean = exports.float = exports.integer = exports.string = exports.id = exports.ModelFieldDataType = exports.ModelFieldType = exports.__auth = void 0;
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+exports.__auth = Symbol('__auth');
+var ModelFieldType;
+(function (ModelFieldType) {
+    ModelFieldType["Id"] = "ID";
+    ModelFieldType["String"] = "String";
+    ModelFieldType["Integer"] = "Int";
+    ModelFieldType["Float"] = "Float";
+    ModelFieldType["Boolean"] = "Boolean";
+    ModelFieldType["Date"] = "AWSDate";
+    ModelFieldType["Time"] = "AWSTime";
+    ModelFieldType["DateTime"] = "AWSDateTime";
+    ModelFieldType["Timestamp"] = "AWSTimestamp";
+    ModelFieldType["Email"] = "AWSEmail";
+    ModelFieldType["JSON"] = "AWSJSON";
+    ModelFieldType["Phone"] = "AWSPhone";
+    ModelFieldType["Url"] = "AWSURL";
+    ModelFieldType["IPAddress"] = "AWSIPAddress";
+})(ModelFieldType || (exports.ModelFieldType = ModelFieldType = {}));
+var ModelFieldDataType;
+(function (ModelFieldDataType) {
+    ModelFieldDataType["String"] = "string";
+    ModelFieldDataType["Number"] = "number";
+    ModelFieldDataType["Boolean"] = "boolean";
+    ModelFieldDataType["Date"] = "Date";
+    ModelFieldDataType["JSON"] = "any";
+})(ModelFieldDataType || (exports.ModelFieldDataType = ModelFieldDataType = {}));
+/**
+ * Model Field Implementation
+ *
+ * @typeParam T - holds the JS data type of the field; invoking the public methods changes this type accordingly
+ * @example
+ * string() => T = string | null
+ * string().array() => T = Array<string | null> | null
+ * string().array().required() => T = Array<string | null>
+ * string().required().array().required() => T = Array<string>
+ *
+ * @param fieldType - stores the GraphQL data type of the field
+ */
+function _field(fieldType) {
+    const _meta = {
+        lastInvokedMethod: null,
+    };
+    const data = {
+        fieldType,
+        required: false,
+        array: false,
+        arrayRequired: false,
+        default: undefined,
+        authorization: [],
+    };
+    const builder = {
+        required() {
+            if (_meta.lastInvokedMethod === 'array') {
+                data.arrayRequired = true;
+            }
+            else {
+                data.required = true;
+            }
+            _meta.lastInvokedMethod = 'required';
+            return this;
+        },
+        array() {
+            data.array = true;
+            _meta.lastInvokedMethod = 'array';
+            return this;
+        },
+        default(val) {
+            data.default = val;
+            _meta.lastInvokedMethod = 'default';
+            return this;
+        },
+        authorization(rules) {
+            data.authorization = rules;
+            _meta.lastInvokedMethod = 'authorization';
+            return this;
+        },
+    };
+    // this double cast gives us a Subtyping Constraint i.e., hides `data` from the public API,
+    // but makes it available internally when needed
+    return { ...builder, data };
+}
+/**
+ * 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.
+ * @returns ID field definition
+ */
+function id() {
+    return _field(ModelFieldType.Id);
+}
+exports.id = id;
+/**
+ * A string scalar type that is represented server-side as a UTF-8 character sequence.
+ * @returns string field definition
+ */
+function string() {
+    return _field(ModelFieldType.String);
+}
+exports.string = string;
+/**
+ * An integer scalar type with a supported value range between -(2^31) and 2^31-1.
+ * @returns integer field definition
+ */
+function integer() {
+    return _field(ModelFieldType.Integer);
+}
+exports.integer = integer;
+/**
+ * A float scalar type following represented server-side as an IEEE 754 floating point value.
+ * @returns float field definition
+ */
+function float() {
+    return _field(ModelFieldType.Float);
+}
+exports.float = float;
+/**
+ * A boolean scalar type that can be either true or false.
+ * @returns boolean field definition
+ */
+function boolean() {
+    return _field(ModelFieldType.Boolean);
+}
+exports.boolean = boolean;
+/**
+ * A date scalar type that is represented server-side as an extended ISO 8601 date string in the format `YYYY-MM-DD`.
+ * @returns date field definition
+ */
+function date() {
+    return _field(ModelFieldType.Date);
+}
+exports.date = date;
+/**
+ * A time scalar type that is represented server-side as an extended ISO 8601 time string in the format `hh:mm:ss.sss`.
+ * @returns time field definition
+ */
+function time() {
+    return _field(ModelFieldType.Time);
+}
+exports.time = time;
+/**
+ * A date time scalar type that is represented server-side as an extended ISO 8601 date and time string in the format `YYYY-MM-DDThh:mm:ss.sssZ`.
+ * @returns datetime field definition
+ */
+function datetime() {
+    return _field(ModelFieldType.DateTime);
+}
+exports.datetime = datetime;
+/**
+ * A timestamp scalar type that is represented by an integer value of the number of seconds before or after `1970-01-01-T00:00Z`.
+ * @returns timestamp field definition
+ */
+function timestamp() {
+    return _field(ModelFieldType.Timestamp);
+}
+exports.timestamp = timestamp;
+/**
+ * An email scalar type that is represented server-side in the format `local-part@domain-part` as defined by RFC 822.
+ * @returns email field definition
+ */
+function email() {
+    return _field(ModelFieldType.Email);
+}
+exports.email = email;
+/**
+ * A JSON scalar type that is automatically parsed and loaded server-side as maps, lists, or scalar values
+ * rather than as the literal input strings.
+ * @returns JSON field definition
+ */
+function json() {
+    return _field(ModelFieldType.JSON);
+}
+exports.json = json;
+/**
+ * A phone number scalar type thas is stored as a string server-side. Phone numbers can contain either spaces
+ * or hyphens to separate digit groups. Phone numbers without a country code are assumed to be US/North American numbers adhering
+ * to the North American Numbering Plan.
+ * @returns phone number field definition
+ */
+function phone() {
+    return _field(ModelFieldType.Phone);
+}
+exports.phone = phone;
+/**
+ * A URL scalar type as defined by RFC 1738. For example, https://www.amazon.com/dp/B000NZW3KC/ or mailto:example@example.com.
+ * URLs must contain a schema (http, mailto) and can't contain two forward slashes (//) in the path part.
+ * @returns URL field definition
+ */
+function url() {
+    return _field(ModelFieldType.Url);
+}
+exports.url = url;
+/**
+ * A valid IPv4 or IPv6 address scalar type. IPv4 addresses are expected in quad-dotted notation (123.12.34.56). IPv6 addresses
+ * are expected in non-bracketed, colon-separated format (1a2b:3c4b:🔢4567). You can include an optional CIDR suffix (123.45.67.89/16)
+ * to indicate subnet mask.
+ * @returns IP address field definition
+ */
+function ipAddress() {
+    return _field(ModelFieldType.IPAddress);
+}
+exports.ipAddress = ipAddress;

package/lib-esm/src/ModelRelationalField.d.ts

@@ -0,0 +1,106 @@
+import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { Authorization } from './Authorization';
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+export declare const __auth: unique symbol;
+export declare enum ModelRelationshipTypes {
+    hasOne = "hasOne",
+    hasMany = "hasMany",
+    belongsTo = "belongsTo",
+    manyToMany = "manyToMany"
+}
+type RelationshipTypes = `${ModelRelationshipTypes}`;
+type ModelRelationalFieldData = {
+    fieldType: 'model';
+    type: ModelRelationshipTypes;
+    relatedModel: string;
+    array: boolean;
+    valueRequired: boolean;
+    arrayRequired: boolean;
+    relationName?: string;
+    authorization: Authorization<any, any>[];
+};
+export type ModelRelationalFieldParamShape = {
+    type: 'model';
+    relationshipType: string;
+    relatedModel: string;
+    array: boolean;
+    valueRequired: boolean;
+    arrayRequired: boolean;
+    relationName?: string;
+};
+export type ModelRelationalField<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never, Auth = undefined> = Omit<{
+    /**
+     * When set, it requires the value of the relationship type to be required.
+     */
+    valueRequired(): ModelRelationalField<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'>;
+    /**
+     * When set, it requires the relationship to always return an array value
+     */
+    arrayRequired(): ModelRelationalField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'arrayRequired'>;
+    /**
+     * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
+     * multiple authorization rules for this field.
+     */
+    authorization<AuthRuleType extends Authorization<any, any>>(rules: AuthRuleType[]): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
+}, K> & {
+    [__auth]?: Auth;
+};
+/**
+ * Internal representation of Model Field that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalRelationalField = ModelRelationalField<ModelRelationalFieldParamShape, string, never> & {
+    data: ModelRelationalFieldData;
+};
+export type RelationTypeFunctionOmitMapping<Type extends ModelRelationshipTypes> = Type extends ModelRelationshipTypes.belongsTo ? 'required' | 'arrayRequired' | 'valueRequired' : Type extends ModelRelationshipTypes.hasMany ? 'required' : Type extends ModelRelationshipTypes.hasOne ? 'arrayRequired' | 'valueRequired' : Type extends ModelRelationshipTypes.manyToMany ? 'required' : never;
+export type ModelRelationalTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean, RelationName extends string | undefined = undefined> = {
+    type: 'model';
+    relatedModel: RM;
+    relationshipType: RT;
+    array: IsArray;
+    valueRequired: false;
+    arrayRequired: false;
+    relationName: RelationName;
+};
+/**
+ * Create a one-directional one-to-one relationship between two models using the `hasOne("MODEL_NAME")` method.
+ * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field
+ * unless overwritten with the `identifier()` method.
+ * @param relatedModel the name of the related model
+ * @returns a one-to-one relationship definition
+ */
+export declare function hasOne<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false, undefined>, RM, "valueRequired" | "arrayRequired", undefined>;
+/**
+ * Create a one-directional one-to-many relationship between two models using the `hasMany()` method.
+ * @param relatedModel the name of the related model
+ * @returns a one-to-many relationship definition
+ */
+export declare function hasMany<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true, undefined>, RM, "required", undefined>;
+/**
+ * Make a `hasOne()` or `hasMany()` relationship bi-directional using the `belongsTo()` method.
+ * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from
+ * parent to the related model.
+ * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model
+ * @returns a belong-to relationship definition
+ */
+export declare function belongsTo<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false, undefined>, RM, "required" | "valueRequired" | "arrayRequired", undefined>;
+/**
+ * Create a many-to-many relationship between two models with the manyToMany() method.
+ * Provide a common relationName on both models to join them into a many-to-many relationship.
+ * Under the hood a many-to-many relationship is modeled with a "join table" with corresponding
+ * `hasMany()` relationships between the two related models. You must set the same `manyToMany()`
+ * field on both models of the relationship.
+ * @param relatedModel name of the related model
+ * @param opts pass in the `relationName` that will serve as the join table name for this many-to-many relationship
+ * @returns a many-to-many relationship definition
+ */
+export declare function manyToMany<RM extends string, RN extends string>(relatedModel: RM, opts: {
+    relationName: RN;
+}): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.manyToMany, true, RN>, RM, "required", undefined>;
+export {};