@contember/graphql-client-system 1.2.0-rc.2

package/src/generated/fetchers/ExecutedMigrationFetcher.ts

@@ -0,0 +1,196 @@
+import type { FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type { WithTypeName, ImplementationType } from '../CommonTypes';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface ExecutedMigrationFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'ExecutedMigration', T, TVariables> {
+
+    on<XName extends ImplementationType<'ExecutedMigration'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): ExecutedMigrationFetcher<
+        XName extends 'ExecutedMigration' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'ExecutedMigration'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'ExecutedMigration'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): ExecutedMigrationFetcher<T, TVariables>;
+
+
+    readonly __typename: ExecutedMigrationFetcher<T & {__typename: ImplementationType<'ExecutedMigration'>}, TVariables>;
+
+
+    readonly version: ExecutedMigrationFetcher<T & {readonly "version": string}, TVariables>;
+
+    "version+"<
+        XAlias extends string = "version", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"version", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~version": ExecutedMigrationFetcher<Omit<T, 'version'>, TVariables>;
+
+
+    readonly name: ExecutedMigrationFetcher<T & {readonly "name": string}, TVariables>;
+
+    "name+"<
+        XAlias extends string = "name", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"name", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~name": ExecutedMigrationFetcher<Omit<T, 'name'>, TVariables>;
+
+
+    readonly executedAt: ExecutedMigrationFetcher<T & {readonly "executedAt": string}, TVariables>;
+
+    "executedAt+"<
+        XAlias extends string = "executedAt", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"executedAt", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~executedAt": ExecutedMigrationFetcher<Omit<T, 'executedAt'>, TVariables>;
+
+
+    readonly checksum: ExecutedMigrationFetcher<T & {readonly "checksum": string}, TVariables>;
+
+    "checksum+"<
+        XAlias extends string = "checksum", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"checksum", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~checksum": ExecutedMigrationFetcher<Omit<T, 'checksum'>, TVariables>;
+
+
+    readonly formatVersion: ExecutedMigrationFetcher<T & {readonly "formatVersion": number}, TVariables>;
+
+    "formatVersion+"<
+        XAlias extends string = "formatVersion", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"formatVersion", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: number} : 
+                {readonly [key in XAlias]: number}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~formatVersion": ExecutedMigrationFetcher<Omit<T, 'formatVersion'>, TVariables>;
+
+
+    readonly modifications: ExecutedMigrationFetcher<T & {readonly "modifications": ReadonlyArray<unknown>}, TVariables>;
+
+    "modifications+"<
+        XAlias extends string = "modifications", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"modifications", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ExecutedMigrationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<unknown>} : 
+                {readonly [key in XAlias]: ReadonlyArray<unknown>}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~modifications": ExecutedMigrationFetcher<Omit<T, 'modifications'>, TVariables>;
+}
+
+export const executedMigration$: ExecutedMigrationFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "ExecutedMigration", 
+            "EMBEDDED", 
+            [], 
+            [
+                "version", 
+                "name", 
+                "executedAt", 
+                "checksum", 
+                "formatVersion", 
+                "modifications"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const executedMigration$$ = 
+    executedMigration$
+        .version
+        .name
+        .executedAt
+        .checksum
+        .formatVersion
+        .modifications
+;

package/src/generated/fetchers/MigrateErrorFetcher.ts

@@ -0,0 +1,125 @@
+import type { FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type { WithTypeName, ImplementationType } from '../CommonTypes';
+import type {MigrateErrorCode} from '../enums';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface MigrateErrorFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'MigrateError', T, TVariables> {
+
+    on<XName extends ImplementationType<'MigrateError'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): MigrateErrorFetcher<
+        XName extends 'MigrateError' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'MigrateError'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'MigrateError'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): MigrateErrorFetcher<T, TVariables>;
+
+
+    readonly __typename: MigrateErrorFetcher<T & {__typename: ImplementationType<'MigrateError'>}, TVariables>;
+
+
+    readonly code: MigrateErrorFetcher<T & {readonly "code": MigrateErrorCode}, TVariables>;
+
+    "code+"<
+        XAlias extends string = "code", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"code", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateErrorFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: MigrateErrorCode} : 
+                {readonly [key in XAlias]: MigrateErrorCode}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~code": MigrateErrorFetcher<Omit<T, 'code'>, TVariables>;
+
+
+    readonly migration: MigrateErrorFetcher<T & {readonly "migration": string}, TVariables>;
+
+    "migration+"<
+        XAlias extends string = "migration", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"migration", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateErrorFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~migration": MigrateErrorFetcher<Omit<T, 'migration'>, TVariables>;
+
+
+    readonly developerMessage: MigrateErrorFetcher<T & {readonly "developerMessage": string}, TVariables>;
+
+    "developerMessage+"<
+        XAlias extends string = "developerMessage", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"developerMessage", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateErrorFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~developerMessage": MigrateErrorFetcher<Omit<T, 'developerMessage'>, TVariables>;
+}
+
+export const migrateError$: MigrateErrorFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "MigrateError", 
+            "EMBEDDED", 
+            [], 
+            [
+                "code", 
+                "migration", 
+                "developerMessage"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const migrateError$$ = 
+    migrateError$
+        .code
+        .migration
+        .developerMessage
+;

package/src/generated/fetchers/MigrateResponseFetcher.ts

@@ -0,0 +1,182 @@
+import type { FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type { WithTypeName, ImplementationType } from '../CommonTypes';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface MigrateResponseFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'MigrateResponse', T, TVariables> {
+
+    on<XName extends ImplementationType<'MigrateResponse'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): MigrateResponseFetcher<
+        XName extends 'MigrateResponse' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'MigrateResponse'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'MigrateResponse'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): MigrateResponseFetcher<T, TVariables>;
+
+
+    readonly __typename: MigrateResponseFetcher<T & {__typename: ImplementationType<'MigrateResponse'>}, TVariables>;
+
+
+    readonly ok: MigrateResponseFetcher<T & {readonly "ok": boolean}, TVariables>;
+
+    "ok+"<
+        XAlias extends string = "ok", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"ok", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateResponseFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: boolean} : 
+                {readonly [key in XAlias]: boolean}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~ok": MigrateResponseFetcher<Omit<T, 'ok'>, TVariables>;
+
+
+    /**
+     * @deprecated No longer supported
+     */
+    errors<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'MigrateError', X, XVariables>
+    ): MigrateResponseFetcher<
+        T & {readonly "errors": ReadonlyArray<X>}, 
+        TVariables & XVariables
+    >;
+
+    /**
+     * @deprecated No longer supported
+     */
+    errors<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "errors", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'MigrateError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"errors", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateResponseFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    error<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'MigrateError', X, XVariables>
+    ): MigrateResponseFetcher<
+        T & {readonly "error"?: X}, 
+        TVariables & XVariables
+    >;
+
+    error<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "error", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'MigrateError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"error", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): MigrateResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    result<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'MigrateResult', X, XVariables>
+    ): MigrateResponseFetcher<
+        T & {readonly "result"?: X}, 
+        TVariables & XVariables
+    >;
+
+    result<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "result", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'MigrateResult', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"result", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): MigrateResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const migrateResponse$: MigrateResponseFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "MigrateResponse", 
+            "EMBEDDED", 
+            [], 
+            [
+                "ok", 
+                {
+                    category: "LIST", 
+                    name: "errors", 
+                    targetTypeName: "MigrateError"
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "error", 
+                    targetTypeName: "MigrateError", 
+                    undefinable: true
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "result", 
+                    targetTypeName: "MigrateResult", 
+                    undefinable: true
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const migrateResponse$$ = 
+    migrateResponse$
+        .ok
+;

package/src/generated/fetchers/MigrateResultFetcher.ts

@@ -0,0 +1,76 @@
+import type { FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type { WithTypeName, ImplementationType } from '../CommonTypes';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface MigrateResultFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'MigrateResult', T, TVariables> {
+
+    on<XName extends ImplementationType<'MigrateResult'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): MigrateResultFetcher<
+        XName extends 'MigrateResult' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'MigrateResult'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'MigrateResult'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): MigrateResultFetcher<T, TVariables>;
+
+
+    readonly __typename: MigrateResultFetcher<T & {__typename: ImplementationType<'MigrateResult'>}, TVariables>;
+
+
+    readonly message: MigrateResultFetcher<T & {readonly "message": string}, TVariables>;
+
+    "message+"<
+        XAlias extends string = "message", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"message", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MigrateResultFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~message": MigrateResultFetcher<Omit<T, 'message'>, TVariables>;
+}
+
+export const migrateResult$: MigrateResultFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "MigrateResult", 
+            "EMBEDDED", 
+            [], 
+            [
+                "message"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const migrateResult$$ = 
+    migrateResult$
+        .message
+;

package/src/generated/fetchers/MutationFetcher.ts

@@ -0,0 +1,110 @@
+import type { AcceptableVariables, UnresolvedVariables, FieldOptions, DirectiveArgs } from 'graphql-ts-client-api';
+import { ENUM_INPUT_METADATA } from '../EnumInputMetadata';
+import type { ObjectFetcher } from 'graphql-ts-client-api';
+import { createFetcher, createFetchableType } from 'graphql-ts-client-api';
+import type {Migration} from '../inputs';
+
+/*
+ * Any instance of this interface is immutable,
+ * all the properties and functions can only be used to create new instances,
+ * they cannot modify the current instance.
+ * 
+ * So any instance of this interface is reuseable.
+ */
+export interface MutationFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'Mutation', T, TVariables> {
+
+
+    directive(name: string, args?: DirectiveArgs): MutationFetcher<T, TVariables>;
+
+
+    migrate<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'MigrateResponse', X, XVariables>
+    ): MutationFetcher<
+        T & {readonly "migrate": X}, 
+        TVariables & XVariables & MutationArgs["migrate"]
+    >;
+
+    migrate<
+        XArgs extends AcceptableVariables<MutationArgs['migrate']>, 
+        X extends object, 
+        XVariables extends object
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'MigrateResponse', X, XVariables>
+    ): MutationFetcher<
+        T & {readonly "migrate": X}, 
+        TVariables & XVariables & UnresolvedVariables<XArgs, MutationArgs['migrate']>
+    >;
+
+    migrate<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "migrate", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'MigrateResponse', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"migrate", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MutationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: X} : 
+                {readonly [key in XAlias]: X}
+        ), 
+        TVariables & XVariables & MutationArgs["migrate"] & XDirectiveVariables
+    >;
+
+    migrate<
+        XArgs extends AcceptableVariables<MutationArgs['migrate']>, 
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "migrate", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'MigrateResponse', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"migrate", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): MutationFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: X} : 
+                {readonly [key in XAlias]: X}
+        ), 
+        TVariables & XVariables & UnresolvedVariables<XArgs, MutationArgs['migrate']> & XDirectiveVariables
+    >;
+}
+
+export const mutation$: MutationFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "Mutation", 
+            "EMBEDDED", 
+            [], 
+            [
+                {
+                    category: "SCALAR", 
+                    name: "migrate", 
+                    argGraphQLTypeMap: {migrations: '[Migration!]!'}, 
+                    targetTypeName: "MigrateResponse"
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export interface MutationArgs {
+
+    readonly migrate: {
+        readonly migrations: ReadonlyArray<Migration>
+    }
+}