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

package/src/generated/fetchers/ApiKeyWithTokenFetcher.ts

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

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

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

package/src/generated/fetchers/ChangePasswordErrorFetcher.ts

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

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