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

package/src/generated/fetchers/PersonFetcher.ts

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

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

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

package/src/generated/fetchers/ProjectFetcher.ts

@@ -0,0 +1,266 @@
+import type { AcceptableVariables, UnresolvedVariables, 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 {MemberType} 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 ProjectFetcher<T extends object, TVariables extends object> extends ObjectFetcher<'Project', T, TVariables> {
+
+    on<XName extends ImplementationType<'Project'>, X extends object, XVariables extends object>(
+        child: ObjectFetcher<XName, X, XVariables>, 
+        fragmentName?: string // undefined: inline fragment; otherwise, otherwise, real fragment
+    ): ProjectFetcher<
+        XName extends 'Project' ?
+        T & X :
+        WithTypeName<T, ImplementationType<'Project'>> & (
+            WithTypeName<X, ImplementationType<XName>> | 
+            {__typename: Exclude<ImplementationType<'Project'>, ImplementationType<XName>>}
+        ), 
+        TVariables & XVariables
+    >;
+
+
+    directive(name: string, args?: DirectiveArgs): ProjectFetcher<T, TVariables>;
+
+
+    readonly __typename: ProjectFetcher<T & {__typename: ImplementationType<'Project'>}, TVariables>;
+
+
+    readonly id: ProjectFetcher<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>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~id": ProjectFetcher<Omit<T, 'id'>, TVariables>;
+
+
+    readonly name: ProjectFetcher<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>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~name": ProjectFetcher<Omit<T, 'name'>, TVariables>;
+
+
+    readonly slug: ProjectFetcher<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>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: string} : 
+                {readonly [key in XAlias]: string}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~slug": ProjectFetcher<Omit<T, 'slug'>, TVariables>;
+
+
+    readonly config: ProjectFetcher<T & {readonly "config": unknown}, TVariables>;
+
+    "config+"<
+        XAlias extends string = "config", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        optionsConfigurer: (
+            options: FieldOptions<"config", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: unknown} : 
+                {readonly [key in XAlias]: unknown}
+        ), 
+        TVariables & XDirectiveVariables
+    >;
+
+    readonly "~config": ProjectFetcher<Omit<T, 'config'>, TVariables>;
+
+
+    roles<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'RoleDefinition', X, XVariables>
+    ): ProjectFetcher<
+        T & {readonly "roles": ReadonlyArray<X>}, 
+        TVariables & XVariables
+    >;
+
+    roles<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "roles", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'RoleDefinition', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"roles", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & XDirectiveVariables
+    >;
+
+
+    members<
+        X extends object, 
+        XVariables extends object
+    >(
+        child: ObjectFetcher<'ProjectIdentityRelation', X, XVariables>
+    ): ProjectFetcher<
+        T & {readonly "members": ReadonlyArray<X>}, 
+        TVariables & XVariables & ProjectArgs["members"]
+    >;
+
+    members<
+        XArgs extends AcceptableVariables<ProjectArgs['members']>, 
+        X extends object, 
+        XVariables extends object
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'ProjectIdentityRelation', X, XVariables>
+    ): ProjectFetcher<
+        T & {readonly "members": ReadonlyArray<X>}, 
+        TVariables & XVariables & UnresolvedVariables<XArgs, ProjectArgs['members']>
+    >;
+
+    members<
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "members", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        child: ObjectFetcher<'ProjectIdentityRelation', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"members", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & ProjectArgs["members"] & XDirectiveVariables
+    >;
+
+    members<
+        XArgs extends AcceptableVariables<ProjectArgs['members']>, 
+        X extends object, 
+        XVariables extends object, 
+        XAlias extends string = "members", 
+        XDirectives extends { readonly [key: string]: DirectiveArgs } = {}, 
+        XDirectiveVariables extends object = {}
+    >(
+        args: XArgs, 
+        child: ObjectFetcher<'ProjectIdentityRelation', X, XVariables>, 
+        optionsConfigurer: (
+            options: FieldOptions<"members", {}, {}>
+        ) => FieldOptions<XAlias, XDirectives, XDirectiveVariables>
+    ): ProjectFetcher<
+        T & (
+            XDirectives extends { readonly include: any } | { readonly skip: any } ? 
+                {readonly [key in XAlias]?: ReadonlyArray<X>} : 
+                {readonly [key in XAlias]: ReadonlyArray<X>}
+        ), 
+        TVariables & XVariables & UnresolvedVariables<XArgs, ProjectArgs['members']> & XDirectiveVariables
+    >;
+}
+
+export const project$: ProjectFetcher<{}, {}> = 
+    createFetcher(
+        createFetchableType(
+            "Project", 
+            "OBJECT", 
+            [], 
+            [
+                {
+                    category: "ID", 
+                    name: "id"
+                }, 
+                "name", 
+                "slug", 
+                "config", 
+                {
+                    category: "LIST", 
+                    name: "roles", 
+                    targetTypeName: "RoleDefinition"
+                }, 
+                {
+                    category: "LIST", 
+                    name: "members", 
+                    argGraphQLTypeMap: {memberType: 'MemberType'}, 
+                    targetTypeName: "ProjectIdentityRelation"
+                }
+            ]
+        ), 
+        ENUM_INPUT_METADATA, 
+        undefined
+    )
+;
+
+export const project$$ = 
+    project$
+        .id
+        .name
+        .slug
+        .config
+;
+
+export interface ProjectArgs {
+
+    readonly members: {
+        readonly memberType?: MemberType
+    }
+}