@contember/client-content 1.3.0-alpha.10

package/src/nodes/ContentEntitySelection.ts

@@ -0,0 +1,240 @@
+import { createListArgs } from '../utils/createListArgs'
+import { ContentClientInput, SchemaEntityNames, SchemaNames } from '../types'
+import { Input } from '@contember/schema'
+import { GraphQlField, GraphQlFieldTypedArgs, GraphQlSelectionSet } from '@contember/graphql-builder'
+
+/**
+ * @internal
+ */
+export type ContentEntitySelectionContext<Name extends string> = {
+	entity: SchemaEntityNames<Name>
+	schema: SchemaNames
+}
+
+export type ContentEntitySelectionCallback = (select: ContentEntitySelection) => ContentEntitySelection
+
+export type EntitySelectionCommonInput<Alias extends string | null = string | null> = { as?: Alias }
+export type EntitySelectionManyArgs<Alias extends string | null = string | null> = ContentClientInput.AnyListQueryInput & EntitySelectionCommonInput<Alias>
+export type EntitySelectionManyByArgs<Alias extends string | null = string | null> = { by: Input.UniqueWhere; filter?: Input.Where } & EntitySelectionCommonInput<Alias>
+export type EntitySelectionOneArgs<Alias extends string | null = string | null> = { filter?: Input.Where } & EntitySelectionCommonInput<Alias>
+export type EntitySelectionColumnArgs<Alias extends string | null = string | null> = EntitySelectionCommonInput<Alias>
+
+export type EntitySelectionAnyArgs =
+	| EntitySelectionColumnArgs
+	| EntitySelectionManyArgs
+	| EntitySelectionManyByArgs
+	| EntitySelectionOneArgs
+
+export type ContentEntitySelectionOrCallback = ContentEntitySelectionCallback | ContentEntitySelection
+
+
+export class ContentEntitySelection {
+
+	/**
+	 * @internal
+	 */
+	constructor(
+		/** @internal */
+		public readonly context: ContentEntitySelectionContext<string>,
+		/** @internal */
+		public readonly selectionSet: GraphQlSelectionSet,
+	) {
+	}
+
+
+	$(field: string, args?: EntitySelectionColumnArgs): ContentEntitySelection
+	$(field: string, args: EntitySelectionManyArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, args: EntitySelectionManyByArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, args: EntitySelectionOneArgs, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+	$(field: string, selection: ContentEntitySelectionOrCallback): ContentEntitySelection
+
+	$(field: string, argsOrSelection?: EntitySelectionAnyArgs | ContentEntitySelectionOrCallback, selectionIn?: ContentEntitySelectionOrCallback): ContentEntitySelection {
+		const [args, selection] = typeof argsOrSelection === 'function' || argsOrSelection instanceof ContentEntitySelection
+			? [{}, argsOrSelection]
+			: [argsOrSelection ?? {}, selectionIn]
+		if (field === '__typename') {
+			return this.withField(new GraphQlField(args.as ?? null, '__typename'))
+		}
+		const fieldInfo = this.context.entity.fields[field]
+		if (!fieldInfo) {
+			if ('by' in args && field.includes('By')) {
+				if (!selection) {
+					throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+				}
+				return this._manyBy(field, args as EntitySelectionManyByArgs, selection)
+			}
+
+			throw new Error(`Field ${this.context.entity.name}.${field} does not exist.`)
+		}
+		if (fieldInfo.type === 'column') {
+			return this._column(field, args as EntitySelectionColumnArgs)
+		}
+		if (fieldInfo.type === 'many') {
+			if (!selection) {
+				throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+			}
+			return this._many(field, args as EntitySelectionManyArgs, selection)
+		}
+		if (fieldInfo.type === 'one') {
+			if (!selection) {
+				throw new Error(`Selection is required for ${this.context.entity.name}.${field}.`)
+			}
+			return this._one(field, args as EntitySelectionOneArgs, selection)
+		}
+		throw new Error(`Unknown field type ${fieldInfo.type}.`)
+	}
+
+	$$(): ContentEntitySelection {
+		const columns = this.context.entity.scalars
+		const nodes = [
+			...this.selectionSet,
+			...columns.map(col => new GraphQlField(null, col)),
+		]
+		return new ContentEntitySelection(this.context, nodes)
+	}
+
+	private _column(
+		name: string,
+		args: EntitySelectionCommonInput = {},
+	): ContentEntitySelection {
+		let fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'column') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a column.`)
+		}
+
+		const alias = args.as ?? name
+
+		const field = new GraphQlField(alias, name, {})
+		return this.withField(field)
+	}
+
+
+	private _many(
+		name: string,
+		args: EntitySelectionManyArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection{
+		const alias = args.as ?? name
+		const fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'many') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a has-many relation.`)
+		}
+		const entity = this.context.schema.entities[fieldInfo.entity]
+
+		const newContext = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+
+		const entitySelection = typeof fields === 'function' ? fields(new ContentEntitySelection(newContext, [])) : fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			createListArgs(entity, args),
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+
+	private _manyBy(
+		name: string,
+		args: EntitySelectionManyByArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection {
+		const alias = args.as ?? name
+		const byField = Object.keys(args.by)[0]
+		const relationField = name.substring(0, name.length - byField.length - 2)
+
+		const field = this.context.entity.fields[relationField]
+		if (!field) {
+			throw new Error(`Field ${this.context.entity.name}.${relationField} does not exist.`)
+		}
+		if (field?.type !== 'many') {
+			throw new Error(`Field ${this.context.entity.name}.${relationField} is not a has-many relation.`)
+		}
+		const entity = this.context.schema.entities[field.entity]
+		const newContext = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+		const fieldUpperFirst = name.charAt(0).toUpperCase() + name.slice(1)
+
+		const argsWithType: GraphQlFieldTypedArgs = {
+			filter: {
+				graphQlType: `${entity.name}Where`,
+				value: args.filter,
+			},
+			by: {
+				graphQlType: `${this.context.entity.name}${fieldUpperFirst}UniqueWhere!`,
+				value: args.by,
+			},
+		}
+
+		const entitySelection = typeof fields === 'function' ? fields(new ContentEntitySelection(newContext, []) as any) : fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			argsWithType,
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+	private _one(
+		name: string,
+		args: EntitySelectionOneArgs,
+		fields:
+			| ContentEntitySelectionCallback
+			| ContentEntitySelection,
+	): ContentEntitySelection {
+		const alias = args.as ?? name
+		const fieldInfo = this.context.entity.fields[name]
+		if (!fieldInfo) {
+			throw new Error(`Field ${this.context.entity.name}.${name} does not exist.`)
+		}
+		if (fieldInfo?.type !== 'one') {
+			throw new Error(`Field ${this.context.entity.name}.${name} is not a has-one relation.`)
+		}
+		const entity = this.context.schema.entities[fieldInfo.entity]
+
+		const newContext: ContentEntitySelectionContext<(typeof entity)['name']> = {
+			entity: entity,
+			schema: this.context.schema,
+		}
+		const argsWithType: GraphQlFieldTypedArgs = {
+			filter: {
+				graphQlType: `${entity.name}Where`,
+				value: args.filter,
+			},
+		}
+		const entitySelection = typeof fields === 'function'
+			? fields(new ContentEntitySelection(newContext, []) as any)
+			: fields
+		const newObjectField = new GraphQlField(
+			alias,
+			name,
+			argsWithType,
+			entitySelection.selectionSet,
+		)
+		return this.withField(newObjectField)
+	}
+
+
+	private withField(field: GraphQlField) {
+		return new ContentEntitySelection(this.context, [
+			...this.selectionSet,
+			field,
+		])
+	}
+}

package/src/nodes/ContentOperation.ts

@@ -0,0 +1,23 @@
+import { GraphQlFieldTypedArgs, GraphQlSelectionSet } from '@contember/graphql-builder'
+
+export class ContentOperation<TValue, TType extends 'query' | 'mutation'> {
+	/**
+	 * @internal
+	 */
+	constructor(
+		/** @internal */
+		public readonly type: TType,
+		/** @internal */
+		public readonly fieldName: string,
+		/** @internal */
+		public readonly args: GraphQlFieldTypedArgs = {},
+		/** @internal */
+		public readonly selection?: GraphQlSelectionSet,
+		/** @internal */
+		public readonly parse: (value: any) => TValue = it => it as TValue,
+	) {
+	}
+}
+
+export type ContentQuery<TValue> = ContentOperation<TValue, 'query'>
+export type ContentMutation<TValue> = ContentOperation<TValue, 'mutation'>

package/src/nodes/TypedEntitySelection.ts

@@ -0,0 +1,111 @@
+import { EntityTypeLike, SchemaTypeLike } from '../types/Schema'
+import { ContentClientInput } from '../types'
+import { ContentEntitySelectionContext } from './ContentEntitySelection'
+
+export type TypedEntitySelectionCallback<
+	TSchema extends SchemaTypeLike,
+	EntityName extends string,
+	TEntity extends EntityTypeLike,
+	TValue
+> = (select: TypedEntitySelection<TSchema, EntityName, TEntity, {}>) => TypedEntitySelection<TSchema, EntityName, TEntity, TValue>
+
+export interface TypedEntitySelection<TSchema extends SchemaTypeLike, TEntityName extends string, TEntity extends EntityTypeLike, TValue> {
+
+	/** @internal */
+	readonly context: ContentEntitySelectionContext<TEntityName>,
+
+	$$(): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in keyof TEntity['columns']]: TEntity['columns'][key]
+	}>
+
+	$<
+		TKey extends (keyof TEntity['columns']) & string,
+		TAlias extends string | null = null
+	>(
+		name: TKey,
+		args?: {as?: TAlias},
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TKey : TAlias]: TEntity['columns'][key]
+	}>
+
+	$<
+		TNestedValue,
+		TNestedKey extends keyof TEntity['hasMany'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		args: ContentClientInput.HasManyRelationInput<TEntity['hasMany'][TNestedKey]> & { as?: TAlias },
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasMany'][TNestedKey]['name'], TEntity['hasMany'][TNestedKey], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasMany'][TNestedKey]['name'], TEntity['hasMany'][TNestedKey], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: TNestedValue[]
+	}>
+
+	$<
+		TNestedValue,
+		TNestedKey extends keyof TEntity['hasMany'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasMany'][TNestedKey]['name'], TEntity['hasMany'][TNestedKey], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasMany'][TNestedKey]['name'], TEntity['hasMany'][TNestedKey], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: TNestedValue[]
+	}>
+
+	$<
+		TNestedValue,
+		TNestedKey extends keyof TEntity['hasManyBy'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		args: ContentClientInput.HasManyByRelationInput<TEntity['hasManyBy'][TNestedKey]['entity'], TEntity['hasManyBy'][TNestedKey]['by']> & { as?: TAlias },
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasManyBy'][TNestedKey]['entity']['name'], TEntity['hasManyBy'][TNestedKey]['entity'], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasManyBy'][TNestedKey]['entity']['name'], TEntity['hasManyBy'][TNestedKey]['entity'], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: null | TNestedValue
+	}>
+
+	$<
+		TNestedValue,
+		TNestedKey extends keyof TEntity['hasManyBy'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasManyBy'][TNestedKey]['entity']['name'], TEntity['hasManyBy'][TNestedKey]['entity'], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasManyBy'][TNestedKey]['entity']['name'], TEntity['hasManyBy'][TNestedKey]['entity'], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: null | TNestedValue
+	}>
+
+	$<
+		TNestedValue extends { [K in string]: unknown },
+		TNestedKey extends keyof TEntity['hasOne'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		args: ContentClientInput.HasOneRelationInput<TEntity['hasOne'][TNestedKey]> & { as?: TAlias },
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasOne'][TNestedKey]['name'], TEntity['hasOne'][TNestedKey], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasOne'][TNestedKey]['name'], TEntity['hasOne'][TNestedKey], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: TNestedValue | null
+	}>
+
+	$<
+		TNestedValue extends { [K in string]: unknown },
+		TNestedKey extends keyof TEntity['hasOne'] & string,
+		TAlias extends string | null = null,
+	>(
+		name: TNestedKey,
+		fields:
+			| TypedEntitySelectionCallback<TSchema, TEntity['hasOne'][TNestedKey]['name'], TEntity['hasOne'][TNestedKey], TNestedValue>
+			| TypedEntitySelection<TSchema, TEntity['hasOne'][TNestedKey]['name'], TEntity['hasOne'][TNestedKey], TNestedValue>,
+	): TypedEntitySelection<TSchema, TEntityName, TEntity, TValue & {
+		[key in TAlias extends null ? TNestedKey : TAlias]: TNestedValue | null
+	}>
+}

package/src/nodes/index.ts

@@ -0,0 +1,3 @@
+export * from './ContentEntitySelection'
+export * from './ContentOperation'
+export * from './TypedEntitySelection'

package/src/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"extends": "../../../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/types"
+	},
+	"references": [
+		{
+			"path": "../../graphql-builder/src"
+		},
+		{
+			"path": "../../graphql-client/src"
+		}
+	]
+}

package/src/types/Input.ts

@@ -0,0 +1,281 @@
+import { Input, JSONObject } from '@contember/schema'
+import { EntityTypeLike } from './Schema'
+
+
+export namespace ContentClientInput {
+	export type ConnectRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly connect: UniqueWhere<TEntity>
+	}
+
+	export type CreateRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly create: CreateDataInput<TEntity>
+	}
+
+	export type ConnectOrCreateInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly connect: UniqueWhere<TEntity>
+		readonly create: CreateDataInput<TEntity>
+	}
+
+	export type ConnectOrCreateRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly connectOrCreate: ConnectOrCreateInput<TEntity>
+	}
+
+	export type DisconnectSpecifiedRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly disconnect: UniqueWhere<TEntity>
+	}
+
+	export type DeleteSpecifiedRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly delete: UniqueWhere<TEntity>
+	}
+
+	export type UpdateSpecifiedRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly update: {
+			readonly by: UniqueWhere<TEntity>
+			readonly data: UpdateDataInput<TEntity>
+		}
+	}
+
+	export type UpsertSpecifiedRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly upsert: {
+			readonly by: UniqueWhere<TEntity>
+			readonly update: UpdateDataInput<TEntity>
+			readonly  create: CreateDataInput<TEntity>
+		}
+	}
+
+	export type DisconnectRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly disconnect: true
+	}
+
+	export type UpdateRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly update: UpdateDataInput<TEntity>
+	}
+
+	export type DeleteRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly delete: true
+	}
+
+	export type UpsertRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly upsert: {
+			readonly update: UpdateDataInput<TEntity>
+			readonly create: CreateDataInput<TEntity>
+		}
+	}
+
+	export type CreateDataInput<TEntity extends EntityTypeLike> =
+		& {
+			/** @internal */
+			readonly __typeGuard?: TEntity['name']
+		}
+		& {
+			readonly [key in keyof TEntity['columns']]?: TEntity['columns'][key]
+		}
+		& {
+			readonly [key in keyof TEntity['hasMany']]?: CreateManyRelationInput<TEntity['hasMany'][key]>
+		}
+		& {
+			readonly [key in keyof TEntity['hasOne']]?: CreateOneRelationInput<TEntity['hasOne'][key]>
+		}
+
+	export type CreateOneRelationInput<TEntity extends EntityTypeLike> =
+		| ConnectRelationInput<TEntity>
+		| CreateRelationInput<TEntity>
+		| ConnectOrCreateRelationInput<TEntity>
+
+	export type CreateManyRelationInput<TEntity extends EntityTypeLike> = readonly CreateOneRelationInput<TEntity>[]
+
+
+	export type UpdateDataInput<TEntity extends EntityTypeLike> =
+		& {
+			/**
+			 * @internal
+			 */
+			readonly __typeGuard?: TEntity['name']
+		}
+		& {
+			readonly [key in keyof TEntity['columns']]?: TEntity['columns'][key]
+		}
+		& {
+			readonly [key in keyof TEntity['hasMany']]?: UpdateManyRelationInput<TEntity['hasMany'][key]>
+		}
+		& {
+			readonly [key in keyof TEntity['hasOne']]?: UpdateOneRelationInput<TEntity['hasOne'][key]>
+		}
+
+	export type UpdateInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly by: UniqueWhere<TEntity>
+		readonly filter?: Where<TEntity>
+		readonly data: UpdateDataInput<TEntity>
+	}
+
+	export type UpsertInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly by: UniqueWhere<TEntity>
+		readonly filter?: Where<TEntity>
+		readonly update: UpdateDataInput<TEntity>
+		readonly create: CreateDataInput<TEntity>
+	}
+
+	export type CreateInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly data: CreateDataInput<TEntity>
+	}
+
+	export type DeleteInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly by: UniqueWhere<TEntity>
+		readonly filter?: Where<TEntity>
+	}
+
+	export type UniqueQueryInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly by: UniqueWhere<TEntity>
+		readonly filter?: Where<TEntity>
+	}
+
+	export type ListQueryInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly filter?: Where<TEntity>
+		readonly orderBy?: readonly OrderBy<TEntity>[]
+		readonly offset?: number
+		readonly limit?: number
+	}
+
+	export type PaginationQueryInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly filter?: Where<TEntity>
+		readonly orderBy?: readonly OrderBy<TEntity>[]
+		readonly skip?: number
+		readonly first?: number
+	}
+
+	export type HasOneRelationInput<TEntity extends EntityTypeLike> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly filter?: Where<TEntity>
+	}
+
+	export type HasManyByRelationInput<TEntity extends EntityTypeLike, TUnique extends JSONObject> = {
+		/** @internal */
+		readonly __typeGuard?: TEntity['name']
+		readonly by: TUnique
+		readonly filter?: Where<TEntity>
+	}
+
+	export type HasManyRelationInput<TEntity extends EntityTypeLike> = ListQueryInput<TEntity>
+	export type HasManyRelationPaginateInput<TEntity extends EntityTypeLike> = PaginationQueryInput<TEntity>
+
+
+	export type UpdateOneRelationInput<TEntity extends EntityTypeLike> =
+		| CreateRelationInput<TEntity>
+		| ConnectRelationInput<TEntity>
+		| ConnectOrCreateRelationInput<TEntity>
+		| DeleteRelationInput<TEntity>
+		| DisconnectRelationInput<TEntity>
+		| UpdateRelationInput<TEntity>
+		| UpsertRelationInput<TEntity>
+
+	export type UpdateManyRelationInputItem<TEntity extends EntityTypeLike> =
+		| CreateRelationInput<TEntity>
+		| ConnectRelationInput<TEntity>
+		| ConnectOrCreateRelationInput<TEntity>
+		| DeleteSpecifiedRelationInput<TEntity>
+		| DisconnectSpecifiedRelationInput<TEntity>
+		| UpdateSpecifiedRelationInput<TEntity>
+		| UpsertSpecifiedRelationInput<TEntity>
+
+
+	export type UpdateManyRelationInput<TEntity extends EntityTypeLike> = Array<UpdateManyRelationInputItem<TEntity>>
+
+
+	export type FieldOrderBy<TEntity extends EntityTypeLike> =
+		& {
+			/** @internal */
+			readonly __typeGuard?: TEntity['name']
+		}
+		& {
+			readonly [key in keyof TEntity['columns']]?: `${Input.OrderDirection}` | null
+		}
+		& {
+			readonly [key in keyof TEntity['hasMany']]?: FieldOrderBy<TEntity['hasMany'][key]> | null
+		}
+		& {
+			readonly [key in keyof TEntity['hasOne']]?: FieldOrderBy<TEntity['hasOne'][key]> | null
+		}
+
+	export type OrderBy<TEntity extends EntityTypeLike> =
+		& {
+			/** @internal */
+			readonly __typeGuard?: TEntity['name']
+			readonly _random?: boolean
+			readonly _randomSeeded?: number
+		}
+		& FieldOrderBy<TEntity>
+
+
+	export type UniqueWhere<TEntity extends EntityTypeLike> =
+		& {
+			/**
+			 * @internal
+			 */
+			readonly __typeGuard?: TEntity['name']
+		}
+		& TEntity['unique']
+
+
+	export type Where<TEntity extends EntityTypeLike> =
+		& {
+			/** @internal */
+			readonly __typeGuard?: TEntity['name']
+			readonly and?: (readonly (Where<TEntity>)[]) | null
+			readonly or?: (readonly (Where<TEntity>)[]) | null
+			readonly not?: Where<TEntity> | null
+		}
+		& {
+			readonly [key in keyof TEntity['columns']]?: Input.Condition<TEntity['columns'][key]> | null
+		}
+		& {
+			readonly [key in keyof TEntity['hasMany']]?: Where<TEntity['hasMany'][key]> | null
+		}
+		& {
+			readonly [key in keyof TEntity['hasOne']]?: Where<TEntity['hasOne'][key]> | null
+		}
+
+
+	export type AnyOrderBy = Input.OrderBy<`${Input.OrderDirection}`>[]
+	export type AnyListQueryInput =
+		& Omit<Input.ListQueryInput, 'orderBy'>
+		& { readonly orderBy?: AnyOrderBy }
+}