@aws-amplify/data-schema 1.2.8 → 1.3.0

package/src/Authorization.ts

@@ -639,8 +639,8 @@ export type ImpliedAuthField<T extends Authorization<any, any, any>> =
       ? never
       : Field extends string
         ? isMulti extends true
-          ? { [K in Field]?: string[] }
-          : { [K in Field]?: string }
+          ? { [K in Field]?: string[] | null | undefined }
+          : { [K in Field]?: string | null | undefined }
         : never
     : never;
 

package/src/ClientSchema/Core/ClientCustomOperations.ts

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

package/src/ClientSchema/Core/ClientCustomType.ts

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

package/src/ClientSchema/Core/ClientEnum.ts

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

package/src/ClientSchema/Core/ClientModel.ts

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

package/src/ClientSchema/Core/ClientSchemaProperty.ts

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

package/src/ClientSchema/Core/index.ts

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

package/src/ClientSchema/index.ts

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

package/src/ClientSchema/utilities/ExtractNestedTypes.ts

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