@aws-amplify/data-schema 1.1.4 → 1.1.6

package/src/CustomOperation.ts

@@ -1,14 +1,13 @@
 import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { Brand, brand } from './util';
-
-import { ModelField, InternalField } from './ModelField';
+import { InternalField, type BaseModelField } from './ModelField';
 import {
   AllowModifierForCustomOperation,
   Authorization,
   allowForCustomOperations,
 } from './Authorization';
 import { RefType, InternalRef } from './RefType';
-import { EnumType, EnumTypeParamShape } from './EnumType';
+import { EnumType } from './EnumType';
 import { CustomType } from './CustomType';
 import type {
   CustomHandler,
@@ -25,10 +24,7 @@ type CustomOperationBrand =
   | 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;
@@ -202,6 +198,26 @@ export type QueryCustomOperation = CustomOperation<
   typeof queryBrand
 >;
 
+/**
+ * Use a custom query to define an API request that will retrieve backend data.
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}
+ * @example
+ * const schema = a.schema({
+ *   echo: a
+ *     .query()
+ *     .arguments({ content: a.string() })
+ *     .returns(a.ref('EchoResponse'))
+ *     .authorization(allow => [allow.publicApiKey()])
+ *     // 3. set the function has the handler
+ *     .handler(a.handler.function(echoHandler)),
+ * 
+ *   EchoResponse: a.customType({
+ *     content: a.string(),
+ *     executionDuration: a.float()
+ *   }),
+ * });
+ * @returns a custom query
+ */
 export function query(): CustomOperation<
   {
     arguments: null;
@@ -222,6 +238,18 @@ export type MutationCustomOperation = CustomOperation<
   typeof mutationBrand
 >;
 
+/**
+ * Use a custom mutation to define an API request that will modify backend data or trigger a subscription event.
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}
+ * @example
+ * likePost: a
+ *   .mutation()
+ *   .arguments({ postId: a.string() })
+ *   .returns(a.ref('Post'))
+ *   .authorization(allow => [allow.publicApiKey()])
+ *   .handler(a.handler.function(echoHandler))
+ * @returns a custom mutation
+ */
 export function mutation(): CustomOperation<
   {
     arguments: null;
@@ -242,6 +270,20 @@ export type SubscriptionCustomOperation = CustomOperation<
   typeof subscriptionBrand
 >;
 
+/**
+ * Define a custom subscription to receive an event when a mutation is triggered
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-subscription/}
+ * @example
+ * // Subscribe to incoming messages
+ * receive: a.subscription()
+ *   // subscribes to the 'publish' mutation
+ *   .for(a.ref('publish')) 
+ *   // subscription handler to set custom filters
+ *   .handler(a.handler.custom({entry: './receive.js'})) 
+ *   // authorization rules as to who can subscribe to the data
+ *   .authorization(allow => [allow.publicApiKey()]),
+ * @returns a custom subscription
+ */
 export function subscription(): CustomOperation<
   {
     arguments: null;

package/src/CustomType.ts

@@ -1,11 +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
@@ -19,9 +15,9 @@ export type CustomTypeAllowedModifiers = 'authorization' | 'array' | 'required';
 
 type CustomTypeFields = Record<
   string,
-  | ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any>
+  | BaseModelField
   | RefType<any, any, any>
-  | EnumType<EnumTypeParamShape>
+  | EnumType
   | CustomType<CustomTypeParamShape>
 >;
 
@@ -60,6 +56,38 @@ function _customType<T extends CustomTypeParamShape>(fields: T['fields']) {
   return { data } as InternalCustomType as CustomType<T>;
 }
 
+/**
+ * Define a custom type. This type represents an inline, typed JSON object. 
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/add-fields/#specify-a-custom-field-type}
+ * @param fields the fields to be added to the custom type
+ * @returns a custom type
+ * @example
+ * a.schema({
+ *   Post: a.model({
+ *     location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *     }),
+ *     content: a.string(),
+ *   }),
+ * });
+ * @example
+ * a.schema({
+ *   Location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *   }),
+ * 
+ *   Post: a.model({
+ *     location: a.ref('Location'),
+ *     content: a.string(),
+ *   }),
+ * 
+ *   User: a.model({
+ *     lastKnownLocation: a.ref('Location'),
+ *   }),
+ * });
+ */
 export function customType<T extends CustomTypeFields>(
   fields: T,
 ): CustomType<{ fields: T }> {

package/src/EnumType.ts

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

package/src/Handler.ts

@@ -92,6 +92,33 @@ export type CustomHandler = { [dataSymbol]: CustomHandlerData } & Brand<
   typeof customHandlerBrand
 >;
 
+/**
+ * Use a custom JavaScript resolver to handle a query, mutation, or subscription. 
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/#step-2---configure-custom-business-logic-handler-code}
+ * @param customHandler `{ entry: "path-to-javascript-resolver-file.js", dataSource: "Data Source name added via "backend.data.add*DataSoruce(...)"}`
+ * @returns A JavaScript resolver attached to the query, mutation, or subscription.
+ * @example
+ * const schema = a.schema({
+ *   Post: a.model({
+ *     content: a.string(),
+ *     likes: a.integer()
+ *       .authorization(allow => [allow.authenticated().to(['read'])])
+ *   }).authorization(allow => [
+ *     allow.owner(),
+ *     allow.authenticated().to(['read'])
+ *   ]),
+ * 
+ *   likePost: a
+ *     .mutation()
+ *     .arguments({ postId: a.id() })
+ *     .returns(a.ref('Post'))
+ *     .authorization(allow => [allow.authenticated()])
+ *     .handler(a.handler.custom({
+ *       dataSource: a.ref('Post'),
+ *       entry: './increment-like.js'
+ *     }))
+ * });
+ */
 function custom(customHandler: CustomHandlerInput): CustomHandler {
   // used to determine caller directory in order to resolve relative path downstream
   const stack = new Error().stack;
@@ -113,6 +140,41 @@ export type FunctionHandler = {
   [dataSymbol]: FunctionHandlerData;
 } & Brand<typeof functionHandlerBrand>;
 
+/**
+ * Use a function created via `defineFunction` to handle the custom query/mutation/subscription. In your function handler, 
+ * you can use the `Schema["YOUR_QUERY_OR_MUTATION_NAME"]["functionHandler"]` utility type to type the handler function.
+ * @example
+ * import {
+ *   type ClientSchema,
+ *   a,
+ *   defineData,
+ *   defineFunction // 1.Import "defineFunction" to create new functions
+ * } from '@aws-amplify/backend';
+ * 
+ * // 2. define a function
+ * const echoHandler = defineFunction({
+ *   entry: './echo-handler/handler.ts'
+ * })
+ * 
+ * const schema = a.schema({
+ *   EchoResponse: a.customType({
+ *     content: a.string(),
+ *     executionDuration: a.float()
+ *   }),
+ * 
+ *   echo: a
+ *     .query()
+ *     .arguments({ content: a.string() })
+ *     .returns(a.ref('EchoResponse'))
+ *     .authorization(allow => [allow.publicApiKey()])
+ *     // 3. set the function has the handler
+ *     .handler(a.handler.function(echoHandler))
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}
+ * @param fn A function created via `defineFunction`. Alternatively, you can pass in a "string" of the function name and pass 
+ * in a corresponding value into the `functionMap` property of defineData.
+ * @returns A handler for the query / mutation / subscription
+ */
 function fcn(fn: FunctionHandlerData): FunctionHandler {
   return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };
 }

package/src/MappedTypes/CustomOperations.ts

@@ -4,7 +4,7 @@ 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,
@@ -66,10 +66,8 @@ 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
+        [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<
+          infer R
         >
           ? R
           : never;
@@ -101,7 +99,7 @@ export type CustomOpReturnType<
           NonModelTypes,
           CustomOperations
         >
-    : Shape['returnType'] extends ModelField<infer R, any, any>
+    : Shape['returnType'] extends BaseModelField<infer R>
       ? R
       : Shape['returnType'] extends CustomType<infer R>
         ?

package/src/MappedTypes/ExtractNonModelTypes.ts

@@ -1,6 +1,6 @@
 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,
@@ -9,7 +9,7 @@ import type {
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 
 export type NonModelTypesShape = {
-  enums: Record<string, EnumType<any>>;
+  enums: Record<string, any>;
   customTypes: Record<string, any>;
 };
 
@@ -51,43 +51,44 @@ export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<
 export type ExtractAndFlattenImplicitNonModelTypesFromFields<
   ParentTypeName extends string,
   Fields,
-> = {
-  // loop through the fields - omit the field that's not a non-model type
-  [FieldProp in keyof Fields as Fields[FieldProp] extends
-    | EnumType<EnumTypeParamShape>
-    | CustomType<CustomTypeParamShape>
-    ? FieldProp
-    : never]: (
-    x: NonNullable<Fields[FieldProp]> extends infer FieldType
-      ? // if the filed is a enum extract it as is
-        FieldType extends EnumType<EnumTypeParamShape>
-        ? {
-            [Key in `${ParentTypeName}${Capitalize<
-              FieldProp & string
-            >}`]: Fields[FieldProp];
-          }
-        : // if the field is a CustomType
-          FieldType extends CustomType<
-              infer CustomTypeShape extends CustomTypeParamShape
-            >
-          ? // recursively extract to the Nested CustomType, and return the
-            // merge of the current CustomType and the extracted (if any)
-            ExtractAndFlattenImplicitNonModelTypesFromFields<
-              `${ParentTypeName}${Capitalize<FieldProp & string>}`,
-              CustomTypeShape['fields']
-            > & {
+> =
+  {
+    // loop through the fields - omit the field that's not a non-model type
+    [FieldProp in keyof Fields as Fields[FieldProp] extends
+      | EnumType
+      | CustomType<CustomTypeParamShape>
+      ? FieldProp
+      : never]: (
+      x: NonNullable<Fields[FieldProp]> extends infer FieldType
+        ? // if the filed is a enum extract it as is
+          FieldType extends EnumType
+          ? {
               [Key in `${ParentTypeName}${Capitalize<
                 FieldProp & string
               >}`]: Fields[FieldProp];
             }
-          : never
-      : never,
-  ) => void;
-} extends Record<string, infer Func>
-  ? Func extends (x: infer P) => void
-    ? P // extract the union of all types of the `x` param used above
-    : Record<never, never> // return an empty mapped object (nothing got extracted)
-  : Record<never, never>; // return an empty mapped object (nothing got extracted)
+          : // if the field is a CustomType
+            FieldType extends CustomType<
+                infer CustomTypeShape extends CustomTypeParamShape
+              >
+            ? // recursively extract to the Nested CustomType, and return the
+              // merge of the current CustomType and the extracted (if any)
+              ExtractAndFlattenImplicitNonModelTypesFromFields<
+                `${ParentTypeName}${Capitalize<FieldProp & string>}`,
+                CustomTypeShape['fields']
+              > & {
+                [Key in `${ParentTypeName}${Capitalize<
+                  FieldProp & string
+                >}`]: Fields[FieldProp];
+              }
+            : never
+        : never,
+    ) => void;
+  } extends Record<string, infer Func>
+    ? Func extends (x: infer P) => void
+      ? P // extract the union of all types of the `x` param used above
+      : Record<never, never> // return an empty mapped object (nothing got extracted)
+    : Record<never, never>; // return an empty mapped object (nothing got extracted)
 
 /**
  * Pulls out implicit, i.e. field-level non-model types from `ModelType` and
@@ -129,12 +130,10 @@ type ResolveNonModelTypes<
   ResolvedSchema = SchemaTypes<Schema> & Extracted,
 > = {
   enums: {
-    [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType<EnumTypeParamShape>
+    [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType
       ? Model
-      : never]: ResolvedSchema[Model] extends EnumType<
-      infer R extends EnumTypeParamShape
-    >
-      ? R['values'][number]
+      : never]: ResolvedSchema[Model] extends EnumType<infer values>
+      ? values[number]
       : never;
   };
   customTypes: {

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -20,7 +20,7 @@ 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,
@@ -214,7 +214,7 @@ type Intersection<
 // TODO: this should probably happen in InjectImplicitModelFields instead. Keeping here for now to reduce refactor
 // blast radius
 export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
-  [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape>
+  [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType
     ? never
     : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape>
       ? never

package/src/MappedTypes/ResolveSchema.ts

@@ -5,9 +5,9 @@ import type {
   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,
@@ -17,9 +17,8 @@ import type {
 export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
 
 // TODO: find better name
-export type SchemaTypes<T> = T extends GenericModelSchema<any>
-  ? T['data']['types']
-  : never;
+export type SchemaTypes<T> =
+  T extends GenericModelSchema<any> ? T['data']['types'] : never;
 
 /**
  * Resolves model types
@@ -30,7 +29,7 @@ export type SchemaTypes<T> = T extends GenericModelSchema<any>
  */
 export type ModelTypes<Schema> = {
   [Model in keyof Schema as Schema[Model] extends
-    | EnumType<EnumTypeParamShape>
+    | EnumType
     | CustomType<CustomTypeParamShape>
     | CustomOperation<CustomOperationParamShape, any>
     ? never
@@ -45,14 +44,16 @@ export type ModelTypes<Schema> = {
  */
 export type ModelAndCustomTypes<Schema> = {
   [Model in keyof Schema as Schema[Model] extends
-    | EnumType<EnumTypeParamShape>
+    | EnumType
     | CustomOperation<CustomOperationParamShape, any>
     ? never
-    : Model]: Schema[Model] extends ModelType<any, any>
+    : // TODO: This should use BaseModel, but seems to only work because it relies on
+      // omitting extra methods
+      Model]: Schema[Model] extends
+    | ModelType<any, any>
+    | CustomType<CustomTypeParamShape>
     ? Schema[Model]
-    : Schema[Model] extends CustomType<CustomTypeParamShape>
-      ? Schema[Model]
-      : never;
+    : never;
 };
 
 /**
@@ -62,11 +63,9 @@ export type ModelAndCustomTypes<Schema> = {
  */
 export type FieldTypes<T> = {
   [ModelProp in keyof T]: {
-    [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<
+    [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends BaseModelField<
       // Match the most common field type to improve resolving performance
-      infer R,
-      any,
-      any
+      infer R
     >
       ? R
       : T[ModelProp][FieldProp] extends RefType<
@@ -80,7 +79,7 @@ export type FieldTypes<T> = {
           : T[ModelProp][FieldProp] | null
         : // replace non-model types with Ref
           T[ModelProp][FieldProp] extends
-              | EnumType<EnumTypeParamShape>
+              | EnumType
               | CustomType<CustomTypeParamShape>
           ? RefType<{
               link: `${Capitalize<ModelProp & string>}${Capitalize<
@@ -114,10 +113,8 @@ 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
+    [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends BaseModelField<
+      infer R
     >
       ? R
       : T[CustomTypeName][FieldProp] extends RefType<
@@ -131,7 +128,7 @@ export type FieldTypesOfCustomType<T> = {
           : T[CustomTypeName][FieldProp] | null
         : // replace non-model types with Ref
           T[CustomTypeName][FieldProp] extends
-              | EnumType<EnumTypeParamShape>
+              | EnumType
               | CustomType<CustomTypeParamShape>
           ? RefType<{
               link: `${Capitalize<CustomTypeName & string>}${Capitalize<

package/src/ModelField.ts

@@ -1,5 +1,7 @@
-import { Brand, brand } from './util';
+import { brand } from './util';
 import { AllowModifier, Authorization, allow } 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.
@@ -34,7 +36,7 @@ export enum ModelFieldDataType {
 }
 
 type FieldMeta = {
-  lastInvokedMethod: null | keyof ModelField<ModelFieldTypeParamOuter>;
+  lastInvokedMethod: null | methodKeyOf<ModelField>;
 };
 
 type FieldData = {
@@ -67,56 +69,69 @@ export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner]
   ? Array<T> | null // optional by default
   : 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,
-  // rename K
-  K extends keyof ModelField<T> = never,
+  T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter,
+  UsedMethod extends UsableModelFieldKey = never,
   Auth = undefined,
 > = Omit<
   {
+    // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
+    [__auth]?: Auth;
+    [brandSymbol]: typeof brandName;
+
     /**
      * Marks a field as required.
      */
-    required(): ModelField<Required<T>, K | 'required'>;
+    required(): ModelField<Required<T>, UsedMethod | 'required'>;
     // Exclude `optional` after calling array, because both the value and the array itself can be optional
     /**
      * 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'>>;
     // TODO: should be T, but .array breaks this constraint. Fix later
     /**
      * 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 `(a.allow.____)` to mix and match
+     * 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>;
+      callback: (
+        allow: Omit<AllowModifier, 'resource'>,
+      ) => AuthRuleType | AuthRuleType[],
+    ): ModelField<T, UsedMethod | 'authorization', AuthRuleType>;
   },
-  K
-> & {
-  // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
-  [__auth]?: Auth;
-} & Brand<typeof brandName>;
+  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;
-};
+}
 
 /**
  * Model Field Implementation