wabe 0.5.0

package/generated/wabe.ts

@@ -0,0 +1,1518 @@
+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; }
+};
+
+export enum AuthenticationProvider {
+  Google = 'Google'
+}
+
+export enum SecondaryFactor {
+  EmailOtp = 'EmailOTP'
+}
+
+/** 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';
+  userId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type UserAclObjectRolesAcl = {
+  __typename?: 'UserACLObjectRolesACL';
+  roleId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type UserAuthentication = {
+  __typename?: 'UserAuthentication';
+  emailPassword?: Maybe<UserAuthenticationEmailPassword>;
+  google?: Maybe<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>>>;
+};
+
+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 = {
+  userId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+export type UserAclObjectRolesAclInput = {
+  roleId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+export type UserAuthenticationInput = {
+  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordInput>;
+  google?: InputMaybe<UserAuthenticationGoogleInput>;
+};
+
+export type UserAuthenticationEmailPasswordInput = {
+  email: Scalars['Email']['input'];
+  password: Scalars['String']['input'];
+};
+
+export type UserAuthenticationGoogleInput = {
+  email: Scalars['Email']['input'];
+  verifiedEmail: Scalars['Boolean']['input'];
+  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>;
+};
+
+/** 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>;
+};
+
+export type UserAclObjectCreateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclCreateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclCreateFieldsInput>>>;
+};
+
+export type UserAclObjectUsersAclCreateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UserAclObjectRolesAclCreateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UserAuthenticationCreateFieldsInput = {
+  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordCreateFieldsInput>;
+  google?: InputMaybe<UserAuthenticationGoogleCreateFieldsInput>;
+};
+
+export type UserAuthenticationEmailPasswordCreateFieldsInput = {
+  email?: InputMaybe<Scalars['Email']['input']>;
+  password?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type UserAuthenticationGoogleCreateFieldsInput = {
+  email?: InputMaybe<Scalars['Email']['input']>;
+  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
+  idToken?: InputMaybe<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>>;
+};
+
+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']>>>;
+};
+
+export type PostAclObject = {
+  __typename?: 'PostACLObject';
+  users?: Maybe<Array<Maybe<PostAclObjectUsersAcl>>>;
+  roles?: Maybe<Array<Maybe<PostAclObjectRolesAcl>>>;
+};
+
+export type PostAclObjectUsersAcl = {
+  __typename?: 'PostACLObjectUsersACL';
+  userId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type PostAclObjectRolesAcl = {
+  __typename?: 'PostACLObjectRolesACL';
+  roleId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+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']>>>;
+};
+
+export type PostAclObjectInput = {
+  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclInput>>>;
+};
+
+export type PostAclObjectUsersAclInput = {
+  userId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+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>;
+};
+
+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']>>>;
+};
+
+export type PostAclObjectCreateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclCreateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclCreateFieldsInput>>>;
+};
+
+export type PostAclObjectUsersAclCreateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type PostAclObjectRolesAclCreateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<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>>;
+};
+
+export type _Session = {
+  __typename?: '_Session';
+  id: Scalars['ID']['output'];
+  user?: Maybe<User>;
+  accessToken: Scalars['String']['output'];
+  accessTokenExpiresAt: Scalars['Date']['output'];
+  refreshToken?: Maybe<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']>>>;
+};
+
+export type _SessionAclObject = {
+  __typename?: '_SessionACLObject';
+  users?: Maybe<Array<Maybe<_SessionAclObjectUsersAcl>>>;
+  roles?: Maybe<Array<Maybe<_SessionAclObjectRolesAcl>>>;
+};
+
+export type _SessionAclObjectUsersAcl = {
+  __typename?: '_SessionACLObjectUsersACL';
+  userId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type _SessionAclObjectRolesAcl = {
+  __typename?: '_SessionACLObjectRolesACL';
+  roleId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type _SessionInput = {
+  user?: InputMaybe<UserPointerInput>;
+  accessToken: Scalars['String']['input'];
+  accessTokenExpiresAt: Scalars['Date']['input'];
+  refreshToken?: InputMaybe<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']>>>;
+};
+
+export type _SessionAclObjectInput = {
+  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclInput>>>;
+};
+
+export type _SessionAclObjectUsersAclInput = {
+  userId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+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>;
+};
+
+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']>>>;
+};
+
+export type _SessionAclObjectCreateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclCreateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclCreateFieldsInput>>>;
+};
+
+export type _SessionAclObjectUsersAclCreateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type _SessionAclObjectRolesAclCreateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<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>>;
+};
+
+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']>>>;
+};
+
+export type UserConnection = {
+  __typename?: 'UserConnection';
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  edges?: Maybe<Array<Maybe<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 RoleAclObjectUsersAcl = {
+  __typename?: 'RoleACLObjectUsersACL';
+  userId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+export type RoleAclObjectRolesAcl = {
+  __typename?: 'RoleACLObjectRolesACL';
+  roleId: Scalars['String']['output'];
+  read: Scalars['Boolean']['output'];
+  write: Scalars['Boolean']['output'];
+};
+
+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']>>>;
+};
+
+export type RoleAclObjectInput = {
+  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclInput>>>;
+};
+
+export type RoleAclObjectUsersAclInput = {
+  userId: Scalars['String']['input'];
+  read: Scalars['Boolean']['input'];
+  write: Scalars['Boolean']['input'];
+};
+
+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>;
+};
+
+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']>>>;
+};
+
+export type RoleAclObjectCreateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclCreateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclCreateFieldsInput>>>;
+};
+
+export type RoleAclObjectUsersAclCreateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type RoleAclObjectRolesAclCreateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<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>>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  /** User class */
+  user?: Maybe<User>;
+  /** User class */
+  users: UserConnection;
+  post?: Maybe<Post>;
+  posts: PostConnection;
+  _session?: Maybe<_Session>;
+  _sessions: _SessionConnection;
+  role?: Maybe<Role>;
+  roles: RoleConnection;
+  /** Hello world description */
+  helloWorld?: Maybe<Scalars['String']['output']>;
+  me?: Maybe<MeOutput>;
+};
+
+
+export type QueryUserArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+
+export type QueryUsersArgs = {
+  where?: InputMaybe<UserWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryPostArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+
+export type QueryPostsArgs = {
+  where?: InputMaybe<PostWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type Query_SessionArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+
+export type Query_SessionsArgs = {
+  where?: InputMaybe<_SessionWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryRoleArgs = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+
+export type QueryRolesArgs = {
+  where?: InputMaybe<RoleWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryHelloWorldArgs = {
+  name: Scalars['String']['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>>>;
+};
+
+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']>>>;
+};
+
+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']>>>;
+};
+
+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']>>>;
+};
+
+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 UserAclObjectUsersAclWhereInput = {
+  userId?: InputMaybe<StringWhereInput>;
+  read?: InputMaybe<BooleanWhereInput>;
+  write?: InputMaybe<BooleanWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<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']>>>;
+};
+
+export type UserAclObjectRolesAclWhereInput = {
+  roleId?: InputMaybe<StringWhereInput>;
+  read?: InputMaybe<BooleanWhereInput>;
+  write?: InputMaybe<BooleanWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<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']>;
+};
+
+export type SearchWhereInput = {
+  contains?: InputMaybe<Scalars['Search']['input']>;
+};
+
+export type UserAuthenticationWhereInput = {
+  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordWhereInput>;
+  google?: InputMaybe<UserAuthenticationGoogleWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<UserAuthenticationWhereInput>>>;
+};
+
+export type UserAuthenticationEmailPasswordWhereInput = {
+  email?: InputMaybe<EmailWhereInput>;
+  password?: InputMaybe<StringWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationEmailPasswordWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<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']>>>;
+};
+
+export type UserAuthenticationGoogleWhereInput = {
+  email?: InputMaybe<EmailWhereInput>;
+  verifiedEmail?: InputMaybe<BooleanWhereInput>;
+  idToken?: InputMaybe<StringWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<UserAuthenticationGoogleWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<UserAuthenticationGoogleWhereInput>>>;
+};
+
+export type AnyWhereInput = {
+  equalTo?: InputMaybe<Scalars['Any']['input']>;
+  notEqualTo?: InputMaybe<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>>>;
+};
+
+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 RoleAclObjectUsersAclWhereInput = {
+  userId?: InputMaybe<StringWhereInput>;
+  read?: InputMaybe<BooleanWhereInput>;
+  write?: InputMaybe<BooleanWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<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 _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>>>;
+};
+
+export type PostConnection = {
+  __typename?: 'PostConnection';
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  edges?: Maybe<Array<Maybe<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>>>;
+};
+
+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']>>>;
+};
+
+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 PostAclObjectUsersAclWhereInput = {
+  userId?: InputMaybe<StringWhereInput>;
+  read?: InputMaybe<BooleanWhereInput>;
+  write?: InputMaybe<BooleanWhereInput>;
+  OR?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclWhereInput>>>;
+  AND?: InputMaybe<Array<InputMaybe<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 RoleConnection = {
+  __typename?: 'RoleConnection';
+  totalCount?: Maybe<Scalars['Int']['output']>;
+  edges?: Maybe<Array<Maybe<RoleEdge>>>;
+};
+
+export type RoleEdge = {
+  __typename?: 'RoleEdge';
+  node: Role;
+};
+
+export type MeOutput = {
+  __typename?: 'MeOutput';
+  user?: Maybe<User>;
+};
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  /** User class */
+  createUser?: Maybe<CreateUserPayload>;
+  /** User class */
+  createUsers: UserConnection;
+  /** User class */
+  updateUser?: Maybe<UpdateUserPayload>;
+  /** User class */
+  updateUsers: UserConnection;
+  /** User class */
+  deleteUser?: Maybe<DeleteUserPayload>;
+  /** User class */
+  deleteUsers: UserConnection;
+  createPost?: Maybe<CreatePostPayload>;
+  createPosts: PostConnection;
+  updatePost?: Maybe<UpdatePostPayload>;
+  updatePosts: PostConnection;
+  deletePost?: Maybe<DeletePostPayload>;
+  deletePosts: PostConnection;
+  create_Session?: Maybe<Create_SessionPayload>;
+  create_Sessions: _SessionConnection;
+  update_Session?: Maybe<Update_SessionPayload>;
+  update_Sessions: _SessionConnection;
+  delete_Session?: Maybe<Delete_SessionPayload>;
+  delete_Sessions: _SessionConnection;
+  createRole?: Maybe<CreateRolePayload>;
+  createRoles: RoleConnection;
+  updateRole?: Maybe<UpdateRolePayload>;
+  updateRoles: RoleConnection;
+  deleteRole?: Maybe<DeleteRolePayload>;
+  deleteRoles: RoleConnection;
+  createMutation: Scalars['Boolean']['output'];
+  customMutation?: Maybe<Scalars['Int']['output']>;
+  secondCustomMutation?: Maybe<Scalars['Int']['output']>;
+  signInWith?: Maybe<SignInWithOutput>;
+  signUpWith?: Maybe<SignUpWithOutput>;
+  signOut?: Maybe<Scalars['Boolean']['output']>;
+  refresh?: Maybe<RefreshSessionOutput>;
+  verifyChallenge?: Maybe<Scalars['Boolean']['output']>;
+};
+
+
+export type MutationCreateUserArgs = {
+  input?: InputMaybe<CreateUserInput>;
+};
+
+
+export type MutationCreateUsersArgs = {
+  input?: InputMaybe<CreateUsersInput>;
+};
+
+
+export type MutationUpdateUserArgs = {
+  input?: InputMaybe<UpdateUserInput>;
+};
+
+
+export type MutationUpdateUsersArgs = {
+  input?: InputMaybe<UpdateUsersInput>;
+};
+
+
+export type MutationDeleteUserArgs = {
+  input?: InputMaybe<DeleteUserInput>;
+};
+
+
+export type MutationDeleteUsersArgs = {
+  input?: InputMaybe<DeleteUsersInput>;
+};
+
+
+export type MutationCreatePostArgs = {
+  input?: InputMaybe<CreatePostInput>;
+};
+
+
+export type MutationCreatePostsArgs = {
+  input?: InputMaybe<CreatePostsInput>;
+};
+
+
+export type MutationUpdatePostArgs = {
+  input?: InputMaybe<UpdatePostInput>;
+};
+
+
+export type MutationUpdatePostsArgs = {
+  input?: InputMaybe<UpdatePostsInput>;
+};
+
+
+export type MutationDeletePostArgs = {
+  input?: InputMaybe<DeletePostInput>;
+};
+
+
+export type MutationDeletePostsArgs = {
+  input?: InputMaybe<DeletePostsInput>;
+};
+
+
+export type MutationCreate_SessionArgs = {
+  input?: InputMaybe<Create_SessionInput>;
+};
+
+
+export type MutationCreate_SessionsArgs = {
+  input?: InputMaybe<Create_SessionsInput>;
+};
+
+
+export type MutationUpdate_SessionArgs = {
+  input?: InputMaybe<Update_SessionInput>;
+};
+
+
+export type MutationUpdate_SessionsArgs = {
+  input?: InputMaybe<Update_SessionsInput>;
+};
+
+
+export type MutationDelete_SessionArgs = {
+  input?: InputMaybe<Delete_SessionInput>;
+};
+
+
+export type MutationDelete_SessionsArgs = {
+  input?: InputMaybe<Delete_SessionsInput>;
+};
+
+
+export type MutationCreateRoleArgs = {
+  input?: InputMaybe<CreateRoleInput>;
+};
+
+
+export type MutationCreateRolesArgs = {
+  input?: InputMaybe<CreateRolesInput>;
+};
+
+
+export type MutationUpdateRoleArgs = {
+  input?: InputMaybe<UpdateRoleInput>;
+};
+
+
+export type MutationUpdateRolesArgs = {
+  input?: InputMaybe<UpdateRolesInput>;
+};
+
+
+export type MutationDeleteRoleArgs = {
+  input?: InputMaybe<DeleteRoleInput>;
+};
+
+
+export type MutationDeleteRolesArgs = {
+  input?: InputMaybe<DeleteRolesInput>;
+};
+
+
+export type MutationCreateMutationArgs = {
+  input?: InputMaybe<CreateMutationInput>;
+};
+
+
+export type MutationCustomMutationArgs = {
+  input?: InputMaybe<CustomMutationInput>;
+};
+
+
+export type MutationSecondCustomMutationArgs = {
+  input?: InputMaybe<SecondCustomMutationInput>;
+};
+
+
+export type MutationSignInWithArgs = {
+  input?: InputMaybe<SignInWithInput>;
+};
+
+
+export type MutationSignUpWithArgs = {
+  input?: InputMaybe<SignUpWithInput>;
+};
+
+
+export type MutationRefreshArgs = {
+  input?: InputMaybe<RefreshInput>;
+};
+
+
+export type MutationVerifyChallengeArgs = {
+  input?: InputMaybe<VerifyChallengeInput>;
+};
+
+export type CreateUserPayload = {
+  __typename?: 'CreateUserPayload';
+  user?: Maybe<User>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type CreateUserInput = {
+  fields?: InputMaybe<UserCreateFieldsInput>;
+};
+
+export type CreateUsersInput = {
+  fields: Array<InputMaybe<UserCreateFieldsInput>>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type UpdateUserPayload = {
+  __typename?: 'UpdateUserPayload';
+  user?: Maybe<User>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type UpdateUserInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  fields?: InputMaybe<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>;
+};
+
+export type UserAclObjectUpdateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<UserAclObjectUsersAclUpdateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<UserAclObjectRolesAclUpdateFieldsInput>>>;
+};
+
+export type UserAclObjectUsersAclUpdateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UserAclObjectRolesAclUpdateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UserAuthenticationUpdateFieldsInput = {
+  emailPassword?: InputMaybe<UserAuthenticationEmailPasswordUpdateFieldsInput>;
+  google?: InputMaybe<UserAuthenticationGoogleUpdateFieldsInput>;
+};
+
+export type UserAuthenticationEmailPasswordUpdateFieldsInput = {
+  email?: InputMaybe<Scalars['Email']['input']>;
+  password?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type UserAuthenticationGoogleUpdateFieldsInput = {
+  email?: InputMaybe<Scalars['Email']['input']>;
+  verifiedEmail?: InputMaybe<Scalars['Boolean']['input']>;
+  idToken?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type UpdateUsersInput = {
+  fields?: InputMaybe<UserUpdateFieldsInput>;
+  where?: InputMaybe<UserWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type DeleteUserPayload = {
+  __typename?: 'DeleteUserPayload';
+  user?: Maybe<User>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type DeleteUserInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type DeleteUsersInput = {
+  where?: InputMaybe<UserWhereInput>;
+};
+
+export type CreatePostPayload = {
+  __typename?: 'CreatePostPayload';
+  post?: Maybe<Post>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type CreatePostInput = {
+  fields?: InputMaybe<PostCreateFieldsInput>;
+};
+
+export type CreatePostsInput = {
+  fields: Array<InputMaybe<PostCreateFieldsInput>>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type UpdatePostPayload = {
+  __typename?: 'UpdatePostPayload';
+  post?: Maybe<Post>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type UpdatePostInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  fields?: InputMaybe<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']>>>;
+};
+
+export type PostAclObjectUpdateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<PostAclObjectUsersAclUpdateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<PostAclObjectRolesAclUpdateFieldsInput>>>;
+};
+
+export type PostAclObjectUsersAclUpdateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type PostAclObjectRolesAclUpdateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UpdatePostsInput = {
+  fields?: InputMaybe<PostUpdateFieldsInput>;
+  where?: InputMaybe<PostWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type DeletePostPayload = {
+  __typename?: 'DeletePostPayload';
+  post?: Maybe<Post>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type DeletePostInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type DeletePostsInput = {
+  where?: InputMaybe<PostWhereInput>;
+};
+
+export type Create_SessionPayload = {
+  __typename?: 'Create_SessionPayload';
+  _session?: Maybe<_Session>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type Create_SessionInput = {
+  fields?: InputMaybe<_SessionCreateFieldsInput>;
+};
+
+export type Create_SessionsInput = {
+  fields: Array<InputMaybe<_SessionCreateFieldsInput>>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type Update_SessionPayload = {
+  __typename?: 'Update_SessionPayload';
+  _session?: Maybe<_Session>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type Update_SessionInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  fields?: InputMaybe<_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']>>>;
+};
+
+export type _SessionAclObjectUpdateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<_SessionAclObjectUsersAclUpdateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<_SessionAclObjectRolesAclUpdateFieldsInput>>>;
+};
+
+export type _SessionAclObjectUsersAclUpdateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type _SessionAclObjectRolesAclUpdateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type Update_SessionsInput = {
+  fields?: InputMaybe<_SessionUpdateFieldsInput>;
+  where?: InputMaybe<_SessionWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type Delete_SessionPayload = {
+  __typename?: 'Delete_SessionPayload';
+  _session?: Maybe<_Session>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type Delete_SessionInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type Delete_SessionsInput = {
+  where?: InputMaybe<_SessionWhereInput>;
+};
+
+export type CreateRolePayload = {
+  __typename?: 'CreateRolePayload';
+  role?: Maybe<Role>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type CreateRoleInput = {
+  fields?: InputMaybe<RoleCreateFieldsInput>;
+};
+
+export type CreateRolesInput = {
+  fields: Array<InputMaybe<RoleCreateFieldsInput>>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type UpdateRolePayload = {
+  __typename?: 'UpdateRolePayload';
+  role?: Maybe<Role>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type UpdateRoleInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+  fields?: InputMaybe<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']>>>;
+};
+
+export type RoleAclObjectUpdateFieldsInput = {
+  users?: InputMaybe<Array<InputMaybe<RoleAclObjectUsersAclUpdateFieldsInput>>>;
+  roles?: InputMaybe<Array<InputMaybe<RoleAclObjectRolesAclUpdateFieldsInput>>>;
+};
+
+export type RoleAclObjectUsersAclUpdateFieldsInput = {
+  userId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type RoleAclObjectRolesAclUpdateFieldsInput = {
+  roleId?: InputMaybe<Scalars['String']['input']>;
+  read?: InputMaybe<Scalars['Boolean']['input']>;
+  write?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type UpdateRolesInput = {
+  fields?: InputMaybe<RoleUpdateFieldsInput>;
+  where?: InputMaybe<RoleWhereInput>;
+  offset?: InputMaybe<Scalars['Int']['input']>;
+  first?: InputMaybe<Scalars['Int']['input']>;
+};
+
+export type DeleteRolePayload = {
+  __typename?: 'DeleteRolePayload';
+  role?: Maybe<Role>;
+  clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+
+export type DeleteRoleInput = {
+  id?: InputMaybe<Scalars['ID']['input']>;
+};
+
+export type DeleteRolesInput = {
+  where?: InputMaybe<RoleWhereInput>;
+};
+
+export type CreateMutationInput = {
+  name: Scalars['Int']['input'];
+};
+
+export type CustomMutationInput = {
+  a: Scalars['Int']['input'];
+  b: Scalars['Int']['input'];
+};
+
+export type SecondCustomMutationInput = {
+  sum?: InputMaybe<SecondCustomMutationSumInput>;
+};
+
+export type SecondCustomMutationSumInput = {
+  a: Scalars['Int']['input'];
+  b: Scalars['Int']['input'];
+};
+
+export type SignInWithOutput = {
+  __typename?: 'SignInWithOutput';
+  id?: Maybe<Scalars['String']['output']>;
+  accessToken?: Maybe<Scalars['String']['output']>;
+  refreshToken?: Maybe<Scalars['String']['output']>;
+};
+
+export type SignInWithInput = {
+  authentication?: InputMaybe<SignInWithAuthenticationInput>;
+};
+
+export type SignInWithAuthenticationInput = {
+  emailPassword?: InputMaybe<SignInWithAuthenticationEmailPasswordInput>;
+  google?: InputMaybe<SignInWithAuthenticationGoogleInput>;
+  otp?: InputMaybe<SignInWithAuthenticationOtpInput>;
+  secondaryFactor?: InputMaybe<SecondaryFactor>;
+};
+
+export type SignInWithAuthenticationEmailPasswordInput = {
+  email: Scalars['Email']['input'];
+  password: Scalars['String']['input'];
+};
+
+export type SignInWithAuthenticationGoogleInput = {
+  authorizationCode: Scalars['String']['input'];
+  codeVerifier: Scalars['String']['input'];
+};
+
+export type SignInWithAuthenticationOtpInput = {
+  code?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type SignUpWithOutput = {
+  __typename?: 'SignUpWithOutput';
+  id?: Maybe<Scalars['String']['output']>;
+  accessToken: Scalars['String']['output'];
+  refreshToken: Scalars['String']['output'];
+};
+
+export type SignUpWithInput = {
+  authentication?: InputMaybe<SignUpWithAuthenticationInput>;
+};
+
+export type SignUpWithAuthenticationInput = {
+  emailPassword?: InputMaybe<SignUpWithAuthenticationEmailPasswordInput>;
+  google?: InputMaybe<SignUpWithAuthenticationGoogleInput>;
+  otp?: InputMaybe<SignUpWithAuthenticationOtpInput>;
+  secondaryFactor?: InputMaybe<SecondaryFactor>;
+};
+
+export type SignUpWithAuthenticationEmailPasswordInput = {
+  email: Scalars['Email']['input'];
+  password: Scalars['String']['input'];
+};
+
+export type SignUpWithAuthenticationGoogleInput = {
+  authorizationCode: Scalars['String']['input'];
+  codeVerifier: Scalars['String']['input'];
+};
+
+export type SignUpWithAuthenticationOtpInput = {
+  code?: InputMaybe<Scalars['String']['input']>;
+};
+
+export type RefreshSessionOutput = {
+  __typename?: 'RefreshSessionOutput';
+  accessToken: Scalars['String']['output'];
+  refreshToken: Scalars['String']['output'];
+};
+
+export type RefreshInput = {
+  accessToken: Scalars['String']['input'];
+  refreshToken: Scalars['String']['input'];
+};
+
+export type VerifyChallengeInput = {
+  factor?: InputMaybe<VerifyChallengeFactorInput>;
+};
+
+export type VerifyChallengeFactorInput = {
+  otp?: InputMaybe<VerifyChallengeFactorOtpInput>;
+};
+
+export type VerifyChallengeFactorOtpInput = {
+  code?: InputMaybe<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 = "AuthenticationProvider" | "SecondaryFactor"
+
+export type WabeSchemaTypes = {
+	User: User,
+	Post: Post,
+	_Session: _Session,
+	Role: Role
+}