@contember/engine-content-api 1.2.0-alpha.1 → 1.2.0-alpha.12

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -1,7 +1,6 @@
 import { Input, Model } from '@contember/schema'
 import { filterObject, isIt } from '../utils'
 import { UpdateInputProcessor } from './UpdateInputProcessor'
-import * as Context from './InputContext'
 import { ImplementationException, UserError } from '../exception'
 
 export class UpdateInputVisitor<Result> implements
@@ -14,7 +13,7 @@ export class UpdateInputVisitor<Result> implements
 		private readonly data: Input.UpdateDataInput,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): Promise<Result> {
+	public visitColumn({ entity, column }: Model.ColumnContext): Promise<Result> {
 		return this.updateInputProcessor.column({
 			entity,
 			column,
@@ -22,96 +21,51 @@ export class UpdateInputVisitor<Result> implements
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyInverseContext>(
+	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyInverse,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyOwningContext>(
+	public visitManyHasManyOwning(context: Model.ManyHasManyOwningContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyOwning,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasOne(
-		entity: Model.Entity,
-		relation: Model.ManyHasOneRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasManyRelation | null,
-	) {
-		return this.processRelationInput<Context.ManyHasOneContext>(
+	public visitManyHasOne(context: Model.ManyHasOneContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.manyHasOne,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	) {
-		return this.processManyRelationInput<Context.OneHasManyContext>(
+	public visitOneHasMany(context: Model.OneHasManyContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.oneHasMany,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
-		return this.processRelationInput<Context.OneHasOneInverseContext>(
+	public visitOneHasOneInverse(context: Model.OneHasOneInverseContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
-		return this.processRelationInput<Context.OneHasOneOwningContext>(
+	public visitOneHasOneOwning(context: Model.OneHasOneOwningContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 

package/src/inputProcessing/index.ts

@@ -1,7 +1,6 @@
 export * from './CreateInputProcessor'
 export * from './CreateInputVisitor'
 export * from './FieldNode'
-export * from './InputContext'
 export * from './ObjectNode'
 export * from './UniqueWhereExpander'
 export * from './UpdateInputProcessor'

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -40,7 +40,7 @@ export class IntrospectionSchemaFactory {
 			}
 		}
 		const additionalInfo = acceptEveryFieldVisitor<AdditionalFieldInfo>(this.model, entityName, {
-			visitManyHasManyInverse(entity: Model.Entity, relation: Model.ManyHasManyInverseRelation) {
+			visitManyHasManyInverse({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -49,7 +49,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitManyHasManyOwning(entity: Model.Entity, relation: Model.ManyHasManyOwningRelation) {
+			visitManyHasManyOwning({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -58,7 +58,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation) {
+			visitManyHasOne({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -68,7 +68,7 @@ export class IntrospectionSchemaFactory {
 					nullable: relation.nullable,
 				}
 			},
-			visitOneHasMany(entity: Model.Entity, relation: Model.OneHasManyRelation) {
+			visitOneHasMany({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -77,7 +77,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitOneHasOneInverse(entity: Model.Entity, relation: Model.OneHasOneInverseRelation) {
+			visitOneHasOneInverse({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -86,7 +86,7 @@ export class IntrospectionSchemaFactory {
 					nullable: relation.nullable,
 				}
 			},
-			visitOneHasOneOwning(entity: Model.Entity, relation: Model.OneHasOneOwningRelation) {
+			visitOneHasOneOwning({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -97,7 +97,7 @@ export class IntrospectionSchemaFactory {
 					orphanRemoval: relation.orphanRemoval === true,
 				}
 			},
-			visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+			visitColumn({ column }) {
 				return {
 					__typename: '_Column',
 					defaultValue: column.default ?? undefined,

package/src/introspection/content-schema.types.ts

@@ -1,9 +1,8 @@
-import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'
 export type Maybe<T> = T | null
+export type InputMaybe<T> = Maybe<T>
 export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
 export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
 export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
-export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
 	ID: string
@@ -14,30 +13,29 @@ export type Scalars = {
 	Json: any
 }
 
-
 export type Query = {
 	readonly __typename?: 'Query'
 	readonly schema?: Maybe<_Schema>
 }
 
-export type _Argument = _ValidatorArgument | _PathArgument | _LiteralArgument
+export type _Argument = _LiteralArgument | _PathArgument | _ValidatorArgument
 
 export type _Column = _Field & {
 	readonly __typename?: '_Column'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly enumName?: Maybe<Scalars['String']>
 	readonly defaultValue?: Maybe<Scalars['Json']>
+	readonly enumName?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable: Scalars['Boolean']
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export type _Entity = {
 	readonly __typename?: '_Entity'
-	readonly name: Scalars['String']
 	readonly customPrimaryAllowed: Scalars['Boolean']
 	readonly fields: ReadonlyArray<_Field>
+	readonly name: Scalars['String']
 	readonly unique: ReadonlyArray<_UniqueConstraint>
 }
 
@@ -49,9 +47,9 @@ export type _Enum = {
 
 export type _Field = {
 	readonly name: Scalars['String']
-	readonly type: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
@@ -61,15 +59,15 @@ export type _LiteralArgument = {
 }
 
 export enum _OnDeleteBehaviour {
-	Restrict = 'restrict',
 	Cascade = 'cascade',
+	Restrict = 'restrict',
 	SetNull = 'setNull'
 }
 
 export type _OrderBy = {
 	readonly __typename?: '_OrderBy'
-	readonly path: ReadonlyArray<Scalars['String']>
 	readonly direction: _OrderByDirection
+	readonly path: ReadonlyArray<Scalars['String']>
 }
 
 export enum _OrderByDirection {
@@ -84,23 +82,23 @@ export type _PathArgument = {
 
 export type _Relation = _Field & {
 	readonly __typename?: '_Relation'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly side: _RelationSide
-	readonly targetEntity: Scalars['String']
-	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly inversedBy?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly onDelete?: Maybe<_OnDeleteBehaviour>
-	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
 	readonly orderBy?: Maybe<ReadonlyArray<_OrderBy>>
+	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
+	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly side: _RelationSide
+	readonly targetEntity: Scalars['String']
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export enum _RelationSide {
-	Owning = 'owning',
-	Inverse = 'inverse'
+	Inverse = 'inverse',
+	Owning = 'owning'
 }
 
 export type _Rule = {
@@ -116,8 +114,8 @@ export type _RuleMessage = {
 
 export type _Schema = {
 	readonly __typename?: '_Schema'
-	readonly enums: ReadonlyArray<_Enum>
 	readonly entities: ReadonlyArray<_Entity>
+	readonly enums: ReadonlyArray<_Enum>
 }
 
 export type _UniqueConstraint = {
@@ -127,276 +125,11 @@ export type _UniqueConstraint = {
 
 export type _Validator = {
 	readonly __typename?: '_Validator'
-	readonly operation: Scalars['String']
 	readonly arguments: ReadonlyArray<_Argument>
+	readonly operation: Scalars['String']
 }
 
 export type _ValidatorArgument = {
 	readonly __typename?: '_ValidatorArgument'
 	readonly validator: Scalars['Int']
 }
-
-
-
-export type ResolverTypeWrapper<T> = Promise<T> | T
-
-
-export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	fragment: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-
-export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	selectionSet: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
-  | ResolverFn<TResult, TParent, TContext, TArgs>
-  | StitchingResolver<TResult, TParent, TContext, TArgs>
-
-export type ResolverFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Promise<TResult> | TResult
-
-export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>
-
-export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>
-	resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>
-}
-
-export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>
-	resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>
-}
-
-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
-
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
-
-export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
-	parent: TParent,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Maybe<TTypes> | Promise<Maybe<TTypes>>
-
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
-
-export type NextResolverFn<T> = () => Promise<T>
-
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
-	next: NextResolverFn<TResult>,
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-/** Mapping between all available schema types and the resolvers types */
-export type ResolversTypes = {
-	Json: ResolverTypeWrapper<Scalars['Json']>
-	Query: ResolverTypeWrapper<{}>
-	_Argument: ResolversTypes['_ValidatorArgument'] | ResolversTypes['_PathArgument'] | ResolversTypes['_LiteralArgument']
-	_Column: ResolverTypeWrapper<_Column>
-	String: ResolverTypeWrapper<Scalars['String']>
-	Boolean: ResolverTypeWrapper<Scalars['Boolean']>
-	_Entity: ResolverTypeWrapper<_Entity>
-	_Enum: ResolverTypeWrapper<_Enum>
-	_Field: ResolversTypes['_Column'] | ResolversTypes['_Relation']
-	_LiteralArgument: ResolverTypeWrapper<_LiteralArgument>
-	_OnDeleteBehaviour: _OnDeleteBehaviour
-	_OrderBy: ResolverTypeWrapper<_OrderBy>
-	_OrderByDirection: _OrderByDirection
-	_PathArgument: ResolverTypeWrapper<_PathArgument>
-	_Relation: ResolverTypeWrapper<_Relation>
-	_RelationSide: _RelationSide
-	_Rule: ResolverTypeWrapper<_Rule>
-	Int: ResolverTypeWrapper<Scalars['Int']>
-	_RuleMessage: ResolverTypeWrapper<_RuleMessage>
-	_Schema: ResolverTypeWrapper<_Schema>
-	_UniqueConstraint: ResolverTypeWrapper<_UniqueConstraint>
-	_Validator: ResolverTypeWrapper<Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversTypes['_Argument']> }>
-	_ValidatorArgument: ResolverTypeWrapper<_ValidatorArgument>
-}
-
-/** Mapping between all available schema types and the resolvers parents */
-export type ResolversParentTypes = {
-	Json: Scalars['Json']
-	Query: {}
-	_Argument: ResolversParentTypes['_ValidatorArgument'] | ResolversParentTypes['_PathArgument'] | ResolversParentTypes['_LiteralArgument']
-	_Column: _Column
-	String: Scalars['String']
-	Boolean: Scalars['Boolean']
-	_Entity: _Entity
-	_Enum: _Enum
-	_Field: ResolversParentTypes['_Column'] | ResolversParentTypes['_Relation']
-	_LiteralArgument: _LiteralArgument
-	_OrderBy: _OrderBy
-	_PathArgument: _PathArgument
-	_Relation: _Relation
-	_Rule: _Rule
-	Int: Scalars['Int']
-	_RuleMessage: _RuleMessage
-	_Schema: _Schema
-	_UniqueConstraint: _UniqueConstraint
-	_Validator: Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversParentTypes['_Argument']> }
-	_ValidatorArgument: _ValidatorArgument
-}
-
-export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
-	name: 'Json'
-}
-
-export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
-	schema?: Resolver<Maybe<ResolversTypes['_Schema']>, ParentType, ContextType>
-}
-
-export type _ArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Argument'] = ResolversParentTypes['_Argument']> = {
-	__resolveType: TypeResolveFn<'_ValidatorArgument' | '_PathArgument' | '_LiteralArgument', ParentType, ContextType>
-}
-
-export type _ColumnResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Column'] = ResolversParentTypes['_Column']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	enumName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	defaultValue?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	nullable?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EntityResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Entity'] = ResolversParentTypes['_Entity']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	customPrimaryAllowed?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	fields?: Resolver<ReadonlyArray<ResolversTypes['_Field']>, ParentType, ContextType>
-	unique?: Resolver<ReadonlyArray<ResolversTypes['_UniqueConstraint']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EnumResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Enum'] = ResolversParentTypes['_Enum']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	values?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _FieldResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Field'] = ResolversParentTypes['_Field']> = {
-	__resolveType: TypeResolveFn<'_Column' | '_Relation', ParentType, ContextType>
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-}
-
-export type _LiteralArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_LiteralArgument'] = ResolversParentTypes['_LiteralArgument']> = {
-	value?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _OrderByResolvers<ContextType = any, ParentType extends ResolversParentTypes['_OrderBy'] = ResolversParentTypes['_OrderBy']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	direction?: Resolver<ResolversTypes['_OrderByDirection'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _PathArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_PathArgument'] = ResolversParentTypes['_PathArgument']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Relation'] = ResolversParentTypes['_Relation']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	side?: Resolver<ResolversTypes['_RelationSide'], ParentType, ContextType>
-	targetEntity?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	ownedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	inversedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	onDelete?: Resolver<Maybe<ResolversTypes['_OnDeleteBehaviour']>, ParentType, ContextType>
-	orphanRemoval?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	orderBy?: Resolver<Maybe<ReadonlyArray<ResolversTypes['_OrderBy']>>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Rule'] = ResolversParentTypes['_Rule']> = {
-	message?: Resolver<Maybe<ResolversTypes['_RuleMessage']>, ParentType, ContextType>
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleMessageResolvers<ContextType = any, ParentType extends ResolversParentTypes['_RuleMessage'] = ResolversParentTypes['_RuleMessage']> = {
-	text?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _SchemaResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Schema'] = ResolversParentTypes['_Schema']> = {
-	enums?: Resolver<ReadonlyArray<ResolversTypes['_Enum']>, ParentType, ContextType>
-	entities?: Resolver<ReadonlyArray<ResolversTypes['_Entity']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _UniqueConstraintResolvers<ContextType = any, ParentType extends ResolversParentTypes['_UniqueConstraint'] = ResolversParentTypes['_UniqueConstraint']> = {
-	fields?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Validator'] = ResolversParentTypes['_Validator']> = {
-	operation?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	arguments?: Resolver<ReadonlyArray<ResolversTypes['_Argument']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_ValidatorArgument'] = ResolversParentTypes['_ValidatorArgument']> = {
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type Resolvers<ContextType = any> = {
-	Json?: GraphQLScalarType
-	Query?: QueryResolvers<ContextType>
-	_Argument?: _ArgumentResolvers<ContextType>
-	_Column?: _ColumnResolvers<ContextType>
-	_Entity?: _EntityResolvers<ContextType>
-	_Enum?: _EnumResolvers<ContextType>
-	_Field?: _FieldResolvers<ContextType>
-	_LiteralArgument?: _LiteralArgumentResolvers<ContextType>
-	_OrderBy?: _OrderByResolvers<ContextType>
-	_PathArgument?: _PathArgumentResolvers<ContextType>
-	_Relation?: _RelationResolvers<ContextType>
-	_Rule?: _RuleResolvers<ContextType>
-	_RuleMessage?: _RuleMessageResolvers<ContextType>
-	_Schema?: _SchemaResolvers<ContextType>
-	_UniqueConstraint?: _UniqueConstraintResolvers<ContextType>
-	_Validator?: _ValidatorResolvers<ContextType>
-	_ValidatorArgument?: _ValidatorArgumentResolvers<ContextType>
-}
-
-
-/**
- * @deprecated
- * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.
- */
-export type IResolvers<ContextType = any> = Resolvers<ContextType>