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

package/src/generated/fetchers/QueryFetcher.ts

@@ -0,0 +1,221 @@
+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 {EventsArgs} 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 QueryFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'Query', T, TVariables> {
+
+
+    directive(name: string, args?: DirectiveArgs): QueryFetcher<T, TVariables>;
+
+
+    stages<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'Stage', X, XVariables>
+    ): QueryFetcher<
+        T & {readonly "stages": ReadonlyArray<X>}, 
+        TVariables & XVariables
+    >;
+
+    stages<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "stages", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'Stage', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"stages", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): QueryFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    executedMigrations<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'ExecutedMigration', X, XVariables>
+    ): QueryFetcher<
+        T & {readonly "executedMigrations": ReadonlyArray<X>}, 
+        TVariables & XVariables & QueryArgs["executedMigrations"]
+    >;
+
+    executedMigrations<
+        XArgs extends AcceptableVariables<QueryArgs['executedMigrations']>, 
+        X extends object, 
+        XVariables extends object
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'ExecutedMigration', X, XVariables>
+    ): QueryFetcher<
+        T & {readonly "executedMigrations": ReadonlyArray<X>}, 
+        TVariables & XVariables & UnresolvedVariables<XArgs, QueryArgs['executedMigrations']>
+    >;
+
+    executedMigrations<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "executedMigrations", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'ExecutedMigration', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"executedMigrations", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): QueryFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & QueryArgs["executedMigrations"] & XDirectiveVariables
+    >;
+
+    executedMigrations<
+        XArgs extends AcceptableVariables<QueryArgs['executedMigrations']>, 
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "executedMigrations", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'ExecutedMigration', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"executedMigrations", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): QueryFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & UnresolvedVariables<XArgs, QueryArgs['executedMigrations']> & XDirectiveVariables
+    >;
+
+
+    events<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'Event', X, XVariables>
+    ): QueryFetcher<
+        T & {readonly "events": ReadonlyArray<X>}, 
+        TVariables & XVariables & QueryArgs["events"]
+    >;
+
+    events<
+        XArgs extends AcceptableVariables<QueryArgs['events']>, 
+        X extends object, 
+        XVariables extends object
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'Event', X, XVariables>
+    ): QueryFetcher<
+        T & {readonly "events": ReadonlyArray<X>}, 
+        TVariables & XVariables & UnresolvedVariables<XArgs, QueryArgs['events']>
+    >;
+
+    events<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "events", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'Event', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"events", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): QueryFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & QueryArgs["events"] & XDirectiveVariables
+    >;
+
+    events<
+        XArgs extends AcceptableVariables<QueryArgs['events']>, 
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "events", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'Event', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"events", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): QueryFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & UnresolvedVariables<XArgs, QueryArgs['events']> & XDirectiveVariables
+    >;
+}
+
+export const query$: QueryFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "Query", 
+            "OBJECT", 
+            [], 
+            [
+                {
+                    category: "LIST", 
+                    name: "stages", 
+                    targetTypeName: "Stage"
+                }, 
+                {
+                    category: "LIST", 
+                    name: "executedMigrations", 
+                    argGraphQLTypeMap: {version: 'String'}, 
+                    targetTypeName: "ExecutedMigration"
+                }, 
+                {
+                    category: "LIST", 
+                    name: "events", 
+                    argGraphQLTypeMap: {args: 'EventsArgs'}, 
+                    targetTypeName: "Event"
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export interface QueryArgs {
+
+    readonly executedMigrations: {
+        readonly version?: string
+    }, 
+
+    readonly events: {
+        readonly args?: EventsArgs
+    }
+}

package/src/generated/fetchers/StageFetcher.ts

@@ -0,0 +1,127 @@
+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 StageFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'Stage', T, TVariables> {
+
+    on<XName extends ImplementationType<'Stage'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): StageFetcher<
+        XName extends 'Stage' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'Stage'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'Stage'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): StageFetcher<T, TVariables>;
+
+
+    readonly __typename: StageFetcher<T & {__typename: ImplementationType<'Stage'>}, TVariables>;
+
+
+    readonly id: StageFetcher<T & {readonly "id": string}, TVariables>;
+
+    "id+"<
+        XAlias extends string = "id", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"id", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): StageFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~id": StageFetcher<Omit<T, 'id'>, TVariables>;
+
+
+    readonly name: StageFetcher<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>
+    ): StageFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~name": StageFetcher<Omit<T, 'name'>, TVariables>;
+
+
+    readonly slug: StageFetcher<T & {readonly "slug": string}, TVariables>;
+
+    "slug+"<
+        XAlias extends string = "slug", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"slug", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): StageFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~slug": StageFetcher<Omit<T, 'slug'>, TVariables>;
+}
+
+export const stage$: StageFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "Stage", 
+            "OBJECT", 
+            [], 
+            [
+                {
+                    category: "ID", 
+                    name: "id"
+                }, 
+                "name", 
+                "slug"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const stage$$ = 
+    stage$
+        .id
+        .name
+        .slug
+;

package/src/generated/fetchers/UpdateEventFetcher.ts

@@ -0,0 +1,332 @@
+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 { event$ } from './EventFetcher';
+import type {EventType} 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 UpdateEventFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'UpdateEvent', T, TVariables> {
+
+    on<XName extends ImplementationType<'UpdateEvent'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): UpdateEventFetcher<
+        XName extends 'UpdateEvent' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'UpdateEvent'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'UpdateEvent'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): UpdateEventFetcher<T, TVariables>;
+
+
+    readonly __typename: UpdateEventFetcher<T & {__typename: ImplementationType<'UpdateEvent'>}, TVariables>;
+
+
+    readonly id: UpdateEventFetcher<T & {readonly "id": string}, TVariables>;
+
+    "id+"<
+        XAlias extends string = "id", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"id", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~id": UpdateEventFetcher<Omit<T, 'id'>, TVariables>;
+
+
+    readonly transactionId: UpdateEventFetcher<T & {readonly "transactionId": string}, TVariables>;
+
+    "transactionId+"<
+        XAlias extends string = "transactionId", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"transactionId", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~transactionId": UpdateEventFetcher<Omit<T, 'transactionId'>, TVariables>;
+
+
+    readonly identityId: UpdateEventFetcher<T & {readonly "identityId": string}, TVariables>;
+
+    "identityId+"<
+        XAlias extends string = "identityId", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"identityId", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~identityId": UpdateEventFetcher<Omit<T, 'identityId'>, TVariables>;
+
+
+    readonly identityDescription: UpdateEventFetcher<T & {readonly "identityDescription": string}, TVariables>;
+
+    "identityDescription+"<
+        XAlias extends string = "identityDescription", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"identityDescription", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~identityDescription": UpdateEventFetcher<Omit<T, 'identityDescription'>, TVariables>;
+
+
+    readonly description: UpdateEventFetcher<T & {readonly "description": string}, TVariables>;
+
+    "description+"<
+        XAlias extends string = "description", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"description", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~description": UpdateEventFetcher<Omit<T, 'description'>, TVariables>;
+
+
+    readonly createdAt: UpdateEventFetcher<T & {readonly "createdAt": string}, TVariables>;
+
+    "createdAt+"<
+        XAlias extends string = "createdAt", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"createdAt", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~createdAt": UpdateEventFetcher<Omit<T, 'createdAt'>, TVariables>;
+
+
+    readonly appliedAt: UpdateEventFetcher<T & {readonly "appliedAt": string}, TVariables>;
+
+    "appliedAt+"<
+        XAlias extends string = "appliedAt", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"appliedAt", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~appliedAt": UpdateEventFetcher<Omit<T, 'appliedAt'>, TVariables>;
+
+
+    readonly type: UpdateEventFetcher<T & {readonly "type": EventType}, TVariables>;
+
+    "type+"<
+        XAlias extends string = "type", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"type", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: EventType} : 
+                {readonly [key in XAlias]: EventType}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~type": UpdateEventFetcher<Omit<T, 'type'>, TVariables>;
+
+
+    readonly tableName: UpdateEventFetcher<T & {readonly "tableName": string}, TVariables>;
+
+    "tableName+"<
+        XAlias extends string = "tableName", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"tableName", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~tableName": UpdateEventFetcher<Omit<T, 'tableName'>, TVariables>;
+
+
+    readonly primaryKey: UpdateEventFetcher<T & {readonly "primaryKey": ReadonlyArray<number | string>}, TVariables>;
+
+    "primaryKey+"<
+        XAlias extends string = "primaryKey", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"primaryKey", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<number | string>} : 
+                {readonly [key in XAlias]: ReadonlyArray<number | string>}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~primaryKey": UpdateEventFetcher<Omit<T, 'primaryKey'>, TVariables>;
+
+
+    readonly oldValues: UpdateEventFetcher<T & {readonly "oldValues": unknown}, TVariables>;
+
+    "oldValues+"<
+        XAlias extends string = "oldValues", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"oldValues", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: unknown} : 
+                {readonly [key in XAlias]: unknown}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~oldValues": UpdateEventFetcher<Omit<T, 'oldValues'>, TVariables>;
+
+
+    readonly diffValues: UpdateEventFetcher<T & {readonly "diffValues": unknown}, TVariables>;
+
+    "diffValues+"<
+        XAlias extends string = "diffValues", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"diffValues", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): UpdateEventFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: unknown} : 
+                {readonly [key in XAlias]: unknown}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~diffValues": UpdateEventFetcher<Omit<T, 'diffValues'>, TVariables>;
+}
+
+export const updateEvent$: UpdateEventFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "UpdateEvent", 
+            "OBJECT", 
+            [event$.fetchableType], 
+            [
+                "oldValues", 
+                "diffValues"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const updateEvent$$ = 
+    updateEvent$
+        .id
+        .transactionId
+        .identityId
+        .identityDescription
+        .description
+        .createdAt
+        .appliedAt
+        .type
+        .tableName
+        .primaryKey
+        .oldValues
+        .diffValues
+;