@contember/graphql-client-tenant 1.3.0-alpha.8 → 1.3.0-beta.1

package/src/generated/fetchers/AddGlobalIdentityRolesErrorFetcher.ts

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

package/src/generated/fetchers/AddGlobalIdentityRolesResponseFetcher.ts

@@ -0,0 +1,140 @@
+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 AddGlobalIdentityRolesResponseFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'AddGlobalIdentityRolesResponse', T, TVariables> {
+
+    on<XName extends ImplementationType<'AddGlobalIdentityRolesResponse'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): AddGlobalIdentityRolesResponseFetcher<
+        XName extends 'AddGlobalIdentityRolesResponse' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'AddGlobalIdentityRolesResponse'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'AddGlobalIdentityRolesResponse'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): AddGlobalIdentityRolesResponseFetcher<T, TVariables>;
+
+
+    readonly __typename: AddGlobalIdentityRolesResponseFetcher<T & {__typename: ImplementationType<'AddGlobalIdentityRolesResponse'>}, TVariables>;
+
+
+    readonly ok: AddGlobalIdentityRolesResponseFetcher<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>
+    ): AddGlobalIdentityRolesResponseFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: boolean} : 
+                {readonly [key in XAlias]: boolean}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~ok": AddGlobalIdentityRolesResponseFetcher<Omit<T, 'ok'>, TVariables>;
+
+
+    error<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'AddGlobalIdentityRolesError', X, XVariables>
+    ): AddGlobalIdentityRolesResponseFetcher<
+        T & {readonly "error"?: X}, 
+        TVariables & XVariables
+    >;
+
+    error<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "error", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'AddGlobalIdentityRolesError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"error", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): AddGlobalIdentityRolesResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    result<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'AddGlobalIdentityRolesResult', X, XVariables>
+    ): AddGlobalIdentityRolesResponseFetcher<
+        T & {readonly "result"?: X}, 
+        TVariables & XVariables
+    >;
+
+    result<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "result", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'AddGlobalIdentityRolesResult', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"result", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): AddGlobalIdentityRolesResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const addGlobalIdentityRolesResponse$: AddGlobalIdentityRolesResponseFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "AddGlobalIdentityRolesResponse", 
+            "EMBEDDED", 
+            [], 
+            [
+                "ok", 
+                {
+                    category: "SCALAR", 
+                    name: "error", 
+                    targetTypeName: "AddGlobalIdentityRolesError", 
+                    undefinable: true
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "result", 
+                    targetTypeName: "AddGlobalIdentityRolesResult", 
+                    undefinable: true
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const addGlobalIdentityRolesResponse$$ = 
+    addGlobalIdentityRolesResponse$
+        .ok
+;

package/src/generated/fetchers/AddGlobalIdentityRolesResultFetcher.ts

@@ -0,0 +1,84 @@
+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 AddGlobalIdentityRolesResultFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'AddGlobalIdentityRolesResult', T, TVariables> {
+
+    on<XName extends ImplementationType<'AddGlobalIdentityRolesResult'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): AddGlobalIdentityRolesResultFetcher<
+        XName extends 'AddGlobalIdentityRolesResult' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'AddGlobalIdentityRolesResult'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'AddGlobalIdentityRolesResult'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): AddGlobalIdentityRolesResultFetcher<T, TVariables>;
+
+
+    readonly __typename: AddGlobalIdentityRolesResultFetcher<T & {__typename: ImplementationType<'AddGlobalIdentityRolesResult'>}, TVariables>;
+
+
+    identity<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'Identity', X, XVariables>
+    ): AddGlobalIdentityRolesResultFetcher<
+        T & {readonly "identity": X}, 
+        TVariables & XVariables
+    >;
+
+    identity<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "identity", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'Identity', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"identity", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): AddGlobalIdentityRolesResultFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: X} : 
+                {readonly [key in XAlias]: X}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const addGlobalIdentityRolesResult$: AddGlobalIdentityRolesResultFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "AddGlobalIdentityRolesResult", 
+            "EMBEDDED", 
+            [], 
+            [
+                {
+                    category: "REFERENCE", 
+                    name: "identity", 
+                    targetTypeName: "Identity"
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;

package/src/generated/fetchers/DisablePersonErrorFetcher.ts

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

package/src/generated/fetchers/DisablePersonResponseFetcher.ts

@@ -0,0 +1,108 @@
+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 DisablePersonResponseFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'DisablePersonResponse', T, TVariables> {
+
+    on<XName extends ImplementationType<'DisablePersonResponse'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): DisablePersonResponseFetcher<
+        XName extends 'DisablePersonResponse' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'DisablePersonResponse'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'DisablePersonResponse'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): DisablePersonResponseFetcher<T, TVariables>;
+
+
+    readonly __typename: DisablePersonResponseFetcher<T & {__typename: ImplementationType<'DisablePersonResponse'>}, TVariables>;
+
+
+    readonly ok: DisablePersonResponseFetcher<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>
+    ): DisablePersonResponseFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: boolean} : 
+                {readonly [key in XAlias]: boolean}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~ok": DisablePersonResponseFetcher<Omit<T, 'ok'>, TVariables>;
+
+
+    error<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'DisablePersonError', X, XVariables>
+    ): DisablePersonResponseFetcher<
+        T & {readonly "error"?: X}, 
+        TVariables & XVariables
+    >;
+
+    error<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "error", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'DisablePersonError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"error", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): DisablePersonResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const disablePersonResponse$: DisablePersonResponseFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "DisablePersonResponse", 
+            "EMBEDDED", 
+            [], 
+            [
+                "ok", 
+                {
+                    category: "SCALAR", 
+                    name: "error", 
+                    targetTypeName: "DisablePersonError", 
+                    undefinable: true
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const disablePersonResponse$$ = 
+    disablePersonResponse$
+        .ok
+;

package/src/generated/fetchers/IdentityProviderFetcher.ts

@@ -99,22 +99,17 @@ export interface IdentityProviderFetcher<T extends object, TVariables extends ob
     readonly "~configuration": IdentityProviderFetcher<Omit<T, 'configuration'>, TVariables>;
 
 
-    readonly disabledAt: IdentityProviderFetcher<T & {readonly "disabledAt": string}, TVariables>;
+    readonly disabledAt: IdentityProviderFetcher<T & {readonly "disabledAt"?: string}, TVariables>;
 
     "disabledAt+"<
         XAlias extends string = "disabledAt", 
-        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
         XDirectiveVariables extends object = {}
     >(
         optionsConfigurer: (
             options: FieldOptions<"disabledAt", {}, {}>
-        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
     ): IdentityProviderFetcher<
-        T & (
-            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
-                {readonly [key in XAlias]?: string} : 
-                {readonly [key in XAlias]: string}
-        ), 
+        T & {readonly [key in XAlias]?: string}, 
         TVariables & XDirectiveVariables
     >;
 
@@ -162,7 +157,11 @@ export const identityProvider$: IdentityProviderFetcher<{}, {}> =
                 "slug", 
                 "type", 
                 "configuration", 
-                "disabledAt", 
+                {
+                    category: "SCALAR", 
+                    name: "disabledAt", 
+                    undefinable: true
+                }, 
                 {
                     category: "SCALAR", 
                     name: "options",