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

package/src/generated/fetchers/InviteResponseFetcher.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 InviteResponseFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'InviteResponse', T, TVariables> {
+
+    on<XName extends ImplementationType<'InviteResponse'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): InviteResponseFetcher<
+        XName extends 'InviteResponse' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'InviteResponse'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'InviteResponse'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): InviteResponseFetcher<T, TVariables>;
+
+
+    readonly __typename: InviteResponseFetcher<T & {__typename: ImplementationType<'InviteResponse'>}, TVariables>;
+
+
+    readonly ok: InviteResponseFetcher<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>
+    ): InviteResponseFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: boolean} : 
+                {readonly [key in XAlias]: boolean}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~ok": InviteResponseFetcher<Omit<T, 'ok'>, TVariables>;
+
+
+    /**
+     * @deprecated No longer supported
+     */
+    errors<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'InviteError', X, XVariables>
+    ): InviteResponseFetcher<
+        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<'InviteError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"errors", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): InviteResponseFetcher<
+        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<'InviteError', X, XVariables>
+    ): InviteResponseFetcher<
+        T & {readonly "error"?: X}, 
+        TVariables & XVariables
+    >;
+
+    error<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "error", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'InviteError', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"error", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): InviteResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    result<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'InviteResult', X, XVariables>
+    ): InviteResponseFetcher<
+        T & {readonly "result"?: X}, 
+        TVariables & XVariables
+    >;
+
+    result<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "result", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'InviteResult', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"result", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): InviteResponseFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const inviteResponse$: InviteResponseFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "InviteResponse", 
+            "EMBEDDED", 
+            [], 
+            [
+                "ok", 
+                {
+                    category: "LIST", 
+                    name: "errors", 
+                    targetTypeName: "InviteError"
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "error", 
+                    targetTypeName: "InviteError", 
+                    undefinable: true
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "result", 
+                    targetTypeName: "InviteResult", 
+                    undefinable: true
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const inviteResponse$$ = 
+    inviteResponse$
+        .ok
+;

package/src/generated/fetchers/InviteResultFetcher.ts

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

package/src/generated/fetchers/MembershipFetcher.ts

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

package/src/generated/fetchers/MembershipValidationErrorFetcher.ts

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