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

package/src/generated/fetchers/IdentityFetcher.ts

@@ -0,0 +1,257 @@
+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 IdentityFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'Identity', T, TVariables> {
+
+    on<XName extends ImplementationType<'Identity'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): IdentityFetcher<
+        XName extends 'Identity' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'Identity'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'Identity'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): IdentityFetcher<T, TVariables>;
+
+
+    readonly __typename: IdentityFetcher<T & {__typename: ImplementationType<'Identity'>}, TVariables>;
+
+
+    readonly id: IdentityFetcher<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>
+    ): IdentityFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~id": IdentityFetcher<Omit<T, 'id'>, TVariables>;
+
+
+    readonly description: IdentityFetcher<T & {readonly "description"?: string}, TVariables>;
+
+    "description+"<
+        XAlias extends string = "description", 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"description", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & {readonly [key in XAlias]?: string}, 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~description": IdentityFetcher<Omit<T, 'description'>, TVariables>;
+
+
+    person<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'Person', X, XVariables>
+    ): IdentityFetcher<
+        T & {readonly "person"?: X}, 
+        TVariables & XVariables
+    >;
+
+    person<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "person", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'Person', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"person", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    apiKey<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'ApiKey', X, XVariables>
+    ): IdentityFetcher<
+        T & {readonly "apiKey"?: X}, 
+        TVariables & XVariables
+    >;
+
+    apiKey<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "apiKey", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'ApiKey', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"apiKey", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    projects<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'IdentityProjectRelation', X, XVariables>
+    ): IdentityFetcher<
+        T & {readonly "projects": ReadonlyArray<X>}, 
+        TVariables & XVariables
+    >;
+
+    projects<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "projects", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'IdentityProjectRelation', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"projects", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    permissions<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'IdentityGlobalPermissions', X, XVariables>
+    ): IdentityFetcher<
+        T & {readonly "permissions"?: X}, 
+        TVariables & XVariables
+    >;
+
+    permissions<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "permissions", 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'IdentityGlobalPermissions', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"permissions", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & {readonly [key in XAlias]?: X}, 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    readonly roles: IdentityFetcher<T & {readonly "roles"?: ReadonlyArray<string>}, TVariables>;
+
+    "roles+"<
+        XAlias extends string = "roles", 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"roles", {}, {}>
+        ) => FieldOptions<XAlias, {readonly [key: string]: DirectiveArgs}, XDirectiveVariables>
+    ): IdentityFetcher<
+        T & {readonly [key in XAlias]?: ReadonlyArray<string>}, 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~roles": IdentityFetcher<Omit<T, 'roles'>, TVariables>;
+}
+
+export const identity$: IdentityFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "Identity", 
+            "OBJECT", 
+            [], 
+            [
+                {
+                    category: "ID", 
+                    name: "id"
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "description", 
+                    undefinable: true
+                }, 
+                {
+                    category: "REFERENCE", 
+                    name: "person", 
+                    targetTypeName: "Person", 
+                    undefinable: true
+                }, 
+                {
+                    category: "REFERENCE", 
+                    name: "apiKey", 
+                    targetTypeName: "ApiKey", 
+                    undefinable: true
+                }, 
+                {
+                    category: "LIST", 
+                    name: "projects", 
+                    targetTypeName: "IdentityProjectRelation"
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "permissions", 
+                    targetTypeName: "IdentityGlobalPermissions", 
+                    undefinable: true
+                }, 
+                {
+                    category: "SCALAR", 
+                    name: "roles", 
+                    undefinable: true
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const identity$$ = 
+    identity$
+        .id
+        .description
+        .roles
+;

package/src/generated/fetchers/IdentityGlobalPermissionsFetcher.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 IdentityGlobalPermissionsFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'IdentityGlobalPermissions', T, TVariables> {
+
+    on<XName extends ImplementationType<'IdentityGlobalPermissions'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): IdentityGlobalPermissionsFetcher<
+        XName extends 'IdentityGlobalPermissions' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'IdentityGlobalPermissions'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'IdentityGlobalPermissions'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): IdentityGlobalPermissionsFetcher<T, TVariables>;
+
+
+    readonly __typename: IdentityGlobalPermissionsFetcher<T & {__typename: ImplementationType<'IdentityGlobalPermissions'>}, TVariables>;
+
+
+    readonly canCreateProject: IdentityGlobalPermissionsFetcher<T & {readonly "canCreateProject": boolean}, TVariables>;
+
+    "canCreateProject+"<
+        XAlias extends string = "canCreateProject", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"canCreateProject", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): IdentityGlobalPermissionsFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: boolean} : 
+                {readonly [key in XAlias]: boolean}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~canCreateProject": IdentityGlobalPermissionsFetcher<Omit<T, 'canCreateProject'>, TVariables>;
+}
+
+export const identityGlobalPermissions$: IdentityGlobalPermissionsFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "IdentityGlobalPermissions", 
+            "EMBEDDED", 
+            [], 
+            [
+                "canCreateProject"
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const identityGlobalPermissions$$ = 
+    identityGlobalPermissions$
+        .canCreateProject
+;

package/src/generated/fetchers/IdentityProjectRelationFetcher.ts

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

package/src/generated/fetchers/IdentityProviderFetcher.ts

@@ -0,0 +1,184 @@
+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 IdentityProviderFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'IdentityProvider', T, TVariables> {
+
+    on<XName extends ImplementationType<'IdentityProvider'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): IdentityProviderFetcher<
+        XName extends 'IdentityProvider' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'IdentityProvider'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'IdentityProvider'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): IdentityProviderFetcher<T, TVariables>;
+
+
+    readonly __typename: IdentityProviderFetcher<T & {__typename: ImplementationType<'IdentityProvider'>}, TVariables>;
+
+
+    readonly slug: IdentityProviderFetcher<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>
+    ): IdentityProviderFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~slug": IdentityProviderFetcher<Omit<T, 'slug'>, TVariables>;
+
+
+    readonly type: IdentityProviderFetcher<T & {readonly "type": string}, TVariables>;
+
+    "type+"<
+        XAlias extends string = "type", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"type", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): IdentityProviderFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~type": IdentityProviderFetcher<Omit<T, 'type'>, TVariables>;
+
+
+    readonly configuration: IdentityProviderFetcher<T & {readonly "configuration": unknown}, TVariables>;
+
+    "configuration+"<
+        XAlias extends string = "configuration", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"configuration", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): IdentityProviderFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: unknown} : 
+                {readonly [key in XAlias]: unknown}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~configuration": IdentityProviderFetcher<Omit<T, 'configuration'>, 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>
+    ): IdentityProviderFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~disabledAt": IdentityProviderFetcher<Omit<T, 'disabledAt'>, TVariables>;
+
+
+    options<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'IDPOptionsOutput', X, XVariables>
+    ): IdentityProviderFetcher<
+        T & {readonly "options": X}, 
+        TVariables & XVariables
+    >;
+
+    options<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "options", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'IDPOptionsOutput', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"options", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): IdentityProviderFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: X} : 
+                {readonly [key in XAlias]: X}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+}
+
+export const identityProvider$: IdentityProviderFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "IdentityProvider", 
+            "EMBEDDED", 
+            [], 
+            [
+                "slug", 
+                "type", 
+                "configuration", 
+                "disabledAt", 
+                {
+                    category: "SCALAR", 
+                    name: "options", 
+                    targetTypeName: "IDPOptionsOutput"
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const identityProvider$$ = 
+    identityProvider$
+        .slug
+        .type
+        .configuration
+        .disabledAt
+;