wabe 0.5.4 → 0.5.6

package/generated/wabe.ts

@@ -1,169 +1,142 @@
-import { GraphQLClient, RequestOptions } from 'graphql-request';
-import gql from 'graphql-tag';
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = Maybe<T>;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
-export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
-export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
-type GraphQLClientRequestHeaders = RequestOptions['requestHeaders'];
-/** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
-  ID: { input: string; output: string; }
-  String: { input: string; output: string; }
-  Boolean: { input: boolean; output: boolean; }
-  Int: { input: number; output: number; }
-  Float: { input: number; output: number; }
-  /** Phone custom scalar type */
-  Phone: { input: any; output: any; }
-  /** Date scalar type */
-  Date: { input: any; output: any; }
-  /** Email scalar type */
-  Email: { input: any; output: any; }
-  /** File scalar type */
-  File: { input: any; output: any; }
-  /** Search scalar to tokenize and search for all searchable fields */
-  Search: { input: any; output: any; }
-  /** The Any scalar type is used in operations and types that involve any type of value. */
-  Any: { input: any; output: any; }
+  ID: { input: string; output: string; };
+  String: { input: string; output: string; };
+  Boolean: { input: boolean; output: boolean; };
+  Int: { input: number; output: number; };
+  Float: { input: number; output: number; };
+  Email: { input: string; output: string; };
+  Phone: { input: string; output: string; };
+  Date: { input: Date; output: string; };
+  Search: { input: any; output: any; };
+  Any: { input: any; output: any; };
+  File: { input: any; output: any; };
 };
 
+
 export enum RoleEnum {
-  Admin = 'Admin',
-  Client = 'Client'
+  Admin = "Admin",
+  Client = "Client",
 }
 
 export enum AuthenticationProvider {
-  Google = 'google',
-  EmailPassword = 'emailPassword'
+  google = "google",
+  emailPassword = "emailPassword",
 }
 
 export enum SecondaryFactor {
-  EmailOtp = 'EmailOTP'
+  EmailOTP = "EmailOTP",
 }
 
 export enum PaymentMode {
-  Payment = 'payment',
-  Subscription = 'subscription'
+  payment = "payment",
+  subscription = "subscription",
 }
 
 export enum PaymentReccuringInterval {
-  Month = 'month',
-  Year = 'year'
+  month = "month",
+  year = "year",
 }
 
 export enum Currency {
-  Eur = 'eur',
-  Usd = 'usd'
+  eur = "eur",
+  usd = "usd",
 }
 
-/** User class */
 export type User = {
-  __typename?: 'User';
   id: Scalars['ID']['output'];
-  name?: Maybe<Scalars['String']['output']>;
-  age?: Maybe<Scalars['Int']['output']>;
-  acl?: Maybe<UserAclObject>;
-  createdAt?: Maybe<Scalars['Date']['output']>;
-  updatedAt?: Maybe<Scalars['Date']['output']>;
-  search?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
-  authentication?: Maybe<UserAuthentication>;
-  provider?: Maybe<AuthenticationProvider>;
-  isOauth?: Maybe<Scalars['Boolean']['output']>;
-  email?: Maybe<Scalars['Email']['output']>;
-  verifiedEmail?: Maybe<Scalars['Boolean']['output']>;
-  role?: Maybe<Role>;
-  sessions?: Maybe<_SessionConnection>;
-};
-
-export type UserAclObject = {
-  __typename?: 'UserACLObject';
-  users?: Maybe<Array<Maybe<UserAclObjectUsersAcl>>>;
-  roles?: Maybe<Array<Maybe<UserAclObjectRolesAcl>>>;
-};
-
-export type UserAclObjectUsersAcl = {
-  __typename?: 'UserACLObjectUsersACL';
+  name?: Scalars['String']['output'];
+  age?: Scalars['Int']['output'];
+  acl?: UserACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
+  authentication?: UserAuthentication;
+  provider?: AuthenticationProvider;
+  isOauth?: Scalars['Boolean']['output'];
+  email?: Scalars['Email']['output'];
+  verifiedEmail?: Scalars['Boolean']['output'];
+  role?: Role;
+  sessions?: _SessionConnection;
+};
+
+export type UserACLObject = {
+  users?: UserACLObjectUsersACL[];
+  roles?: UserACLObjectRolesACL[];
+};
+
+export type UserACLObjectUsersACL = {
   userId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
-export type UserAclObjectRolesAcl = {
-  __typename?: 'UserACLObjectRolesACL';
+export type UserACLObjectRolesACL = {
   roleId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
 export type UserAuthentication = {
-  __typename?: 'UserAuthentication';
-  emailPassword?: Maybe<UserAuthenticationEmailPassword>;
-  google?: Maybe<UserAuthenticationGoogle>;
+  emailPassword?: UserAuthenticationEmailPassword;
+  google?: UserAuthenticationGoogle;
 };
 
 export type UserAuthenticationEmailPassword = {
-  __typename?: 'UserAuthenticationEmailPassword';
   email: Scalars['Email']['output'];
   password: Scalars['String']['output'];
 };
 
 export type UserAuthenticationGoogle = {
-  __typename?: 'UserAuthenticationGoogle';
   email: Scalars['Email']['output'];
   verifiedEmail: Scalars['Boolean']['output'];
   idToken: Scalars['String']['output'];
 };
 
 export type _SessionConnection = {
-  __typename?: '_SessionConnection';
-  totalCount?: Maybe<Scalars['Int']['output']>;
-  edges?: Maybe<Array<Maybe<_SessionEdge>>>;
+  totalCount?: Scalars['Int']['output'];
+  edges?: _SessionEdge[];
 };
 
 export type _SessionEdge = {
-  __typename?: '_SessionEdge';
   node: _Session;
 };
 
-/** User class */
 export type UserInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  age?: InputMaybe<Scalars['Int']['input']>;
-  acl?: InputMaybe<UserAclObjectInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  authentication?: InputMaybe<UserAuthenticationInput>;
-  provider?: InputMaybe<AuthenticationProvider>;
-  isOauth?: InputMaybe<Scalars['Boolean']['input']>;
-  email?: InputMaybe<Scalars['Email']['input']>;
-  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
-  role?: InputMaybe<RolePointerInput>;
-  sessions?: InputMaybe<_SessionRelationInput>;
-};
-
-export type UserAclObjectInput = {
-  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclInput>>>;
-};
-
-export type UserAclObjectUsersAclInput = {
+  name?: Scalars['String']['input'];
+  age?: Scalars['Int']['input'];
+  acl?: UserACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+  authentication?: UserAuthenticationInput;
+  provider?: AuthenticationProvider;
+  isOauth?: Scalars['Boolean']['input'];
+  email?: Scalars['Email']['input'];
+  verifiedEmail?: Scalars['Boolean']['input'];
+  role?: RolePointerInput;
+  sessions?: _SessionRelationInput;
+};
+
+export type UserACLObjectInput = {
+  users?: UserACLObjectUsersACLInput[];
+  roles?: UserACLObjectRolesACLInput[];
+};
+
+export type UserACLObjectUsersACLInput = {
   userId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-export type UserAclObjectRolesAclInput = {
+export type UserACLObjectRolesACLInput = {
   roleId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
 export type UserAuthenticationInput = {
-  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordInput>;
-  google?: InputMaybe<UserAuthenticationGoogleInput>;
+  emailPassword?: UserAuthenticationEmailPasswordInput;
+  google?: UserAuthenticationGoogleInput;
 };
 
 export type UserAuthenticationEmailPasswordInput = {
@@ -177,96 +150,89 @@ export type UserAuthenticationGoogleInput = {
   idToken: Scalars['String']['input'];
 };
 
-/** Input to link an object to a pointer User */
 export type UserPointerInput = {
-  unlink?: InputMaybe<Scalars['Boolean']['input']>;
-  link?: InputMaybe<Scalars['ID']['input']>;
-  createAndLink?: InputMaybe<UserCreateFieldsInput>;
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: UserCreateFieldsInput;
 };
 
-/** User class */
 export type UserCreateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  age?: InputMaybe<Scalars['Int']['input']>;
-  acl?: InputMaybe<UserAclObjectCreateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  authentication?: InputMaybe<UserAuthenticationCreateFieldsInput>;
-  provider?: InputMaybe<AuthenticationProvider>;
-  isOauth?: InputMaybe<Scalars['Boolean']['input']>;
-  email?: InputMaybe<Scalars['Email']['input']>;
-  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
-  role?: InputMaybe<RolePointerInput>;
-  sessions?: InputMaybe<_SessionRelationInput>;
+  name?: Scalars['String']['input'];
+  age?: Scalars['Int']['input'];
+  acl?: UserACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+  authentication?: UserAuthenticationCreateFieldsInput;
+  provider?: AuthenticationProvider;
+  isOauth?: Scalars['Boolean']['input'];
+  email?: Scalars['Email']['input'];
+  verifiedEmail?: Scalars['Boolean']['input'];
+  role?: RolePointerInput;
+  sessions?: _SessionRelationInput;
 };
 
-export type UserAclObjectCreateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclCreateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclCreateFieldsInput>>>;
+export type UserACLObjectCreateFieldsInput = {
+  users?: UserACLObjectUsersACLCreateFieldsInput[];
+  roles?: UserACLObjectRolesACLCreateFieldsInput[];
 };
 
-export type UserAclObjectUsersAclCreateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type UserACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type UserAclObjectRolesAclCreateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type UserACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type UserAuthenticationCreateFieldsInput = {
-  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordCreateFieldsInput>;
-  google?: InputMaybe<UserAuthenticationGoogleCreateFieldsInput>;
+  emailPassword?: UserAuthenticationEmailPasswordCreateFieldsInput;
+  google?: UserAuthenticationGoogleCreateFieldsInput;
 };
 
 export type UserAuthenticationEmailPasswordCreateFieldsInput = {
-  email?: InputMaybe<Scalars['Email']['input']>;
-  password?: InputMaybe<Scalars['String']['input']>;
+  email?: Scalars['Email']['input'];
+  password?: Scalars['String']['input'];
 };
 
 export type UserAuthenticationGoogleCreateFieldsInput = {
-  email?: InputMaybe<Scalars['Email']['input']>;
-  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
-  idToken?: InputMaybe<Scalars['String']['input']>;
+  email?: Scalars['Email']['input'];
+  verifiedEmail?: Scalars['Boolean']['input'];
+  idToken?: Scalars['String']['input'];
 };
 
-/** Input to add a relation to the class User */
 export type UserRelationInput = {
-  add?: InputMaybe<Array<Scalars['ID']['input']>>;
-  remove?: InputMaybe<Array<Scalars['ID']['input']>>;
-  createAndAdd?: InputMaybe<Array<UserCreateFieldsInput>>;
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: UserCreateFieldsInput[];
 };
 
 export type Post = {
-  __typename?: 'Post';
   id: Scalars['ID']['output'];
   name: Scalars['String']['output'];
-  test?: Maybe<Scalars['File']['output']>;
-  acl?: Maybe<PostAclObject>;
-  createdAt?: Maybe<Scalars['Date']['output']>;
-  updatedAt?: Maybe<Scalars['Date']['output']>;
-  search?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  test?: Scalars['File']['output'];
+  acl?: PostACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
 };
 
-export type PostAclObject = {
-  __typename?: 'PostACLObject';
-  users?: Maybe<Array<Maybe<PostAclObjectUsersAcl>>>;
-  roles?: Maybe<Array<Maybe<PostAclObjectRolesAcl>>>;
+export type PostACLObject = {
+  users?: PostACLObjectUsersACL[];
+  roles?: PostACLObjectRolesACL[];
 };
 
-export type PostAclObjectUsersAcl = {
-  __typename?: 'PostACLObjectUsersACL';
+export type PostACLObjectUsersACL = {
   userId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
-export type PostAclObjectRolesAcl = {
-  __typename?: 'PostACLObjectRolesACL';
+export type PostACLObjectRolesACL = {
   roleId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
@@ -274,213 +240,199 @@ export type PostAclObjectRolesAcl = {
 
 export type PostInput = {
   name: Scalars['String']['input'];
-  test?: InputMaybe<Scalars['File']['input']>;
-  acl?: InputMaybe<PostAclObjectInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  test?: Scalars['File']['input'];
+  acl?: PostACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PostAclObjectInput = {
-  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclInput>>>;
+export type PostACLObjectInput = {
+  users?: PostACLObjectUsersACLInput[];
+  roles?: PostACLObjectRolesACLInput[];
 };
 
-export type PostAclObjectUsersAclInput = {
+export type PostACLObjectUsersACLInput = {
   userId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-export type PostAclObjectRolesAclInput = {
+export type PostACLObjectRolesACLInput = {
   roleId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-/** Input to link an object to a pointer Post */
 export type PostPointerInput = {
-  unlink?: InputMaybe<Scalars['Boolean']['input']>;
-  link?: InputMaybe<Scalars['ID']['input']>;
-  createAndLink?: InputMaybe<PostCreateFieldsInput>;
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: PostCreateFieldsInput;
 };
 
 export type PostCreateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  test?: InputMaybe<Scalars['File']['input']>;
-  acl?: InputMaybe<PostAclObjectCreateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  name?: Scalars['String']['input'];
+  test?: Scalars['File']['input'];
+  acl?: PostACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PostAclObjectCreateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclCreateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclCreateFieldsInput>>>;
+export type PostACLObjectCreateFieldsInput = {
+  users?: PostACLObjectUsersACLCreateFieldsInput[];
+  roles?: PostACLObjectRolesACLCreateFieldsInput[];
 };
 
-export type PostAclObjectUsersAclCreateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PostACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type PostAclObjectRolesAclCreateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PostACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-/** Input to add a relation to the class Post */
 export type PostRelationInput = {
-  add?: InputMaybe<Array<Scalars['ID']['input']>>;
-  remove?: InputMaybe<Array<Scalars['ID']['input']>>;
-  createAndAdd?: InputMaybe<Array<PostCreateFieldsInput>>;
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: PostCreateFieldsInput[];
 };
 
 export type _Session = {
-  __typename?: '_Session';
   id: Scalars['ID']['output'];
-  user?: Maybe<User>;
+  user?: User;
   accessToken: Scalars['String']['output'];
   accessTokenExpiresAt: Scalars['Date']['output'];
-  refreshToken?: Maybe<Scalars['String']['output']>;
+  refreshToken?: Scalars['String']['output'];
   refreshTokenExpiresAt: Scalars['Date']['output'];
-  acl?: Maybe<_SessionAclObject>;
-  createdAt?: Maybe<Scalars['Date']['output']>;
-  updatedAt?: Maybe<Scalars['Date']['output']>;
-  search?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  acl?: _SessionACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
 };
 
-export type _SessionAclObject = {
-  __typename?: '_SessionACLObject';
-  users?: Maybe<Array<Maybe<_SessionAclObjectUsersAcl>>>;
-  roles?: Maybe<Array<Maybe<_SessionAclObjectRolesAcl>>>;
+export type _SessionACLObject = {
+  users?: _SessionACLObjectUsersACL[];
+  roles?: _SessionACLObjectRolesACL[];
 };
 
-export type _SessionAclObjectUsersAcl = {
-  __typename?: '_SessionACLObjectUsersACL';
+export type _SessionACLObjectUsersACL = {
   userId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
-export type _SessionAclObjectRolesAcl = {
-  __typename?: '_SessionACLObjectRolesACL';
+export type _SessionACLObjectRolesACL = {
   roleId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
 export type _SessionInput = {
-  user?: InputMaybe<UserPointerInput>;
+  user?: UserPointerInput;
   accessToken: Scalars['String']['input'];
   accessTokenExpiresAt: Scalars['Date']['input'];
-  refreshToken?: InputMaybe<Scalars['String']['input']>;
+  refreshToken?: Scalars['String']['input'];
   refreshTokenExpiresAt: Scalars['Date']['input'];
-  acl?: InputMaybe<_SessionAclObjectInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  acl?: _SessionACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type _SessionAclObjectInput = {
-  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclInput>>>;
+export type _SessionACLObjectInput = {
+  users?: _SessionACLObjectUsersACLInput[];
+  roles?: _SessionACLObjectRolesACLInput[];
 };
 
-export type _SessionAclObjectUsersAclInput = {
+export type _SessionACLObjectUsersACLInput = {
   userId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-export type _SessionAclObjectRolesAclInput = {
+export type _SessionACLObjectRolesACLInput = {
   roleId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-/** Input to link an object to a pointer _Session */
 export type _SessionPointerInput = {
-  unlink?: InputMaybe<Scalars['Boolean']['input']>;
-  link?: InputMaybe<Scalars['ID']['input']>;
-  createAndLink?: InputMaybe<_SessionCreateFieldsInput>;
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: _SessionCreateFieldsInput;
 };
 
 export type _SessionCreateFieldsInput = {
-  user?: InputMaybe<UserPointerInput>;
-  accessToken?: InputMaybe<Scalars['String']['input']>;
-  accessTokenExpiresAt?: InputMaybe<Scalars['Date']['input']>;
-  refreshToken?: InputMaybe<Scalars['String']['input']>;
-  refreshTokenExpiresAt?: InputMaybe<Scalars['Date']['input']>;
-  acl?: InputMaybe<_SessionAclObjectCreateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  user?: UserPointerInput;
+  accessToken?: Scalars['String']['input'];
+  accessTokenExpiresAt?: Scalars['Date']['input'];
+  refreshToken?: Scalars['String']['input'];
+  refreshTokenExpiresAt?: Scalars['Date']['input'];
+  acl?: _SessionACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type _SessionAclObjectCreateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclCreateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclCreateFieldsInput>>>;
+export type _SessionACLObjectCreateFieldsInput = {
+  users?: _SessionACLObjectUsersACLCreateFieldsInput[];
+  roles?: _SessionACLObjectRolesACLCreateFieldsInput[];
 };
 
-export type _SessionAclObjectUsersAclCreateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type _SessionACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type _SessionAclObjectRolesAclCreateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type _SessionACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-/** Input to add a relation to the class _Session */
 export type _SessionRelationInput = {
-  add?: InputMaybe<Array<Scalars['ID']['input']>>;
-  remove?: InputMaybe<Array<Scalars['ID']['input']>>;
-  createAndAdd?: InputMaybe<Array<_SessionCreateFieldsInput>>;
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: _SessionCreateFieldsInput[];
 };
 
 export type Role = {
-  __typename?: 'Role';
   id: Scalars['ID']['output'];
   name: Scalars['String']['output'];
-  users?: Maybe<UserConnection>;
-  acl?: Maybe<RoleAclObject>;
-  createdAt?: Maybe<Scalars['Date']['output']>;
-  updatedAt?: Maybe<Scalars['Date']['output']>;
-  search?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  users?: UserConnection;
+  acl?: RoleACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
 };
 
 export type UserConnection = {
-  __typename?: 'UserConnection';
-  totalCount?: Maybe<Scalars['Int']['output']>;
-  edges?: Maybe<Array<Maybe<UserEdge>>>;
+  totalCount?: Scalars['Int']['output'];
+  edges?: UserEdge[];
 };
 
 export type UserEdge = {
-  __typename?: 'UserEdge';
   node: User;
 };
 
-export type RoleAclObject = {
-  __typename?: 'RoleACLObject';
-  users?: Maybe<Array<Maybe<RoleAclObjectUsersAcl>>>;
-  roles?: Maybe<Array<Maybe<RoleAclObjectRolesAcl>>>;
+export type RoleACLObject = {
+  users?: RoleACLObjectUsersACL[];
+  roles?: RoleACLObjectRolesACL[];
 };
 
-export type RoleAclObjectUsersAcl = {
-  __typename?: 'RoleACLObjectUsersACL';
+export type RoleACLObjectUsersACL = {
   userId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
-export type RoleAclObjectRolesAcl = {
-  __typename?: 'RoleACLObjectRolesACL';
+export type RoleACLObjectRolesACL = {
   roleId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
@@ -488,678 +440,813 @@ export type RoleAclObjectRolesAcl = {
 
 export type RoleInput = {
   name: Scalars['String']['input'];
-  users?: InputMaybe<UserRelationInput>;
-  acl?: InputMaybe<RoleAclObjectInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  users?: UserRelationInput;
+  acl?: RoleACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type RoleAclObjectInput = {
-  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclInput>>>;
+export type RoleACLObjectInput = {
+  users?: RoleACLObjectUsersACLInput[];
+  roles?: RoleACLObjectRolesACLInput[];
 };
 
-export type RoleAclObjectUsersAclInput = {
+export type RoleACLObjectUsersACLInput = {
   userId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-export type RoleAclObjectRolesAclInput = {
+export type RoleACLObjectRolesACLInput = {
   roleId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-/** Input to link an object to a pointer Role */
 export type RolePointerInput = {
-  unlink?: InputMaybe<Scalars['Boolean']['input']>;
-  link?: InputMaybe<Scalars['ID']['input']>;
-  createAndLink?: InputMaybe<RoleCreateFieldsInput>;
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: RoleCreateFieldsInput;
 };
 
 export type RoleCreateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  users?: InputMaybe<UserRelationInput>;
-  acl?: InputMaybe<RoleAclObjectCreateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  name?: Scalars['String']['input'];
+  users?: UserRelationInput;
+  acl?: RoleACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type RoleAclObjectCreateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclCreateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclCreateFieldsInput>>>;
+export type RoleACLObjectCreateFieldsInput = {
+  users?: RoleACLObjectUsersACLCreateFieldsInput[];
+  roles?: RoleACLObjectRolesACLCreateFieldsInput[];
 };
 
-export type RoleAclObjectUsersAclCreateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type RoleACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type RoleAclObjectRolesAclCreateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type RoleACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-/** Input to add a relation to the class Role */
 export type RoleRelationInput = {
-  add?: InputMaybe<Array<Scalars['ID']['input']>>;
-  remove?: InputMaybe<Array<Scalars['ID']['input']>>;
-  createAndAdd?: InputMaybe<Array<RoleCreateFieldsInput>>;
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: RoleCreateFieldsInput[];
 };
 
 export type Payment = {
-  __typename?: 'Payment';
   id: Scalars['ID']['output'];
-  user?: Maybe<User>;
+  user?: User;
   amount: Scalars['Int']['output'];
   currency: Currency;
-  acl?: Maybe<PaymentAclObject>;
-  createdAt?: Maybe<Scalars['Date']['output']>;
-  updatedAt?: Maybe<Scalars['Date']['output']>;
-  search?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+  acl?: PaymentACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
 };
 
-export type PaymentAclObject = {
-  __typename?: 'PaymentACLObject';
-  users?: Maybe<Array<Maybe<PaymentAclObjectUsersAcl>>>;
-  roles?: Maybe<Array<Maybe<PaymentAclObjectRolesAcl>>>;
+export type PaymentACLObject = {
+  users?: PaymentACLObjectUsersACL[];
+  roles?: PaymentACLObjectRolesACL[];
 };
 
-export type PaymentAclObjectUsersAcl = {
-  __typename?: 'PaymentACLObjectUsersACL';
+export type PaymentACLObjectUsersACL = {
   userId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
-export type PaymentAclObjectRolesAcl = {
-  __typename?: 'PaymentACLObjectRolesACL';
+export type PaymentACLObjectRolesACL = {
   roleId: Scalars['String']['output'];
   read: Scalars['Boolean']['output'];
   write: Scalars['Boolean']['output'];
 };
 
 export type PaymentInput = {
-  user?: InputMaybe<UserPointerInput>;
+  user?: UserPointerInput;
   amount: Scalars['Int']['input'];
   currency: Currency;
-  acl?: InputMaybe<PaymentAclObjectInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  acl?: PaymentACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PaymentAclObjectInput = {
-  users?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclInput>>>;
+export type PaymentACLObjectInput = {
+  users?: PaymentACLObjectUsersACLInput[];
+  roles?: PaymentACLObjectRolesACLInput[];
 };
 
-export type PaymentAclObjectUsersAclInput = {
+export type PaymentACLObjectUsersACLInput = {
   userId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-export type PaymentAclObjectRolesAclInput = {
+export type PaymentACLObjectRolesACLInput = {
   roleId: Scalars['String']['input'];
   read: Scalars['Boolean']['input'];
   write: Scalars['Boolean']['input'];
 };
 
-/** Input to link an object to a pointer Payment */
 export type PaymentPointerInput = {
-  unlink?: InputMaybe<Scalars['Boolean']['input']>;
-  link?: InputMaybe<Scalars['ID']['input']>;
-  createAndLink?: InputMaybe<PaymentCreateFieldsInput>;
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: PaymentCreateFieldsInput;
 };
 
 export type PaymentCreateFieldsInput = {
-  user?: InputMaybe<UserPointerInput>;
-  amount?: InputMaybe<Scalars['Int']['input']>;
-  currency?: InputMaybe<Currency>;
-  acl?: InputMaybe<PaymentAclObjectCreateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  user?: UserPointerInput;
+  amount?: Scalars['Int']['input'];
+  currency?: Currency;
+  acl?: PaymentACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PaymentAclObjectCreateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclCreateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclCreateFieldsInput>>>;
+export type PaymentACLObjectCreateFieldsInput = {
+  users?: PaymentACLObjectUsersACLCreateFieldsInput[];
+  roles?: PaymentACLObjectRolesACLCreateFieldsInput[];
 };
 
-export type PaymentAclObjectUsersAclCreateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PaymentACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type PaymentAclObjectRolesAclCreateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PaymentACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-/** Input to add a relation to the class Payment */
 export type PaymentRelationInput = {
-  add?: InputMaybe<Array<Scalars['ID']['input']>>;
-  remove?: InputMaybe<Array<Scalars['ID']['input']>>;
-  createAndAdd?: InputMaybe<Array<PaymentCreateFieldsInput>>;
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: PaymentCreateFieldsInput[];
+};
+
+export type _InternalConfig = {
+  id: Scalars['ID']['output'];
+  configKey: Scalars['String']['output'];
+  configValue: Scalars['String']['output'];
+  description?: Scalars['String']['output'];
+  acl?: _InternalConfigACLObject;
+  createdAt?: Scalars['Date']['output'];
+  updatedAt?: Scalars['Date']['output'];
+  search?: Scalars['String']['output'][];
+};
+
+export type _InternalConfigACLObject = {
+  users?: _InternalConfigACLObjectUsersACL[];
+  roles?: _InternalConfigACLObjectRolesACL[];
+};
+
+export type _InternalConfigACLObjectUsersACL = {
+  userId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type _InternalConfigACLObjectRolesACL = {
+  roleId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type _InternalConfigInput = {
+  configKey: Scalars['String']['input'];
+  configValue: Scalars['String']['input'];
+  description?: Scalars['String']['input'];
+  acl?: _InternalConfigACLObjectInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+};
+
+export type _InternalConfigACLObjectInput = {
+  users?: _InternalConfigACLObjectUsersACLInput[];
+  roles?: _InternalConfigACLObjectRolesACLInput[];
+};
+
+export type _InternalConfigACLObjectUsersACLInput = {
+  userId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+export type _InternalConfigACLObjectRolesACLInput = {
+  roleId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+export type _InternalConfigPointerInput = {
+  unlink?: Scalars['Boolean']['input'];
+  link?: Scalars['ID']['input'];
+  createAndLink?: _InternalConfigCreateFieldsInput;
+};
+
+export type _InternalConfigCreateFieldsInput = {
+  configKey?: Scalars['String']['input'];
+  configValue?: Scalars['String']['input'];
+  description?: Scalars['String']['input'];
+  acl?: _InternalConfigACLObjectCreateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+};
+
+export type _InternalConfigACLObjectCreateFieldsInput = {
+  users?: _InternalConfigACLObjectUsersACLCreateFieldsInput[];
+  roles?: _InternalConfigACLObjectRolesACLCreateFieldsInput[];
+};
+
+export type _InternalConfigACLObjectUsersACLCreateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
+};
+
+export type _InternalConfigACLObjectRolesACLCreateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
+};
+
+export type _InternalConfigRelationInput = {
+  add?: Scalars['ID']['input'][];
+  remove?: Scalars['ID']['input'][];
+  createAndAdd?: _InternalConfigCreateFieldsInput[];
 };
 
 export type Query = {
-  __typename?: 'Query';
-  /** User class */
-  user?: Maybe<User>;
-  /** User class */
+  user?: User;
   users: UserConnection;
-  post?: Maybe<Post>;
+  post?: Post;
   posts: PostConnection;
-  _session?: Maybe<_Session>;
+  _session?: _Session;
   _sessions: _SessionConnection;
-  role?: Maybe<Role>;
+  role?: Role;
   roles: RoleConnection;
-  payment?: Maybe<Payment>;
+  payment?: Payment;
   payments: PaymentConnection;
-  /** Hello world description */
-  helloWorld?: Maybe<Scalars['String']['output']>;
-  me?: Maybe<MeOutput>;
-  /** Get invoices of a customer */
-  getInvoices: Array<Maybe<Invoice>>;
+  _internalConfig?: _InternalConfig;
+  _internalConfigs: _InternalConfigConnection;
+  helloWorld?: Scalars['String']['output'];
+  me?: MeOutput;
+  getInvoices: Invoice[];
 };
 
-
 export type QueryUserArgs = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
-
 export type QueryUsersArgs = {
-  where?: InputMaybe<UserWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<UserOrder>>;
+  where?: UserWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: UserOrder[];
 };
 
-
 export type QueryPostArgs = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
-
 export type QueryPostsArgs = {
-  where?: InputMaybe<PostWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<PostOrder>>;
+  where?: PostWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PostOrder[];
 };
 
-
-export type Query_SessionArgs = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+export type Query_sessionArgs = {
+  id?: Scalars['ID']['input'];
 };
 
-
-export type Query_SessionsArgs = {
-  where?: InputMaybe<_SessionWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<_SessionOrder>>;
+export type Query_sessionsArgs = {
+  where?: _SessionWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _SessionOrder[];
 };
 
-
 export type QueryRoleArgs = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
-
 export type QueryRolesArgs = {
-  where?: InputMaybe<RoleWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<RoleOrder>>;
+  where?: RoleWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: RoleOrder[];
 };
 
-
 export type QueryPaymentArgs = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
-
 export type QueryPaymentsArgs = {
-  where?: InputMaybe<PaymentWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<PaymentOrder>>;
+  where?: PaymentWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PaymentOrder[];
 };
 
+export type Query_internalConfigArgs = {
+  id?: Scalars['ID']['input'];
+};
+
+export type Query_internalConfigsArgs = {
+  where?: _InternalConfigWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _InternalConfigOrder[];
+};
 
 export type QueryHelloWorldArgs = {
   name: Scalars['String']['input'];
 };
 
-
 export type QueryGetInvoicesArgs = {
   email: Scalars['Email']['input'];
 };
 
-/** User class */
 export type UserWhereInput = {
-  id?: InputMaybe<IdWhereInput>;
-  name?: InputMaybe<StringWhereInput>;
-  age?: InputMaybe<IntWhereInput>;
-  acl?: InputMaybe<UserAclObjectWhereInput>;
-  createdAt?: InputMaybe<DateWhereInput>;
-  updatedAt?: InputMaybe<DateWhereInput>;
-  search?: InputMaybe<SearchWhereInput>;
-  authentication?: InputMaybe<UserAuthenticationWhereInput>;
-  provider?: InputMaybe<AnyWhereInput>;
-  isOauth?: InputMaybe<BooleanWhereInput>;
-  email?: InputMaybe<EmailWhereInput>;
-  verifiedEmail?: InputMaybe<BooleanWhereInput>;
-  role?: InputMaybe<RoleWhereInput>;
-  sessions?: InputMaybe<_SessionWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserWhereInput>>>;
+  id?: IdWhereInput;
+  name?: StringWhereInput;
+  age?: IntWhereInput;
+  acl?: UserACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  authentication?: UserAuthenticationWhereInput;
+  provider?: AnyWhereInput;
+  isOauth?: BooleanWhereInput;
+  email?: EmailWhereInput;
+  verifiedEmail?: BooleanWhereInput;
+  role?: RoleWhereInput;
+  sessions?: _SessionWhereInput;
+  OR?: UserWhereInput[];
+  AND?: UserWhereInput[];
 };
 
 export type IdWhereInput = {
-  equalTo?: InputMaybe<Scalars['ID']['input']>;
-  notEqualTo?: InputMaybe<Scalars['ID']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
+  equalTo?: Scalars['ID']['input'];
+  notEqualTo?: Scalars['ID']['input'];
+  in?: Scalars['ID']['input'][];
+  notIn?: Scalars['ID']['input'][];
 };
 
 export type StringWhereInput = {
-  equalTo?: InputMaybe<Scalars['String']['input']>;
-  notEqualTo?: InputMaybe<Scalars['String']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  equalTo?: Scalars['String']['input'];
+  notEqualTo?: Scalars['String']['input'];
+  in?: Scalars['String']['input'][];
+  notIn?: Scalars['String']['input'][];
 };
 
 export type IntWhereInput = {
-  equalTo?: InputMaybe<Scalars['Int']['input']>;
-  notEqualTo?: InputMaybe<Scalars['Int']['input']>;
-  lessThan?: InputMaybe<Scalars['Int']['input']>;
-  lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
-  greaterThan?: InputMaybe<Scalars['Int']['input']>;
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['Int']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['Int']['input']>>>;
+  equalTo?: Scalars['Int']['input'];
+  notEqualTo?: Scalars['Int']['input'];
+  lessThan?: Scalars['Int']['input'];
+  lessThanOrEqualTo?: Scalars['Int']['input'];
+  greaterThan?: Scalars['Int']['input'];
+  greaterThanOrEqualTo?: Scalars['Int']['input'];
+  in?: Scalars['Int']['input'][];
+  notIn?: Scalars['Int']['input'][];
 };
 
-export type UserAclObjectWhereInput = {
-  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclWhereInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclWhereInput>>>;
-  OR?: InputMaybe<Array<InputMaybe<UserAclObjectWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAclObjectWhereInput>>>;
+export type UserACLObjectWhereInput = {
+  users?: UserACLObjectUsersACLWhereInput[];
+  roles?: UserACLObjectRolesACLWhereInput[];
+  OR?: UserACLObjectWhereInput[];
+  AND?: UserACLObjectWhereInput[];
 };
 
-export type UserAclObjectUsersAclWhereInput = {
-  userId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclWhereInput>>>;
+export type UserACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: UserACLObjectUsersACLWhereInput[];
+  AND?: UserACLObjectUsersACLWhereInput[];
 };
 
 export type BooleanWhereInput = {
-  equalTo?: InputMaybe<Scalars['Boolean']['input']>;
-  notEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['Boolean']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['Boolean']['input']>>>;
+  equalTo?: Scalars['Boolean']['input'];
+  notEqualTo?: Scalars['Boolean']['input'];
+  in?: Scalars['Boolean']['input'][];
+  notIn?: Scalars['Boolean']['input'][];
 };
 
-export type UserAclObjectRolesAclWhereInput = {
-  roleId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclWhereInput>>>;
+export type UserACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: UserACLObjectRolesACLWhereInput[];
+  AND?: UserACLObjectRolesACLWhereInput[];
 };
 
 export type DateWhereInput = {
-  equalTo?: InputMaybe<Scalars['Date']['input']>;
-  notEqualTo?: InputMaybe<Scalars['Date']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['Date']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['Date']['input']>>>;
-  lessThan?: InputMaybe<Scalars['Date']['input']>;
-  lessThanOrEqualTo?: InputMaybe<Scalars['Date']['input']>;
-  greaterThan?: InputMaybe<Scalars['Date']['input']>;
-  greaterThanOrEqualTo?: InputMaybe<Scalars['Date']['input']>;
+  equalTo?: Scalars['Date']['input'];
+  notEqualTo?: Scalars['Date']['input'];
+  in?: Scalars['Date']['input'][];
+  notIn?: Scalars['Date']['input'][];
+  lessThan?: Scalars['Date']['input'];
+  lessThanOrEqualTo?: Scalars['Date']['input'];
+  greaterThan?: Scalars['Date']['input'];
+  greaterThanOrEqualTo?: Scalars['Date']['input'];
 };
 
 export type SearchWhereInput = {
-  contains?: InputMaybe<Scalars['Search']['input']>;
+  contains?: Scalars['Search']['input'];
 };
 
 export type UserAuthenticationWhereInput = {
-  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordWhereInput>;
-  google?: InputMaybe<UserAuthenticationGoogleWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAuthenticationWhereInput>>>;
+  emailPassword?: UserAuthenticationEmailPasswordWhereInput;
+  google?: UserAuthenticationGoogleWhereInput;
+  OR?: UserAuthenticationWhereInput[];
+  AND?: UserAuthenticationWhereInput[];
 };
 
 export type UserAuthenticationEmailPasswordWhereInput = {
-  email?: InputMaybe<EmailWhereInput>;
-  password?: InputMaybe<StringWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationEmailPasswordWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAuthenticationEmailPasswordWhereInput>>>;
+  email?: EmailWhereInput;
+  password?: StringWhereInput;
+  OR?: UserAuthenticationEmailPasswordWhereInput[];
+  AND?: UserAuthenticationEmailPasswordWhereInput[];
 };
 
 export type EmailWhereInput = {
-  equalTo?: InputMaybe<Scalars['Email']['input']>;
-  notEqualTo?: InputMaybe<Scalars['Email']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['Email']['input']>>>;
-  notIn?: InputMaybe<Array<InputMaybe<Scalars['Email']['input']>>>;
+  equalTo?: Scalars['Email']['input'];
+  notEqualTo?: Scalars['Email']['input'];
+  in?: Scalars['Email']['input'][];
+  notIn?: Scalars['Email']['input'][];
 };
 
 export type UserAuthenticationGoogleWhereInput = {
-  email?: InputMaybe<EmailWhereInput>;
-  verifiedEmail?: InputMaybe<BooleanWhereInput>;
-  idToken?: InputMaybe<StringWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationGoogleWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<UserAuthenticationGoogleWhereInput>>>;
+  email?: EmailWhereInput;
+  verifiedEmail?: BooleanWhereInput;
+  idToken?: StringWhereInput;
+  OR?: UserAuthenticationGoogleWhereInput[];
+  AND?: UserAuthenticationGoogleWhereInput[];
 };
 
 export type AnyWhereInput = {
-  equalTo?: InputMaybe<Scalars['Any']['input']>;
-  notEqualTo?: InputMaybe<Scalars['Any']['input']>;
+  equalTo?: Scalars['Any']['input'];
+  notEqualTo?: Scalars['Any']['input'];
 };
 
 export type RoleWhereInput = {
-  id?: InputMaybe<IdWhereInput>;
-  name?: InputMaybe<StringWhereInput>;
-  users?: InputMaybe<UserWhereInput>;
-  acl?: InputMaybe<RoleAclObjectWhereInput>;
-  createdAt?: InputMaybe<DateWhereInput>;
-  updatedAt?: InputMaybe<DateWhereInput>;
-  search?: InputMaybe<SearchWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<RoleWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<RoleWhereInput>>>;
+  id?: IdWhereInput;
+  name?: StringWhereInput;
+  users?: UserWhereInput;
+  acl?: RoleACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  OR?: RoleWhereInput[];
+  AND?: RoleWhereInput[];
 };
 
-export type RoleAclObjectWhereInput = {
-  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclWhereInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclWhereInput>>>;
-  OR?: InputMaybe<Array<InputMaybe<RoleAclObjectWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<RoleAclObjectWhereInput>>>;
+export type RoleACLObjectWhereInput = {
+  users?: RoleACLObjectUsersACLWhereInput[];
+  roles?: RoleACLObjectRolesACLWhereInput[];
+  OR?: RoleACLObjectWhereInput[];
+  AND?: RoleACLObjectWhereInput[];
 };
 
-export type RoleAclObjectUsersAclWhereInput = {
-  userId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclWhereInput>>>;
+export type RoleACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: RoleACLObjectUsersACLWhereInput[];
+  AND?: RoleACLObjectUsersACLWhereInput[];
 };
 
-export type RoleAclObjectRolesAclWhereInput = {
-  roleId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclWhereInput>>>;
+export type RoleACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: RoleACLObjectRolesACLWhereInput[];
+  AND?: RoleACLObjectRolesACLWhereInput[];
 };
 
 export type _SessionWhereInput = {
-  id?: InputMaybe<IdWhereInput>;
-  user?: InputMaybe<UserWhereInput>;
-  accessToken?: InputMaybe<StringWhereInput>;
-  accessTokenExpiresAt?: InputMaybe<DateWhereInput>;
-  refreshToken?: InputMaybe<StringWhereInput>;
-  refreshTokenExpiresAt?: InputMaybe<DateWhereInput>;
-  acl?: InputMaybe<_SessionAclObjectWhereInput>;
-  createdAt?: InputMaybe<DateWhereInput>;
-  updatedAt?: InputMaybe<DateWhereInput>;
-  search?: InputMaybe<SearchWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<_SessionWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<_SessionWhereInput>>>;
-};
-
-export type _SessionAclObjectWhereInput = {
-  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclWhereInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclWhereInput>>>;
-  OR?: InputMaybe<Array<InputMaybe<_SessionAclObjectWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<_SessionAclObjectWhereInput>>>;
-};
-
-export type _SessionAclObjectUsersAclWhereInput = {
-  userId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclWhereInput>>>;
-};
-
-export type _SessionAclObjectRolesAclWhereInput = {
-  roleId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclWhereInput>>>;
+  id?: IdWhereInput;
+  user?: UserWhereInput;
+  accessToken?: StringWhereInput;
+  accessTokenExpiresAt?: DateWhereInput;
+  refreshToken?: StringWhereInput;
+  refreshTokenExpiresAt?: DateWhereInput;
+  acl?: _SessionACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  OR?: _SessionWhereInput[];
+  AND?: _SessionWhereInput[];
+};
+
+export type _SessionACLObjectWhereInput = {
+  users?: _SessionACLObjectUsersACLWhereInput[];
+  roles?: _SessionACLObjectRolesACLWhereInput[];
+  OR?: _SessionACLObjectWhereInput[];
+  AND?: _SessionACLObjectWhereInput[];
+};
+
+export type _SessionACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: _SessionACLObjectUsersACLWhereInput[];
+  AND?: _SessionACLObjectUsersACLWhereInput[];
+};
+
+export type _SessionACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: _SessionACLObjectRolesACLWhereInput[];
+  AND?: _SessionACLObjectRolesACLWhereInput[];
 };
 
 export enum UserOrder {
-  NameAsc = 'name_ASC',
-  NameDesc = 'name_DESC',
-  AgeAsc = 'age_ASC',
-  AgeDesc = 'age_DESC',
-  AclAsc = 'acl_ASC',
-  AclDesc = 'acl_DESC',
-  CreatedAtAsc = 'createdAt_ASC',
-  CreatedAtDesc = 'createdAt_DESC',
-  UpdatedAtAsc = 'updatedAt_ASC',
-  UpdatedAtDesc = 'updatedAt_DESC',
-  SearchAsc = 'search_ASC',
-  SearchDesc = 'search_DESC',
-  AuthenticationAsc = 'authentication_ASC',
-  AuthenticationDesc = 'authentication_DESC',
-  ProviderAsc = 'provider_ASC',
-  ProviderDesc = 'provider_DESC',
-  IsOauthAsc = 'isOauth_ASC',
-  IsOauthDesc = 'isOauth_DESC',
-  EmailAsc = 'email_ASC',
-  EmailDesc = 'email_DESC',
-  VerifiedEmailAsc = 'verifiedEmail_ASC',
-  VerifiedEmailDesc = 'verifiedEmail_DESC',
-  RoleAsc = 'role_ASC',
-  RoleDesc = 'role_DESC',
-  SessionsAsc = 'sessions_ASC',
-  SessionsDesc = 'sessions_DESC'
+  name_ASC = "name_ASC",
+  name_DESC = "name_DESC",
+  age_ASC = "age_ASC",
+  age_DESC = "age_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
+  authentication_ASC = "authentication_ASC",
+  authentication_DESC = "authentication_DESC",
+  provider_ASC = "provider_ASC",
+  provider_DESC = "provider_DESC",
+  isOauth_ASC = "isOauth_ASC",
+  isOauth_DESC = "isOauth_DESC",
+  email_ASC = "email_ASC",
+  email_DESC = "email_DESC",
+  verifiedEmail_ASC = "verifiedEmail_ASC",
+  verifiedEmail_DESC = "verifiedEmail_DESC",
+  role_ASC = "role_ASC",
+  role_DESC = "role_DESC",
+  sessions_ASC = "sessions_ASC",
+  sessions_DESC = "sessions_DESC",
 }
 
 export type PostConnection = {
-  __typename?: 'PostConnection';
-  totalCount?: Maybe<Scalars['Int']['output']>;
-  edges?: Maybe<Array<Maybe<PostEdge>>>;
+  totalCount?: Scalars['Int']['output'];
+  edges?: PostEdge[];
 };
 
 export type PostEdge = {
-  __typename?: 'PostEdge';
   node: Post;
 };
 
 export type PostWhereInput = {
-  id?: InputMaybe<IdWhereInput>;
-  name?: InputMaybe<StringWhereInput>;
-  test?: InputMaybe<FileWhereInput>;
-  acl?: InputMaybe<PostAclObjectWhereInput>;
-  createdAt?: InputMaybe<DateWhereInput>;
-  updatedAt?: InputMaybe<DateWhereInput>;
-  search?: InputMaybe<SearchWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PostWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PostWhereInput>>>;
+  id?: IdWhereInput;
+  name?: StringWhereInput;
+  test?: FileWhereInput;
+  acl?: PostACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  OR?: PostWhereInput[];
+  AND?: PostWhereInput[];
 };
 
 export type FileWhereInput = {
-  equalTo?: InputMaybe<Scalars['File']['input']>;
-  notEqualTo?: InputMaybe<Scalars['File']['input']>;
-  in?: InputMaybe<Array<InputMaybe<Scalars['File']['input']>>>;
-  notInt?: InputMaybe<Array<InputMaybe<Scalars['File']['input']>>>;
+  equalTo?: Scalars['File']['input'];
+  notEqualTo?: Scalars['File']['input'];
+  in?: Scalars['File']['input'][];
+  notInt?: Scalars['File']['input'][];
 };
 
-export type PostAclObjectWhereInput = {
-  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclWhereInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclWhereInput>>>;
-  OR?: InputMaybe<Array<InputMaybe<PostAclObjectWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PostAclObjectWhereInput>>>;
+export type PostACLObjectWhereInput = {
+  users?: PostACLObjectUsersACLWhereInput[];
+  roles?: PostACLObjectRolesACLWhereInput[];
+  OR?: PostACLObjectWhereInput[];
+  AND?: PostACLObjectWhereInput[];
 };
 
-export type PostAclObjectUsersAclWhereInput = {
-  userId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclWhereInput>>>;
+export type PostACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: PostACLObjectUsersACLWhereInput[];
+  AND?: PostACLObjectUsersACLWhereInput[];
 };
 
-export type PostAclObjectRolesAclWhereInput = {
-  roleId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclWhereInput>>>;
+export type PostACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: PostACLObjectRolesACLWhereInput[];
+  AND?: PostACLObjectRolesACLWhereInput[];
 };
 
 export enum PostOrder {
-  NameAsc = 'name_ASC',
-  NameDesc = 'name_DESC',
-  TestAsc = 'test_ASC',
-  TestDesc = 'test_DESC',
-  AclAsc = 'acl_ASC',
-  AclDesc = 'acl_DESC',
-  CreatedAtAsc = 'createdAt_ASC',
-  CreatedAtDesc = 'createdAt_DESC',
-  UpdatedAtAsc = 'updatedAt_ASC',
-  UpdatedAtDesc = 'updatedAt_DESC',
-  SearchAsc = 'search_ASC',
-  SearchDesc = 'search_DESC'
+  name_ASC = "name_ASC",
+  name_DESC = "name_DESC",
+  test_ASC = "test_ASC",
+  test_DESC = "test_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
 }
 
 export enum _SessionOrder {
-  UserAsc = 'user_ASC',
-  UserDesc = 'user_DESC',
-  AccessTokenAsc = 'accessToken_ASC',
-  AccessTokenDesc = 'accessToken_DESC',
-  AccessTokenExpiresAtAsc = 'accessTokenExpiresAt_ASC',
-  AccessTokenExpiresAtDesc = 'accessTokenExpiresAt_DESC',
-  RefreshTokenAsc = 'refreshToken_ASC',
-  RefreshTokenDesc = 'refreshToken_DESC',
-  RefreshTokenExpiresAtAsc = 'refreshTokenExpiresAt_ASC',
-  RefreshTokenExpiresAtDesc = 'refreshTokenExpiresAt_DESC',
-  AclAsc = 'acl_ASC',
-  AclDesc = 'acl_DESC',
-  CreatedAtAsc = 'createdAt_ASC',
-  CreatedAtDesc = 'createdAt_DESC',
-  UpdatedAtAsc = 'updatedAt_ASC',
-  UpdatedAtDesc = 'updatedAt_DESC',
-  SearchAsc = 'search_ASC',
-  SearchDesc = 'search_DESC'
+  user_ASC = "user_ASC",
+  user_DESC = "user_DESC",
+  accessToken_ASC = "accessToken_ASC",
+  accessToken_DESC = "accessToken_DESC",
+  accessTokenExpiresAt_ASC = "accessTokenExpiresAt_ASC",
+  accessTokenExpiresAt_DESC = "accessTokenExpiresAt_DESC",
+  refreshToken_ASC = "refreshToken_ASC",
+  refreshToken_DESC = "refreshToken_DESC",
+  refreshTokenExpiresAt_ASC = "refreshTokenExpiresAt_ASC",
+  refreshTokenExpiresAt_DESC = "refreshTokenExpiresAt_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
 }
 
 export type RoleConnection = {
-  __typename?: 'RoleConnection';
-  totalCount?: Maybe<Scalars['Int']['output']>;
-  edges?: Maybe<Array<Maybe<RoleEdge>>>;
+  totalCount?: Scalars['Int']['output'];
+  edges?: RoleEdge[];
 };
 
 export type RoleEdge = {
-  __typename?: 'RoleEdge';
   node: Role;
 };
 
 export enum RoleOrder {
-  NameAsc = 'name_ASC',
-  NameDesc = 'name_DESC',
-  UsersAsc = 'users_ASC',
-  UsersDesc = 'users_DESC',
-  AclAsc = 'acl_ASC',
-  AclDesc = 'acl_DESC',
-  CreatedAtAsc = 'createdAt_ASC',
-  CreatedAtDesc = 'createdAt_DESC',
-  UpdatedAtAsc = 'updatedAt_ASC',
-  UpdatedAtDesc = 'updatedAt_DESC',
-  SearchAsc = 'search_ASC',
-  SearchDesc = 'search_DESC'
+  name_ASC = "name_ASC",
+  name_DESC = "name_DESC",
+  users_ASC = "users_ASC",
+  users_DESC = "users_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
 }
 
 export type PaymentConnection = {
-  __typename?: 'PaymentConnection';
-  totalCount?: Maybe<Scalars['Int']['output']>;
-  edges?: Maybe<Array<Maybe<PaymentEdge>>>;
+  totalCount?: Scalars['Int']['output'];
+  edges?: PaymentEdge[];
 };
 
 export type PaymentEdge = {
-  __typename?: 'PaymentEdge';
   node: Payment;
 };
 
 export type PaymentWhereInput = {
-  id?: InputMaybe<IdWhereInput>;
-  user?: InputMaybe<UserWhereInput>;
-  amount?: InputMaybe<IntWhereInput>;
-  currency?: InputMaybe<AnyWhereInput>;
-  acl?: InputMaybe<PaymentAclObjectWhereInput>;
-  createdAt?: InputMaybe<DateWhereInput>;
-  updatedAt?: InputMaybe<DateWhereInput>;
-  search?: InputMaybe<SearchWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PaymentWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PaymentWhereInput>>>;
+  id?: IdWhereInput;
+  user?: UserWhereInput;
+  amount?: IntWhereInput;
+  currency?: AnyWhereInput;
+  acl?: PaymentACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  OR?: PaymentWhereInput[];
+  AND?: PaymentWhereInput[];
 };
 
-export type PaymentAclObjectWhereInput = {
-  users?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclWhereInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclWhereInput>>>;
-  OR?: InputMaybe<Array<InputMaybe<PaymentAclObjectWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PaymentAclObjectWhereInput>>>;
+export type PaymentACLObjectWhereInput = {
+  users?: PaymentACLObjectUsersACLWhereInput[];
+  roles?: PaymentACLObjectRolesACLWhereInput[];
+  OR?: PaymentACLObjectWhereInput[];
+  AND?: PaymentACLObjectWhereInput[];
 };
 
-export type PaymentAclObjectUsersAclWhereInput = {
-  userId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclWhereInput>>>;
+export type PaymentACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: PaymentACLObjectUsersACLWhereInput[];
+  AND?: PaymentACLObjectUsersACLWhereInput[];
 };
 
-export type PaymentAclObjectRolesAclWhereInput = {
-  roleId?: InputMaybe<StringWhereInput>;
-  read?: InputMaybe<BooleanWhereInput>;
-  write?: InputMaybe<BooleanWhereInput>;
-  OR?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclWhereInput>>>;
-  AND?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclWhereInput>>>;
+export type PaymentACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: PaymentACLObjectRolesACLWhereInput[];
+  AND?: PaymentACLObjectRolesACLWhereInput[];
 };
 
 export enum PaymentOrder {
-  UserAsc = 'user_ASC',
-  UserDesc = 'user_DESC',
-  AmountAsc = 'amount_ASC',
-  AmountDesc = 'amount_DESC',
-  CurrencyAsc = 'currency_ASC',
-  CurrencyDesc = 'currency_DESC',
-  AclAsc = 'acl_ASC',
-  AclDesc = 'acl_DESC',
-  CreatedAtAsc = 'createdAt_ASC',
-  CreatedAtDesc = 'createdAt_DESC',
-  UpdatedAtAsc = 'updatedAt_ASC',
-  UpdatedAtDesc = 'updatedAt_DESC',
-  SearchAsc = 'search_ASC',
-  SearchDesc = 'search_DESC'
+  user_ASC = "user_ASC",
+  user_DESC = "user_DESC",
+  amount_ASC = "amount_ASC",
+  amount_DESC = "amount_DESC",
+  currency_ASC = "currency_ASC",
+  currency_DESC = "currency_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
+}
+
+export type _InternalConfigConnection = {
+  totalCount?: Scalars['Int']['output'];
+  edges?: _InternalConfigEdge[];
+};
+
+export type _InternalConfigEdge = {
+  node: _InternalConfig;
+};
+
+export type _InternalConfigWhereInput = {
+  id?: IdWhereInput;
+  configKey?: StringWhereInput;
+  configValue?: StringWhereInput;
+  description?: StringWhereInput;
+  acl?: _InternalConfigACLObjectWhereInput;
+  createdAt?: DateWhereInput;
+  updatedAt?: DateWhereInput;
+  search?: SearchWhereInput;
+  OR?: _InternalConfigWhereInput[];
+  AND?: _InternalConfigWhereInput[];
+};
+
+export type _InternalConfigACLObjectWhereInput = {
+  users?: _InternalConfigACLObjectUsersACLWhereInput[];
+  roles?: _InternalConfigACLObjectRolesACLWhereInput[];
+  OR?: _InternalConfigACLObjectWhereInput[];
+  AND?: _InternalConfigACLObjectWhereInput[];
+};
+
+export type _InternalConfigACLObjectUsersACLWhereInput = {
+  userId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: _InternalConfigACLObjectUsersACLWhereInput[];
+  AND?: _InternalConfigACLObjectUsersACLWhereInput[];
+};
+
+export type _InternalConfigACLObjectRolesACLWhereInput = {
+  roleId?: StringWhereInput;
+  read?: BooleanWhereInput;
+  write?: BooleanWhereInput;
+  OR?: _InternalConfigACLObjectRolesACLWhereInput[];
+  AND?: _InternalConfigACLObjectRolesACLWhereInput[];
+};
+
+export enum _InternalConfigOrder {
+  configKey_ASC = "configKey_ASC",
+  configKey_DESC = "configKey_DESC",
+  configValue_ASC = "configValue_ASC",
+  configValue_DESC = "configValue_DESC",
+  description_ASC = "description_ASC",
+  description_DESC = "description_DESC",
+  acl_ASC = "acl_ASC",
+  acl_DESC = "acl_DESC",
+  createdAt_ASC = "createdAt_ASC",
+  createdAt_DESC = "createdAt_DESC",
+  updatedAt_ASC = "updatedAt_ASC",
+  updatedAt_DESC = "updatedAt_DESC",
+  search_ASC = "search_ASC",
+  search_DESC = "search_DESC",
 }
 
 export type MeOutput = {
-  __typename?: 'MeOutput';
-  user?: Maybe<User>;
+  user?: User;
 };
 
 export type Invoice = {
-  __typename?: 'Invoice';
   amountDue: Scalars['Int']['output'];
   amountPaid: Scalars['Int']['output'];
   currency: Currency;
@@ -1170,669 +1257,719 @@ export type Invoice = {
 };
 
 export type Mutation = {
-  __typename?: 'Mutation';
-  /** User class */
-  createUser?: Maybe<CreateUserPayload>;
-  /** User class */
+  createUser?: CreateUserPayload;
   createUsers: UserConnection;
-  /** User class */
-  updateUser?: Maybe<UpdateUserPayload>;
-  /** User class */
+  updateUser?: UpdateUserPayload;
   updateUsers: UserConnection;
-  /** User class */
-  deleteUser?: Maybe<DeleteUserPayload>;
-  /** User class */
+  deleteUser?: DeleteUserPayload;
   deleteUsers: UserConnection;
-  createPost?: Maybe<CreatePostPayload>;
+  createPost?: CreatePostPayload;
   createPosts: PostConnection;
-  updatePost?: Maybe<UpdatePostPayload>;
+  updatePost?: UpdatePostPayload;
   updatePosts: PostConnection;
-  deletePost?: Maybe<DeletePostPayload>;
+  deletePost?: DeletePostPayload;
   deletePosts: PostConnection;
-  create_Session?: Maybe<Create_SessionPayload>;
+  create_Session?: Create_SessionPayload;
   create_Sessions: _SessionConnection;
-  update_Session?: Maybe<Update_SessionPayload>;
+  update_Session?: Update_SessionPayload;
   update_Sessions: _SessionConnection;
-  delete_Session?: Maybe<Delete_SessionPayload>;
+  delete_Session?: Delete_SessionPayload;
   delete_Sessions: _SessionConnection;
-  createRole?: Maybe<CreateRolePayload>;
+  createRole?: CreateRolePayload;
   createRoles: RoleConnection;
-  updateRole?: Maybe<UpdateRolePayload>;
+  updateRole?: UpdateRolePayload;
   updateRoles: RoleConnection;
-  deleteRole?: Maybe<DeleteRolePayload>;
+  deleteRole?: DeleteRolePayload;
   deleteRoles: RoleConnection;
-  createPayment?: Maybe<CreatePaymentPayload>;
+  createPayment?: CreatePaymentPayload;
   createPayments: PaymentConnection;
-  updatePayment?: Maybe<UpdatePaymentPayload>;
+  updatePayment?: UpdatePaymentPayload;
   updatePayments: PaymentConnection;
-  deletePayment?: Maybe<DeletePaymentPayload>;
+  deletePayment?: DeletePaymentPayload;
   deletePayments: PaymentConnection;
+  create_InternalConfig?: Create_InternalConfigPayload;
+  create_InternalConfigs: _InternalConfigConnection;
+  update_InternalConfig?: Update_InternalConfigPayload;
+  update_InternalConfigs: _InternalConfigConnection;
+  delete_InternalConfig?: Delete_InternalConfigPayload;
+  delete_InternalConfigs: _InternalConfigConnection;
   createMutation: Scalars['Boolean']['output'];
-  customMutation?: Maybe<Scalars['Int']['output']>;
-  secondCustomMutation?: Maybe<Scalars['Int']['output']>;
-  /** Create a payment with the payment provider. Returns the url to redirect the user to pay */
-  makePayment?: Maybe<Scalars['String']['output']>;
-  cancelSubscription?: Maybe<Scalars['Boolean']['output']>;
-  /** Send basic email with text and html, returns the id of the email */
-  sendEmail?: Maybe<Scalars['String']['output']>;
-  signInWith?: Maybe<SignInWithOutput>;
-  signUpWith?: Maybe<SignUpWithOutput>;
-  signOut?: Maybe<Scalars['Boolean']['output']>;
-  refresh?: Maybe<RefreshSessionOutput>;
-  verifyChallenge?: Maybe<Scalars['Boolean']['output']>;
+  customMutation?: Scalars['Int']['output'];
+  secondCustomMutation?: Scalars['Int']['output'];
+  resetPassword?: Scalars['Boolean']['output'];
+  sendOtpCode?: Scalars['Boolean']['output'];
+  makePayment?: Scalars['String']['output'];
+  cancelSubscription?: Scalars['Boolean']['output'];
+  sendEmail?: Scalars['String']['output'];
+  signInWith?: SignInWithOutput;
+  signUpWith?: SignUpWithOutput;
+  signOut?: Scalars['Boolean']['output'];
+  refresh?: RefreshSessionOutput;
+  verifyChallenge?: Scalars['Boolean']['output'];
 };
 
-
 export type MutationCreateUserArgs = {
   input: CreateUserInput;
 };
 
-
 export type MutationCreateUsersArgs = {
   input: CreateUsersInput;
 };
 
-
 export type MutationUpdateUserArgs = {
   input: UpdateUserInput;
 };
 
-
 export type MutationUpdateUsersArgs = {
   input: UpdateUsersInput;
 };
 
-
 export type MutationDeleteUserArgs = {
   input: DeleteUserInput;
 };
 
-
 export type MutationDeleteUsersArgs = {
   input: DeleteUsersInput;
 };
 
-
 export type MutationCreatePostArgs = {
   input: CreatePostInput;
 };
 
-
 export type MutationCreatePostsArgs = {
   input: CreatePostsInput;
 };
 
-
 export type MutationUpdatePostArgs = {
   input: UpdatePostInput;
 };
 
-
 export type MutationUpdatePostsArgs = {
   input: UpdatePostsInput;
 };
 
-
 export type MutationDeletePostArgs = {
   input: DeletePostInput;
 };
 
-
 export type MutationDeletePostsArgs = {
   input: DeletePostsInput;
 };
 
-
 export type MutationCreate_SessionArgs = {
   input: Create_SessionInput;
 };
 
-
 export type MutationCreate_SessionsArgs = {
   input: Create_SessionsInput;
 };
 
-
 export type MutationUpdate_SessionArgs = {
   input: Update_SessionInput;
 };
 
-
 export type MutationUpdate_SessionsArgs = {
   input: Update_SessionsInput;
 };
 
-
 export type MutationDelete_SessionArgs = {
   input: Delete_SessionInput;
 };
 
-
 export type MutationDelete_SessionsArgs = {
   input: Delete_SessionsInput;
 };
 
-
 export type MutationCreateRoleArgs = {
   input: CreateRoleInput;
 };
 
-
 export type MutationCreateRolesArgs = {
   input: CreateRolesInput;
 };
 
-
 export type MutationUpdateRoleArgs = {
   input: UpdateRoleInput;
 };
 
-
 export type MutationUpdateRolesArgs = {
   input: UpdateRolesInput;
 };
 
-
 export type MutationDeleteRoleArgs = {
   input: DeleteRoleInput;
 };
 
-
 export type MutationDeleteRolesArgs = {
   input: DeleteRolesInput;
 };
 
-
 export type MutationCreatePaymentArgs = {
   input: CreatePaymentInput;
 };
 
-
 export type MutationCreatePaymentsArgs = {
   input: CreatePaymentsInput;
 };
 
-
 export type MutationUpdatePaymentArgs = {
   input: UpdatePaymentInput;
 };
 
-
 export type MutationUpdatePaymentsArgs = {
   input: UpdatePaymentsInput;
 };
 
-
 export type MutationDeletePaymentArgs = {
   input: DeletePaymentInput;
 };
 
-
 export type MutationDeletePaymentsArgs = {
   input: DeletePaymentsInput;
 };
 
+export type MutationCreate_InternalConfigArgs = {
+  input: Create_InternalConfigInput;
+};
+
+export type MutationCreate_InternalConfigsArgs = {
+  input: Create_InternalConfigsInput;
+};
+
+export type MutationUpdate_InternalConfigArgs = {
+  input: Update_InternalConfigInput;
+};
+
+export type MutationUpdate_InternalConfigsArgs = {
+  input: Update_InternalConfigsInput;
+};
+
+export type MutationDelete_InternalConfigArgs = {
+  input: Delete_InternalConfigInput;
+};
+
+export type MutationDelete_InternalConfigsArgs = {
+  input: Delete_InternalConfigsInput;
+};
 
 export type MutationCreateMutationArgs = {
   input: CreateMutationInput;
 };
 
-
 export type MutationCustomMutationArgs = {
   input: CustomMutationInput;
 };
 
-
 export type MutationSecondCustomMutationArgs = {
   input: SecondCustomMutationInput;
 };
 
+export type MutationResetPasswordArgs = {
+  input: ResetPasswordInput;
+};
+
+export type MutationSendOtpCodeArgs = {
+  input: SendOtpCodeInput;
+};
 
 export type MutationMakePaymentArgs = {
   input: MakePaymentInput;
 };
 
-
 export type MutationCancelSubscriptionArgs = {
   input: CancelSubscriptionInput;
 };
 
-
 export type MutationSendEmailArgs = {
   input: SendEmailInput;
 };
 
-
 export type MutationSignInWithArgs = {
   input: SignInWithInput;
 };
 
-
 export type MutationSignUpWithArgs = {
   input: SignUpWithInput;
 };
 
-
 export type MutationRefreshArgs = {
   input: RefreshInput;
 };
 
-
 export type MutationVerifyChallengeArgs = {
   input: VerifyChallengeInput;
 };
 
 export type CreateUserPayload = {
-  __typename?: 'CreateUserPayload';
-  user?: Maybe<User>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  user?: User;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type CreateUserInput = {
-  fields?: InputMaybe<UserCreateFieldsInput>;
+  fields?: UserCreateFieldsInput;
 };
 
 export type CreateUsersInput = {
-  fields: Array<InputMaybe<UserCreateFieldsInput>>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<UserOrder>>>;
+  fields: UserCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: UserOrder[];
 };
 
 export type UpdateUserPayload = {
-  __typename?: 'UpdateUserPayload';
-  user?: Maybe<User>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  user?: User;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type UpdateUserInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
-  fields?: InputMaybe<UserUpdateFieldsInput>;
+  id?: Scalars['ID']['input'];
+  fields?: UserUpdateFieldsInput;
 };
 
-/** User class */
 export type UserUpdateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  age?: InputMaybe<Scalars['Int']['input']>;
-  acl?: InputMaybe<UserAclObjectUpdateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
-  authentication?: InputMaybe<UserAuthenticationUpdateFieldsInput>;
-  provider?: InputMaybe<AuthenticationProvider>;
-  isOauth?: InputMaybe<Scalars['Boolean']['input']>;
-  email?: InputMaybe<Scalars['Email']['input']>;
-  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
-  role?: InputMaybe<RolePointerInput>;
-  sessions?: InputMaybe<_SessionRelationInput>;
+  name?: Scalars['String']['input'];
+  age?: Scalars['Int']['input'];
+  acl?: UserACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+  authentication?: UserAuthenticationUpdateFieldsInput;
+  provider?: AuthenticationProvider;
+  isOauth?: Scalars['Boolean']['input'];
+  email?: Scalars['Email']['input'];
+  verifiedEmail?: Scalars['Boolean']['input'];
+  role?: RolePointerInput;
+  sessions?: _SessionRelationInput;
 };
 
-export type UserAclObjectUpdateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclUpdateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclUpdateFieldsInput>>>;
+export type UserACLObjectUpdateFieldsInput = {
+  users?: UserACLObjectUsersACLUpdateFieldsInput[];
+  roles?: UserACLObjectRolesACLUpdateFieldsInput[];
 };
 
-export type UserAclObjectUsersAclUpdateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type UserACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type UserAclObjectRolesAclUpdateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type UserACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type UserAuthenticationUpdateFieldsInput = {
-  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordUpdateFieldsInput>;
-  google?: InputMaybe<UserAuthenticationGoogleUpdateFieldsInput>;
+  emailPassword?: UserAuthenticationEmailPasswordUpdateFieldsInput;
+  google?: UserAuthenticationGoogleUpdateFieldsInput;
 };
 
 export type UserAuthenticationEmailPasswordUpdateFieldsInput = {
-  email?: InputMaybe<Scalars['Email']['input']>;
-  password?: InputMaybe<Scalars['String']['input']>;
+  email?: Scalars['Email']['input'];
+  password?: Scalars['String']['input'];
 };
 
 export type UserAuthenticationGoogleUpdateFieldsInput = {
-  email?: InputMaybe<Scalars['Email']['input']>;
-  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
-  idToken?: InputMaybe<Scalars['String']['input']>;
+  email?: Scalars['Email']['input'];
+  verifiedEmail?: Scalars['Boolean']['input'];
+  idToken?: Scalars['String']['input'];
 };
 
 export type UpdateUsersInput = {
-  fields?: InputMaybe<UserUpdateFieldsInput>;
-  where?: InputMaybe<UserWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<UserOrder>>>;
+  fields?: UserUpdateFieldsInput;
+  where?: UserWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: UserOrder[];
 };
 
 export type DeleteUserPayload = {
-  __typename?: 'DeleteUserPayload';
-  user?: Maybe<User>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  user?: User;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type DeleteUserInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
 export type DeleteUsersInput = {
-  where?: InputMaybe<UserWhereInput>;
-  order?: InputMaybe<Array<InputMaybe<UserOrder>>>;
+  where?: UserWhereInput;
+  order?: UserOrder[];
 };
 
 export type CreatePostPayload = {
-  __typename?: 'CreatePostPayload';
-  post?: Maybe<Post>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  post?: Post;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type CreatePostInput = {
-  fields?: InputMaybe<PostCreateFieldsInput>;
+  fields?: PostCreateFieldsInput;
 };
 
 export type CreatePostsInput = {
-  fields: Array<InputMaybe<PostCreateFieldsInput>>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<PostOrder>>>;
+  fields: PostCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PostOrder[];
 };
 
 export type UpdatePostPayload = {
-  __typename?: 'UpdatePostPayload';
-  post?: Maybe<Post>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  post?: Post;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type UpdatePostInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
-  fields?: InputMaybe<PostUpdateFieldsInput>;
+  id?: Scalars['ID']['input'];
+  fields?: PostUpdateFieldsInput;
 };
 
 export type PostUpdateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  test?: InputMaybe<Scalars['File']['input']>;
-  acl?: InputMaybe<PostAclObjectUpdateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  name?: Scalars['String']['input'];
+  test?: Scalars['File']['input'];
+  acl?: PostACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PostAclObjectUpdateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclUpdateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclUpdateFieldsInput>>>;
+export type PostACLObjectUpdateFieldsInput = {
+  users?: PostACLObjectUsersACLUpdateFieldsInput[];
+  roles?: PostACLObjectRolesACLUpdateFieldsInput[];
 };
 
-export type PostAclObjectUsersAclUpdateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PostACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type PostAclObjectRolesAclUpdateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PostACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type UpdatePostsInput = {
-  fields?: InputMaybe<PostUpdateFieldsInput>;
-  where?: InputMaybe<PostWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<PostOrder>>>;
+  fields?: PostUpdateFieldsInput;
+  where?: PostWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PostOrder[];
 };
 
 export type DeletePostPayload = {
-  __typename?: 'DeletePostPayload';
-  post?: Maybe<Post>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  post?: Post;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type DeletePostInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
 export type DeletePostsInput = {
-  where?: InputMaybe<PostWhereInput>;
-  order?: InputMaybe<Array<InputMaybe<PostOrder>>>;
+  where?: PostWhereInput;
+  order?: PostOrder[];
 };
 
 export type Create_SessionPayload = {
-  __typename?: 'Create_SessionPayload';
-  _session?: Maybe<_Session>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  _session?: _Session;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type Create_SessionInput = {
-  fields?: InputMaybe<_SessionCreateFieldsInput>;
+  fields?: _SessionCreateFieldsInput;
 };
 
 export type Create_SessionsInput = {
-  fields: Array<InputMaybe<_SessionCreateFieldsInput>>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<_SessionOrder>>>;
+  fields: _SessionCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _SessionOrder[];
 };
 
 export type Update_SessionPayload = {
-  __typename?: 'Update_SessionPayload';
-  _session?: Maybe<_Session>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  _session?: _Session;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type Update_SessionInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
-  fields?: InputMaybe<_SessionUpdateFieldsInput>;
+  id?: Scalars['ID']['input'];
+  fields?: _SessionUpdateFieldsInput;
 };
 
 export type _SessionUpdateFieldsInput = {
-  user?: InputMaybe<UserPointerInput>;
-  accessToken?: InputMaybe<Scalars['String']['input']>;
-  accessTokenExpiresAt?: InputMaybe<Scalars['Date']['input']>;
-  refreshToken?: InputMaybe<Scalars['String']['input']>;
-  refreshTokenExpiresAt?: InputMaybe<Scalars['Date']['input']>;
-  acl?: InputMaybe<_SessionAclObjectUpdateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  user?: UserPointerInput;
+  accessToken?: Scalars['String']['input'];
+  accessTokenExpiresAt?: Scalars['Date']['input'];
+  refreshToken?: Scalars['String']['input'];
+  refreshTokenExpiresAt?: Scalars['Date']['input'];
+  acl?: _SessionACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type _SessionAclObjectUpdateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclUpdateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclUpdateFieldsInput>>>;
+export type _SessionACLObjectUpdateFieldsInput = {
+  users?: _SessionACLObjectUsersACLUpdateFieldsInput[];
+  roles?: _SessionACLObjectRolesACLUpdateFieldsInput[];
 };
 
-export type _SessionAclObjectUsersAclUpdateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type _SessionACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type _SessionAclObjectRolesAclUpdateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type _SessionACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type Update_SessionsInput = {
-  fields?: InputMaybe<_SessionUpdateFieldsInput>;
-  where?: InputMaybe<_SessionWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<_SessionOrder>>>;
+  fields?: _SessionUpdateFieldsInput;
+  where?: _SessionWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _SessionOrder[];
 };
 
 export type Delete_SessionPayload = {
-  __typename?: 'Delete_SessionPayload';
-  _session?: Maybe<_Session>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  _session?: _Session;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type Delete_SessionInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
 export type Delete_SessionsInput = {
-  where?: InputMaybe<_SessionWhereInput>;
-  order?: InputMaybe<Array<InputMaybe<_SessionOrder>>>;
+  where?: _SessionWhereInput;
+  order?: _SessionOrder[];
 };
 
 export type CreateRolePayload = {
-  __typename?: 'CreateRolePayload';
-  role?: Maybe<Role>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  role?: Role;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type CreateRoleInput = {
-  fields?: InputMaybe<RoleCreateFieldsInput>;
+  fields?: RoleCreateFieldsInput;
 };
 
 export type CreateRolesInput = {
-  fields: Array<InputMaybe<RoleCreateFieldsInput>>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<RoleOrder>>>;
+  fields: RoleCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: RoleOrder[];
 };
 
 export type UpdateRolePayload = {
-  __typename?: 'UpdateRolePayload';
-  role?: Maybe<Role>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  role?: Role;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type UpdateRoleInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
-  fields?: InputMaybe<RoleUpdateFieldsInput>;
+  id?: Scalars['ID']['input'];
+  fields?: RoleUpdateFieldsInput;
 };
 
 export type RoleUpdateFieldsInput = {
-  name?: InputMaybe<Scalars['String']['input']>;
-  users?: InputMaybe<UserRelationInput>;
-  acl?: InputMaybe<RoleAclObjectUpdateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  name?: Scalars['String']['input'];
+  users?: UserRelationInput;
+  acl?: RoleACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type RoleAclObjectUpdateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclUpdateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclUpdateFieldsInput>>>;
+export type RoleACLObjectUpdateFieldsInput = {
+  users?: RoleACLObjectUsersACLUpdateFieldsInput[];
+  roles?: RoleACLObjectRolesACLUpdateFieldsInput[];
 };
 
-export type RoleAclObjectUsersAclUpdateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type RoleACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type RoleAclObjectRolesAclUpdateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type RoleACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type UpdateRolesInput = {
-  fields?: InputMaybe<RoleUpdateFieldsInput>;
-  where?: InputMaybe<RoleWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<RoleOrder>>>;
+  fields?: RoleUpdateFieldsInput;
+  where?: RoleWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: RoleOrder[];
 };
 
 export type DeleteRolePayload = {
-  __typename?: 'DeleteRolePayload';
-  role?: Maybe<Role>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  role?: Role;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type DeleteRoleInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
 export type DeleteRolesInput = {
-  where?: InputMaybe<RoleWhereInput>;
-  order?: InputMaybe<Array<InputMaybe<RoleOrder>>>;
+  where?: RoleWhereInput;
+  order?: RoleOrder[];
 };
 
 export type CreatePaymentPayload = {
-  __typename?: 'CreatePaymentPayload';
-  payment?: Maybe<Payment>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  payment?: Payment;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type CreatePaymentInput = {
-  fields?: InputMaybe<PaymentCreateFieldsInput>;
+  fields?: PaymentCreateFieldsInput;
 };
 
 export type CreatePaymentsInput = {
-  fields: Array<InputMaybe<PaymentCreateFieldsInput>>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<PaymentOrder>>>;
+  fields: PaymentCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PaymentOrder[];
 };
 
 export type UpdatePaymentPayload = {
-  __typename?: 'UpdatePaymentPayload';
-  payment?: Maybe<Payment>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  payment?: Payment;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type UpdatePaymentInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
-  fields?: InputMaybe<PaymentUpdateFieldsInput>;
+  id?: Scalars['ID']['input'];
+  fields?: PaymentUpdateFieldsInput;
 };
 
 export type PaymentUpdateFieldsInput = {
-  user?: InputMaybe<UserPointerInput>;
-  amount?: InputMaybe<Scalars['Int']['input']>;
-  currency?: InputMaybe<Currency>;
-  acl?: InputMaybe<PaymentAclObjectUpdateFieldsInput>;
-  createdAt?: InputMaybe<Scalars['Date']['input']>;
-  updatedAt?: InputMaybe<Scalars['Date']['input']>;
-  search?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+  user?: UserPointerInput;
+  amount?: Scalars['Int']['input'];
+  currency?: Currency;
+  acl?: PaymentACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
 };
 
-export type PaymentAclObjectUpdateFieldsInput = {
-  users?: InputMaybe<Array<InputMaybe<PaymentAclObjectUsersAclUpdateFieldsInput>>>;
-  roles?: InputMaybe<Array<InputMaybe<PaymentAclObjectRolesAclUpdateFieldsInput>>>;
+export type PaymentACLObjectUpdateFieldsInput = {
+  users?: PaymentACLObjectUsersACLUpdateFieldsInput[];
+  roles?: PaymentACLObjectRolesACLUpdateFieldsInput[];
 };
 
-export type PaymentAclObjectUsersAclUpdateFieldsInput = {
-  userId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PaymentACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
-export type PaymentAclObjectRolesAclUpdateFieldsInput = {
-  roleId?: InputMaybe<Scalars['String']['input']>;
-  read?: InputMaybe<Scalars['Boolean']['input']>;
-  write?: InputMaybe<Scalars['Boolean']['input']>;
+export type PaymentACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
 };
 
 export type UpdatePaymentsInput = {
-  fields?: InputMaybe<PaymentUpdateFieldsInput>;
-  where?: InputMaybe<PaymentWhereInput>;
-  offset?: InputMaybe<Scalars['Int']['input']>;
-  first?: InputMaybe<Scalars['Int']['input']>;
-  order?: InputMaybe<Array<InputMaybe<PaymentOrder>>>;
+  fields?: PaymentUpdateFieldsInput;
+  where?: PaymentWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: PaymentOrder[];
 };
 
 export type DeletePaymentPayload = {
-  __typename?: 'DeletePaymentPayload';
-  payment?: Maybe<Payment>;
-  clientMutationId?: Maybe<Scalars['String']['output']>;
+  payment?: Payment;
+  clientMutationId?: Scalars['String']['output'];
 };
 
 export type DeletePaymentInput = {
-  id?: InputMaybe<Scalars['ID']['input']>;
+  id?: Scalars['ID']['input'];
 };
 
 export type DeletePaymentsInput = {
-  where?: InputMaybe<PaymentWhereInput>;
-  order?: InputMaybe<Array<InputMaybe<PaymentOrder>>>;
+  where?: PaymentWhereInput;
+  order?: PaymentOrder[];
+};
+
+export type Create_InternalConfigPayload = {
+  _internalConfig?: _InternalConfig;
+  clientMutationId?: Scalars['String']['output'];
+};
+
+export type Create_InternalConfigInput = {
+  fields?: _InternalConfigCreateFieldsInput;
+};
+
+export type Create_InternalConfigsInput = {
+  fields: _InternalConfigCreateFieldsInput[];
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _InternalConfigOrder[];
+};
+
+export type Update_InternalConfigPayload = {
+  _internalConfig?: _InternalConfig;
+  clientMutationId?: Scalars['String']['output'];
+};
+
+export type Update_InternalConfigInput = {
+  id?: Scalars['ID']['input'];
+  fields?: _InternalConfigUpdateFieldsInput;
+};
+
+export type _InternalConfigUpdateFieldsInput = {
+  configKey?: Scalars['String']['input'];
+  configValue?: Scalars['String']['input'];
+  description?: Scalars['String']['input'];
+  acl?: _InternalConfigACLObjectUpdateFieldsInput;
+  createdAt?: Scalars['Date']['input'];
+  updatedAt?: Scalars['Date']['input'];
+  search?: Scalars['String']['input'][];
+};
+
+export type _InternalConfigACLObjectUpdateFieldsInput = {
+  users?: _InternalConfigACLObjectUsersACLUpdateFieldsInput[];
+  roles?: _InternalConfigACLObjectRolesACLUpdateFieldsInput[];
+};
+
+export type _InternalConfigACLObjectUsersACLUpdateFieldsInput = {
+  userId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
+};
+
+export type _InternalConfigACLObjectRolesACLUpdateFieldsInput = {
+  roleId?: Scalars['String']['input'];
+  read?: Scalars['Boolean']['input'];
+  write?: Scalars['Boolean']['input'];
+};
+
+export type Update_InternalConfigsInput = {
+  fields?: _InternalConfigUpdateFieldsInput;
+  where?: _InternalConfigWhereInput;
+  offset?: Scalars['Int']['input'];
+  first?: Scalars['Int']['input'];
+  order?: _InternalConfigOrder[];
+};
+
+export type Delete_InternalConfigPayload = {
+  _internalConfig?: _InternalConfig;
+  clientMutationId?: Scalars['String']['output'];
+};
+
+export type Delete_InternalConfigInput = {
+  id?: Scalars['ID']['input'];
+};
+
+export type Delete_InternalConfigsInput = {
+  where?: _InternalConfigWhereInput;
+  order?: _InternalConfigOrder[];
 };
 
 export type CreateMutationInput = {
@@ -1845,7 +1982,7 @@ export type CustomMutationInput = {
 };
 
 export type SecondCustomMutationInput = {
-  sum?: InputMaybe<SecondCustomMutationSumInput>;
+  sum?: SecondCustomMutationSumInput;
 };
 
 export type SecondCustomMutationSumInput = {
@@ -1853,14 +1990,25 @@ export type SecondCustomMutationSumInput = {
   b: Scalars['Int']['input'];
 };
 
+export type ResetPasswordInput = {
+  password: Scalars['String']['input'];
+  email: Scalars['Email']['input'];
+  otp: Scalars['String']['input'];
+  provider: AuthenticationProvider;
+};
+
+export type SendOtpCodeInput = {
+  email: Scalars['Email']['input'];
+};
+
 export type MakePaymentInput = {
-  customerEmail?: InputMaybe<Scalars['Email']['input']>;
+  customerEmail?: Scalars['Email']['input'];
   paymentMode: PaymentMode;
   successUrl: Scalars['String']['input'];
   cancelUrl: Scalars['String']['input'];
-  products: Array<InputMaybe<MakePaymentProductInput>>;
-  automaticTax?: InputMaybe<Scalars['Boolean']['input']>;
-  recurringInterval?: InputMaybe<PaymentReccuringInterval>;
+  products: MakePaymentProductInput[];
+  automaticTax?: Scalars['Boolean']['input'];
+  recurringInterval?: PaymentReccuringInterval;
 };
 
 export type MakePaymentProductInput = {
@@ -1875,28 +2023,27 @@ export type CancelSubscriptionInput = {
 
 export type SendEmailInput = {
   from: Scalars['String']['input'];
-  to: Array<Scalars['String']['input']>;
+  to: Scalars['String']['input'][];
   subject: Scalars['String']['input'];
-  text?: InputMaybe<Scalars['String']['input']>;
-  html?: InputMaybe<Scalars['String']['input']>;
+  text?: Scalars['String']['input'];
+  html?: Scalars['String']['input'];
 };
 
 export type SignInWithOutput = {
-  __typename?: 'SignInWithOutput';
-  id?: Maybe<Scalars['String']['output']>;
-  accessToken?: Maybe<Scalars['String']['output']>;
-  refreshToken?: Maybe<Scalars['String']['output']>;
+  id?: Scalars['String']['output'];
+  accessToken?: Scalars['String']['output'];
+  refreshToken?: Scalars['String']['output'];
 };
 
 export type SignInWithInput = {
-  authentication?: InputMaybe<SignInWithAuthenticationInput>;
+  authentication?: SignInWithAuthenticationInput;
 };
 
 export type SignInWithAuthenticationInput = {
-  emailPassword?: InputMaybe<SignInWithAuthenticationEmailPasswordInput>;
-  google?: InputMaybe<SignInWithAuthenticationGoogleInput>;
-  otp?: InputMaybe<SignInWithAuthenticationOtpInput>;
-  secondaryFactor?: InputMaybe<SecondaryFactor>;
+  emailPassword?: SignInWithAuthenticationEmailPasswordInput;
+  google?: SignInWithAuthenticationGoogleInput;
+  otp?: SignInWithAuthenticationOtpInput;
+  secondaryFactor?: SecondaryFactor;
 };
 
 export type SignInWithAuthenticationEmailPasswordInput = {
@@ -1910,25 +2057,24 @@ export type SignInWithAuthenticationGoogleInput = {
 };
 
 export type SignInWithAuthenticationOtpInput = {
-  code?: InputMaybe<Scalars['String']['input']>;
+  code?: Scalars['String']['input'];
 };
 
 export type SignUpWithOutput = {
-  __typename?: 'SignUpWithOutput';
-  id?: Maybe<Scalars['String']['output']>;
+  id?: Scalars['String']['output'];
   accessToken: Scalars['String']['output'];
   refreshToken: Scalars['String']['output'];
 };
 
 export type SignUpWithInput = {
-  authentication?: InputMaybe<SignUpWithAuthenticationInput>;
+  authentication?: SignUpWithAuthenticationInput;
 };
 
 export type SignUpWithAuthenticationInput = {
-  emailPassword?: InputMaybe<SignUpWithAuthenticationEmailPasswordInput>;
-  google?: InputMaybe<SignUpWithAuthenticationGoogleInput>;
-  otp?: InputMaybe<SignUpWithAuthenticationOtpInput>;
-  secondaryFactor?: InputMaybe<SecondaryFactor>;
+  emailPassword?: SignUpWithAuthenticationEmailPasswordInput;
+  google?: SignUpWithAuthenticationGoogleInput;
+  otp?: SignUpWithAuthenticationOtpInput;
+  secondaryFactor?: SecondaryFactor;
 };
 
 export type SignUpWithAuthenticationEmailPasswordInput = {
@@ -1942,11 +2088,10 @@ export type SignUpWithAuthenticationGoogleInput = {
 };
 
 export type SignUpWithAuthenticationOtpInput = {
-  code?: InputMaybe<Scalars['String']['input']>;
+  code?: Scalars['String']['input'];
 };
 
 export type RefreshSessionOutput = {
-  __typename?: 'RefreshSessionOutput';
   accessToken: Scalars['String']['output'];
   refreshToken: Scalars['String']['output'];
 };
@@ -1957,31 +2102,18 @@ export type RefreshInput = {
 };
 
 export type VerifyChallengeInput = {
-  factor?: InputMaybe<VerifyChallengeFactorInput>;
+  factor?: VerifyChallengeFactorInput;
 };
 
 export type VerifyChallengeFactorInput = {
-  otp?: InputMaybe<VerifyChallengeFactorOtpInput>;
+  otp?: VerifyChallengeFactorOtpInput;
 };
 
 export type VerifyChallengeFactorOtpInput = {
-  code?: InputMaybe<Scalars['String']['input']>;
+  code?: Scalars['String']['input'];
 };
 
 
-
-export type SdkFunctionWrapper = <T>(action: (requestHeaders?:Record<string, string>) => Promise<T>, operationName: string, operationType?: string, variables?: any) => Promise<T>;
-
-
-const defaultWrapper: SdkFunctionWrapper = (action, _operationName, _operationType, _variables) => action();
-
-export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper = defaultWrapper) {
-  return {
-
-  };
-}
-export type Sdk = ReturnType<typeof getSdk>;
-
 export type WabeSchemaScalars = "Phone"
 
 export type WabeSchemaEnums = "RoleEnum" | "AuthenticationProvider" | "SecondaryFactor" | "PaymentMode" | "PaymentReccuringInterval" | "Currency"
@@ -1991,5 +2123,6 @@ export type WabeSchemaTypes = {
 	Post: Post,
 	_Session: _Session,
 	Role: Role,
-	Payment: Payment
+	Payment: Payment,
+	_InternalConfig: _InternalConfig
 }