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

package/src/generated/fetchers/UpdateProjectMemberResponseFetcher.ts

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

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

package/src/generated/fetchers/VariableEntryFetcher.ts

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

package/src/generated/fetchers/index.ts

@@ -0,0 +1,168 @@
+export type {QueryFetcher, QueryArgs} from './QueryFetcher';
+export {query$} from './QueryFetcher';
+export type {MutationFetcher, MutationArgs} from './MutationFetcher';
+export {mutation$} from './MutationFetcher';
+export type {SignUpResponseFetcher} from './SignUpResponseFetcher';
+export {signUpResponse$, signUpResponse$$} from './SignUpResponseFetcher';
+export type {SignUpErrorFetcher} from './SignUpErrorFetcher';
+export {signUpError$, signUpError$$} from './SignUpErrorFetcher';
+export type {SignUpResultFetcher} from './SignUpResultFetcher';
+export {signUpResult$} from './SignUpResultFetcher';
+export type {CommonSignInResultFetcher} from './CommonSignInResultFetcher';
+export {commonSignInResult$, commonSignInResult$$} from './CommonSignInResultFetcher';
+export type {SignInResponseFetcher} from './SignInResponseFetcher';
+export {signInResponse$, signInResponse$$} from './SignInResponseFetcher';
+export type {SignInErrorFetcher} from './SignInErrorFetcher';
+export {signInError$, signInError$$} from './SignInErrorFetcher';
+export type {SignInResultFetcher} from './SignInResultFetcher';
+export {signInResult$, signInResult$$} from './SignInResultFetcher';
+export type {CreateSessionTokenResponseFetcher} from './CreateSessionTokenResponseFetcher';
+export {createSessionTokenResponse$, createSessionTokenResponse$$} from './CreateSessionTokenResponseFetcher';
+export type {CreateSessionTokenErrorFetcher} from './CreateSessionTokenErrorFetcher';
+export {createSessionTokenError$, createSessionTokenError$$} from './CreateSessionTokenErrorFetcher';
+export type {CreateSessionTokenResultFetcher} from './CreateSessionTokenResultFetcher';
+export {createSessionTokenResult$, createSessionTokenResult$$} from './CreateSessionTokenResultFetcher';
+export type {SignOutResponseFetcher} from './SignOutResponseFetcher';
+export {signOutResponse$, signOutResponse$$} from './SignOutResponseFetcher';
+export type {SignOutErrorFetcher} from './SignOutErrorFetcher';
+export {signOutError$, signOutError$$} from './SignOutErrorFetcher';
+export type {ChangePasswordResponseFetcher} from './ChangePasswordResponseFetcher';
+export {changePasswordResponse$, changePasswordResponse$$} from './ChangePasswordResponseFetcher';
+export type {ChangePasswordErrorFetcher} from './ChangePasswordErrorFetcher';
+export {changePasswordError$, changePasswordError$$} from './ChangePasswordErrorFetcher';
+export type {ChangeMyPasswordResponseFetcher} from './ChangeMyPasswordResponseFetcher';
+export {changeMyPasswordResponse$, changeMyPasswordResponse$$} from './ChangeMyPasswordResponseFetcher';
+export type {ChangeMyPasswordErrorFetcher} from './ChangeMyPasswordErrorFetcher';
+export {changeMyPasswordError$, changeMyPasswordError$$} from './ChangeMyPasswordErrorFetcher';
+export type {InitSignInIDPResponseFetcher} from './InitSignInIDPResponseFetcher';
+export {initSignInIDPResponse$, initSignInIDPResponse$$} from './InitSignInIDPResponseFetcher';
+export type {InitSignInIDPResultFetcher} from './InitSignInIDPResultFetcher';
+export {initSignInIDPResult$, initSignInIDPResult$$} from './InitSignInIDPResultFetcher';
+export type {InitSignInIDPErrorFetcher} from './InitSignInIDPErrorFetcher';
+export {initSignInIDPError$, initSignInIDPError$$} from './InitSignInIDPErrorFetcher';
+export type {SignInIDPResponseFetcher} from './SignInIDPResponseFetcher';
+export {signInIDPResponse$, signInIDPResponse$$} from './SignInIDPResponseFetcher';
+export type {SignInIDPErrorFetcher} from './SignInIDPErrorFetcher';
+export {signInIDPError$, signInIDPError$$} from './SignInIDPErrorFetcher';
+export type {SignInIDPResultFetcher} from './SignInIDPResultFetcher';
+export {signInIDPResult$, signInIDPResult$$} from './SignInIDPResultFetcher';
+export type {AddIDPResponseFetcher} from './AddIDPResponseFetcher';
+export {addIDPResponse$, addIDPResponse$$} from './AddIDPResponseFetcher';
+export type {AddIDPErrorFetcher} from './AddIDPErrorFetcher';
+export {addIDPError$, addIDPError$$} from './AddIDPErrorFetcher';
+export type {UpdateIDPResponseFetcher} from './UpdateIDPResponseFetcher';
+export {updateIDPResponse$, updateIDPResponse$$} from './UpdateIDPResponseFetcher';
+export type {UpdateIDPErrorFetcher} from './UpdateIDPErrorFetcher';
+export {updateIDPError$, updateIDPError$$} from './UpdateIDPErrorFetcher';
+export type {DisableIDPResponseFetcher} from './DisableIDPResponseFetcher';
+export {disableIDPResponse$, disableIDPResponse$$} from './DisableIDPResponseFetcher';
+export type {DisableIDPErrorFetcher} from './DisableIDPErrorFetcher';
+export {disableIDPError$, disableIDPError$$} from './DisableIDPErrorFetcher';
+export type {EnableIDPResponseFetcher} from './EnableIDPResponseFetcher';
+export {enableIDPResponse$, enableIDPResponse$$} from './EnableIDPResponseFetcher';
+export type {EnableIDPErrorFetcher} from './EnableIDPErrorFetcher';
+export {enableIDPError$, enableIDPError$$} from './EnableIDPErrorFetcher';
+export type {IdentityProviderFetcher} from './IdentityProviderFetcher';
+export {identityProvider$, identityProvider$$} from './IdentityProviderFetcher';
+export type {IDPOptionsOutputFetcher} from './IDPOptionsOutputFetcher';
+export {iDPOptionsOutput$, iDPOptionsOutput$$} from './IDPOptionsOutputFetcher';
+export type {InviteResponseFetcher} from './InviteResponseFetcher';
+export {inviteResponse$, inviteResponse$$} from './InviteResponseFetcher';
+export type {InviteErrorFetcher} from './InviteErrorFetcher';
+export {inviteError$, inviteError$$} from './InviteErrorFetcher';
+export type {InviteResultFetcher} from './InviteResultFetcher';
+export {inviteResult$, inviteResult$$} from './InviteResultFetcher';
+export type {AddProjectMemberResponseFetcher} from './AddProjectMemberResponseFetcher';
+export {addProjectMemberResponse$, addProjectMemberResponse$$} from './AddProjectMemberResponseFetcher';
+export type {AddProjectMemberErrorFetcher} from './AddProjectMemberErrorFetcher';
+export {addProjectMemberError$, addProjectMemberError$$} from './AddProjectMemberErrorFetcher';
+export type {UpdateProjectMemberResponseFetcher} from './UpdateProjectMemberResponseFetcher';
+export {updateProjectMemberResponse$, updateProjectMemberResponse$$} from './UpdateProjectMemberResponseFetcher';
+export type {UpdateProjectMemberErrorFetcher} from './UpdateProjectMemberErrorFetcher';
+export {updateProjectMemberError$, updateProjectMemberError$$} from './UpdateProjectMemberErrorFetcher';
+export type {RemoveProjectMemberResponseFetcher} from './RemoveProjectMemberResponseFetcher';
+export {removeProjectMemberResponse$, removeProjectMemberResponse$$} from './RemoveProjectMemberResponseFetcher';
+export type {RemoveProjectMemberErrorFetcher} from './RemoveProjectMemberErrorFetcher';
+export {removeProjectMemberError$, removeProjectMemberError$$} from './RemoveProjectMemberErrorFetcher';
+export type {CreateApiKeyResponseFetcher} from './CreateApiKeyResponseFetcher';
+export {createApiKeyResponse$, createApiKeyResponse$$} from './CreateApiKeyResponseFetcher';
+export type {CreateApiKeyErrorFetcher} from './CreateApiKeyErrorFetcher';
+export {createApiKeyError$, createApiKeyError$$} from './CreateApiKeyErrorFetcher';
+export type {CreateApiKeyResultFetcher} from './CreateApiKeyResultFetcher';
+export {createApiKeyResult$} from './CreateApiKeyResultFetcher';
+export type {DisableApiKeyResponseFetcher} from './DisableApiKeyResponseFetcher';
+export {disableApiKeyResponse$, disableApiKeyResponse$$} from './DisableApiKeyResponseFetcher';
+export type {DisableApiKeyErrorFetcher} from './DisableApiKeyErrorFetcher';
+export {disableApiKeyError$, disableApiKeyError$$} from './DisableApiKeyErrorFetcher';
+export type {VariableEntryFetcher} from './VariableEntryFetcher';
+export {variableEntry$, variableEntry$$} from './VariableEntryFetcher';
+export type {MembershipFetcher} from './MembershipFetcher';
+export {membership$, membership$$} from './MembershipFetcher';
+export type {MembershipValidationErrorFetcher} from './MembershipValidationErrorFetcher';
+export {membershipValidationError$, membershipValidationError$$} from './MembershipValidationErrorFetcher';
+export type {PersonFetcher} from './PersonFetcher';
+export {person$, person$$} from './PersonFetcher';
+export type {ApiKeyFetcher} from './ApiKeyFetcher';
+export {apiKey$, apiKey$$} from './ApiKeyFetcher';
+export type {ApiKeyWithTokenFetcher} from './ApiKeyWithTokenFetcher';
+export {apiKeyWithToken$, apiKeyWithToken$$} from './ApiKeyWithTokenFetcher';
+export type {IdentityFetcher} from './IdentityFetcher';
+export {identity$, identity$$} from './IdentityFetcher';
+export type {IdentityGlobalPermissionsFetcher} from './IdentityGlobalPermissionsFetcher';
+export {identityGlobalPermissions$, identityGlobalPermissions$$} from './IdentityGlobalPermissionsFetcher';
+export type {IdentityProjectRelationFetcher} from './IdentityProjectRelationFetcher';
+export {identityProjectRelation$} from './IdentityProjectRelationFetcher';
+export type {ProjectFetcher, ProjectArgs} from './ProjectFetcher';
+export {project$, project$$} from './ProjectFetcher';
+export type {ProjectIdentityRelationFetcher} from './ProjectIdentityRelationFetcher';
+export {projectIdentityRelation$} from './ProjectIdentityRelationFetcher';
+export type {RoleDefinitionFetcher} from './RoleDefinitionFetcher';
+export {roleDefinition$, roleDefinition$$} from './RoleDefinitionFetcher';
+export type {RoleVariableDefinitionFetcher} from './RoleVariableDefinitionFetcher';
+export {roleVariableDefinition$, roleVariableDefinition$$} from './RoleVariableDefinitionFetcher';
+export type {RoleEntityVariableDefinitionFetcher} from './RoleEntityVariableDefinitionFetcher';
+export {roleEntityVariableDefinition$, roleEntityVariableDefinition$$} from './RoleEntityVariableDefinitionFetcher';
+export type {RolePredefinedVariableDefinitionFetcher} from './RolePredefinedVariableDefinitionFetcher';
+export {rolePredefinedVariableDefinition$, rolePredefinedVariableDefinition$$} from './RolePredefinedVariableDefinitionFetcher';
+export type {RoleConditionVariableDefinitionFetcher} from './RoleConditionVariableDefinitionFetcher';
+export {roleConditionVariableDefinition$, roleConditionVariableDefinition$$} from './RoleConditionVariableDefinitionFetcher';
+export type {PrepareOtpResponseFetcher} from './PrepareOtpResponseFetcher';
+export {prepareOtpResponse$, prepareOtpResponse$$} from './PrepareOtpResponseFetcher';
+export type {PrepareOtpResultFetcher} from './PrepareOtpResultFetcher';
+export {prepareOtpResult$, prepareOtpResult$$} from './PrepareOtpResultFetcher';
+export type {ConfirmOtpResponseFetcher} from './ConfirmOtpResponseFetcher';
+export {confirmOtpResponse$, confirmOtpResponse$$} from './ConfirmOtpResponseFetcher';
+export type {ConfirmOtpErrorFetcher} from './ConfirmOtpErrorFetcher';
+export {confirmOtpError$, confirmOtpError$$} from './ConfirmOtpErrorFetcher';
+export type {DisableOtpResponseFetcher} from './DisableOtpResponseFetcher';
+export {disableOtpResponse$, disableOtpResponse$$} from './DisableOtpResponseFetcher';
+export type {DisableOtpErrorFetcher} from './DisableOtpErrorFetcher';
+export {disableOtpError$, disableOtpError$$} from './DisableOtpErrorFetcher';
+export type {AddMailTemplateResponseFetcher} from './AddMailTemplateResponseFetcher';
+export {addMailTemplateResponse$, addMailTemplateResponse$$} from './AddMailTemplateResponseFetcher';
+export type {AddMailTemplateErrorFetcher} from './AddMailTemplateErrorFetcher';
+export {addMailTemplateError$, addMailTemplateError$$} from './AddMailTemplateErrorFetcher';
+export type {RemoveMailTemplateResponseFetcher} from './RemoveMailTemplateResponseFetcher';
+export {removeMailTemplateResponse$, removeMailTemplateResponse$$} from './RemoveMailTemplateResponseFetcher';
+export type {RemoveMailTemplateErrorFetcher} from './RemoveMailTemplateErrorFetcher';
+export {removeMailTemplateError$, removeMailTemplateError$$} from './RemoveMailTemplateErrorFetcher';
+export type {CheckResetPasswordTokenResultFetcher} from './CheckResetPasswordTokenResultFetcher';
+export {checkResetPasswordTokenResult$, checkResetPasswordTokenResult$$} from './CheckResetPasswordTokenResultFetcher';
+export type {CreatePasswordResetRequestResponseFetcher} from './CreatePasswordResetRequestResponseFetcher';
+export {createPasswordResetRequestResponse$, createPasswordResetRequestResponse$$} from './CreatePasswordResetRequestResponseFetcher';
+export type {CreatePasswordResetRequestErrorFetcher} from './CreatePasswordResetRequestErrorFetcher';
+export {createPasswordResetRequestError$, createPasswordResetRequestError$$} from './CreatePasswordResetRequestErrorFetcher';
+export type {ResetPasswordResponseFetcher} from './ResetPasswordResponseFetcher';
+export {resetPasswordResponse$, resetPasswordResponse$$} from './ResetPasswordResponseFetcher';
+export type {ResetPasswordErrorFetcher} from './ResetPasswordErrorFetcher';
+export {resetPasswordError$, resetPasswordError$$} from './ResetPasswordErrorFetcher';
+export type {CreateProjectResponseFetcher} from './CreateProjectResponseFetcher';
+export {createProjectResponse$, createProjectResponse$$} from './CreateProjectResponseFetcher';
+export type {CreateProjectResponseErrorFetcher} from './CreateProjectResponseErrorFetcher';
+export {createProjectResponseError$, createProjectResponseError$$} from './CreateProjectResponseErrorFetcher';
+export type {CreateProjectResultFetcher} from './CreateProjectResultFetcher';
+export {createProjectResult$} from './CreateProjectResultFetcher';
+export type {SetProjectSecretResponseFetcher} from './SetProjectSecretResponseFetcher';
+export {setProjectSecretResponse$, setProjectSecretResponse$$} from './SetProjectSecretResponseFetcher';
+export type {UpdateProjectResponseFetcher} from './UpdateProjectResponseFetcher';
+export {updateProjectResponse$, updateProjectResponse$$} from './UpdateProjectResponseFetcher';

package/src/generated/index.ts

@@ -0,0 +1,4 @@
+export type { GraphQLExecutor } from "./Async";
+export { setGraphQLExecutor, execute } from "./Async";
+export type { ImplementationType } from './CommonTypes';
+export { upcastTypes, downcastTypes } from './CommonTypes';

package/src/generated/inputs/CreateProjectOptions.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type CreateProjectOptions = {
+    readonly deployTokenHash?: string;
+    readonly noDeployToken?: boolean;
+}

package/src/generated/inputs/CreateResetPasswordRequestOptions.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type CreateResetPasswordRequestOptions = {
+    readonly mailProject?: string;
+    readonly mailVariant?: string;
+}

package/src/generated/inputs/IDPOptions.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type IDPOptions = {
+    readonly autoSignUp?: boolean;
+    readonly exclusive?: boolean;
+}

package/src/generated/inputs/IDPResponseInput.ts

@@ -0,0 +1,7 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type IDPResponseInput = {
+    readonly url: string;
+}

package/src/generated/inputs/InviteOptions.ts

@@ -0,0 +1,10 @@
+import type {InviteMethod} from '../enums';
+
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type InviteOptions = {
+    readonly method?: InviteMethod;
+    readonly mailVariant?: string;
+}

package/src/generated/inputs/MailTemplate.ts

@@ -0,0 +1,14 @@
+import type {MailType} from '../enums';
+
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type MailTemplate = {
+    readonly projectSlug?: string;
+    readonly type: MailType;
+    readonly variant?: string;
+    readonly subject: string;
+    readonly content: string;
+    readonly useLayout?: boolean;
+}

package/src/generated/inputs/MailTemplateIdentifier.ts

@@ -0,0 +1,11 @@
+import type {MailType} from '../enums';
+
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type MailTemplateIdentifier = {
+    readonly projectSlug?: string;
+    readonly type: MailType;
+    readonly variant?: string;
+}

package/src/generated/inputs/MembershipInput.ts

@@ -0,0 +1,10 @@
+import type {VariableEntryInput} from '.';
+
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type MembershipInput = {
+    readonly role: string;
+    readonly variables: ReadonlyArray<VariableEntryInput>;
+}

package/src/generated/inputs/ProjectSecret.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type ProjectSecret = {
+    readonly key: string;
+    readonly value: string;
+}

package/src/generated/inputs/UnmanagedInviteOptions.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type UnmanagedInviteOptions = {
+    readonly password?: string;
+    readonly resetTokenHash?: string;
+}

package/src/generated/inputs/VariableEntryInput.ts

@@ -0,0 +1,8 @@
+/*
+ * This input type is not interface, because interfaces 
+ * do not satisfy the constraint 'SerializableParam' of recoil
+ */
+export type VariableEntryInput = {
+    readonly name: string;
+    readonly values: ReadonlyArray<string>;
+}

package/src/generated/inputs/index.ts

@@ -0,0 +1,11 @@
+export type {IDPResponseInput} from './IDPResponseInput';
+export type {IDPOptions} from './IDPOptions';
+export type {InviteOptions} from './InviteOptions';
+export type {UnmanagedInviteOptions} from './UnmanagedInviteOptions';
+export type {VariableEntryInput} from './VariableEntryInput';
+export type {MembershipInput} from './MembershipInput';
+export type {MailTemplate} from './MailTemplate';
+export type {MailTemplateIdentifier} from './MailTemplateIdentifier';
+export type {CreateResetPasswordRequestOptions} from './CreateResetPasswordRequestOptions';
+export type {ProjectSecret} from './ProjectSecret';
+export type {CreateProjectOptions} from './CreateProjectOptions';

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './generated/enums'
+export * from './generated/fetchers'
+export * from './generated/inputs'
+export type { GraphQLExecutor } from './generated/Async'
+export { setGraphQLExecutor, execute } from './generated/Async'
+export type { ImplementationType } from './generated/CommonTypes'
+export { upcastTypes, downcastTypes } from './generated/CommonTypes'

package/src/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/src"
+	},
+	"references": [
+	]
+}