import gql from 'graphql-tag';
import * as React from 'react';
import * as ReactApollo from 'react-apollo';
export type Maybe<T> = T | null;
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string,
  String: string,
  Boolean: boolean,
  Int: number,
  Float: number,
  /** A date-time string at UTC, such as `2007-12-25T16:15:30Z`, compliant with the
   * `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO
   * 8601 standard for representation of dates and times using the Gregorian calendar.
 */
  DateTime: any,
  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
  JSON: any,
  /** The `BigInt` scalar type represents whole numeric values. */
  BigInt: any,
  /** A date string, such as `2007-12-25`, compliant with the `full-date` format
   * outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for
   * representation of dates and times using the Gregorian calendar.
 */
  Date: any,
  /** A time string at UTC, such as `16:15:30Z`, compliant with the `full-time` format
   * outlined in section 5.6 of the RFC 3339profile of the ISO 8601 standard for
   * representation of dates and times using the Gregorian calendar.
 */
  Time: any,
};

export type AggregationFunctionType = 
  'AVG' |
  'SUM' |
  'COUNT' |
  'MIN' |
  'MAX' |
  'GROUP_CONCAT' |
  'ANY_VALUE' |
  'STDDEV_POP' |
  'STDDEV_SAMP' |
  'VAR_POP' |
  'VAR_SAMP';

export type ApiToken = {
  __typename?: 'ApiToken',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  name?: Maybe<Scalars['String']>,
  roles?: Maybe<RoleListResponse>,
  _description?: Maybe<Scalars['String']>,
};


export type ApiTokenRolesArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};

/** ApiTokens create input */
export type ApiTokenCreateInput = {
  name: Scalars['String'],
  roles?: Maybe<ApiTokensRolesRelationInput>,
};

/** ApiTokens delete input */
export type ApiTokenDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

export type ApiTokenFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  token?: Maybe<StringPredicate>,
  createdBy?: Maybe<UserFilter>,
  roles?: Maybe<RoleRelationFilter>,
  AND?: Maybe<Array<ApiTokenFilter>>,
  OR?: Maybe<Array<ApiTokenFilter>>,
};

export type ApiTokenGroupBy = {
  query: ApiTokenGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type ApiTokenGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  name?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  roles?: Maybe<RoleGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type ApiTokenKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** ApiTokenListResponse output */
export type ApiTokenListResponse = {
  __typename?: 'ApiTokenListResponse',
  /** List items */
  items: Array<ApiToken>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** ApiTokenManyResponse output */
export type ApiTokenManyResponse = {
  __typename?: 'ApiTokenManyResponse',
  /** List items */
  items: Array<ApiToken>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type ApiTokenOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'name_ASC' |
  'name_DESC' |
  'token_ASC' |
  'token_DESC';

/** ApiTokens subscription payload */
export type ApiTokenPayload = {
  __typename?: 'ApiTokenPayload',
  mutation: MutationType,
  node?: Maybe<ApiToken>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<ApiToken>,
};

export type ApiTokenPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  token?: Maybe<StringPredicate>,
  createdBy?: Maybe<UserPermissionFilter>,
  roles?: Maybe<RolePermissionRelationFilter>,
  AND?: Maybe<Array<ApiTokenPermissionFilter>>,
  OR?: Maybe<Array<ApiTokenPermissionFilter>>,
};

export type ApiTokenPermissionRelationFilter = {
  some?: Maybe<ApiTokenPermissionFilter>,
  every?: Maybe<ApiTokenPermissionFilter>,
  none?: Maybe<ApiTokenPermissionFilter>,
};

export type ApiTokenRelationFilter = {
  some?: Maybe<ApiTokenFilter>,
  every?: Maybe<ApiTokenFilter>,
  none?: Maybe<ApiTokenFilter>,
};

/** API Token Response */
export type ApiTokenResponse = {
  __typename?: 'ApiTokenResponse',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  name?: Maybe<Scalars['String']>,
  roles?: Maybe<RoleListResponse>,
  token: Scalars['String'],
};


/** API Token Response */
export type ApiTokenResponseRolesArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};

/** Roles create input from apiTokens */
export type ApiTokens_RoleCreateInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersRelationInput>,
};

/** Roles update input from apiTokens */
export type ApiTokens_RoleUpdateInput = {
  filter?: Maybe<RoleKeyFilter>,
  data: RoleUpdateInput,
};

export type ApiTokenSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  name?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** ApiTokens relation input */
export type ApiTokensRolesRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<ApiTokens_RoleCreateInput>>>,
};

/** ApiTokens relation input */
export type ApiTokensRolesUpdateRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  disconnect?: Maybe<Array<RoleKeyFilter>>,
  reconnect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<ApiTokens_RoleCreateInput>>>,
  update?: Maybe<Array<Maybe<ApiTokens_RoleUpdateInput>>>,
};

/** ApiTokens subscription filter */
export type ApiTokenSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<ApiTokenFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** ApiTokens update input */
export type ApiTokenUpdateByFilterInput = {
  name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  token?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
};

/** ApiTokens update input */
export type ApiTokenUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  roles?: Maybe<ApiTokensRolesUpdateRelationInput>,
};

/** Application */
export type Application = {
  __typename?: 'Application',
  id: Scalars['ID'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  createdAt: Scalars['DateTime'],
  appType: Scalars['String'],
  status: ApplicationStatusEnum,
};

/** ApplicationDeleteMutationInput */
export type ApplicationDeleteMutationInput = {
  id: Scalars['String'],
  force?: Maybe<Scalars['Boolean']>,
};

/** Application install input */
export type ApplicationInstallInput = {
  appType: Scalars['String'],
  name: Scalars['String'],
  status?: Maybe<ApplicationStatusEnum>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** ApplicationListResponse output */
export type ApplicationListResponse = {
  __typename?: 'ApplicationListResponse',
  /** List items */
  items: Array<Application>,
  /** List items count */
  count: Scalars['Int'],
};

/** Application Status Enum */
export type ApplicationStatusEnum = 
  'ACTIVE' |
  'INACTIVE';

/** Application update input */
export type ApplicationUpdateInput = {
  id: Scalars['String'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  status?: Maybe<ApplicationStatusEnum>,
};

/** Async Session */
export type AsyncSession = {
  __typename?: 'AsyncSession',
  sessionId: Scalars['String'],
};

export type AsyncSessionStatusResponse = {
  __typename?: 'AsyncSessionStatusResponse',
  status: Scalars['String'],
  message?: Maybe<Scalars['String']>,
};

/** Message create input from attachments */
export type Attachments_MessageCreateInput = {
  channel?: Maybe<MessageChannelRelationInput>,
  text: Scalars['String'],
  attachments?: Maybe<MessageAttachmentsRelationInput>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
};

/** Message update input from attachments */
export type Attachments_MessageUpdateInput = {
  filter?: Maybe<MessageKeyFilter>,
  data: MessageUpdateInput,
};

/** Auth response */
export type Auth = {
  __typename?: 'Auth',
  refreshToken?: Maybe<Scalars['String']>,
  idToken?: Maybe<Scalars['String']>,
};

export type AuthenticationProfile = {
  __typename?: 'AuthenticationProfile',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  name?: Maybe<Scalars['String']>,
  type?: Maybe<Scalars['String']>,
  secret?: Maybe<Scalars['String']>,
  managementDomain?: Maybe<Scalars['String']>,
  clientId?: Maybe<Scalars['String']>,
  databaseName?: Maybe<Scalars['String']>,
  domain?: Maybe<Scalars['String']>,
  selfSignUpEnabled?: Maybe<Scalars['Boolean']>,
  selfSignUpEmailDomains?: Maybe<Array<Maybe<Scalars['String']>>>,
  roles?: Maybe<RoleListResponse>,
  audiences?: Maybe<Array<Maybe<Scalars['String']>>>,
  attributes?: Maybe<AuthenticationProfileAttributes>,
  _description?: Maybe<Scalars['String']>,
};


export type AuthenticationProfileRolesArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};

/** Authentication Profile Attributes */
export type AuthenticationProfileAttributes = CognitoAuthProfileAttributes;

/** Authentication profile connection options */
export type AuthenticationProfileConnectionOptions = {
  __typename?: 'AuthenticationProfileConnectionOptions',
  google?: Maybe<GoogleOptions>,
  facebook?: Maybe<FacebookOptions>,
  github?: Maybe<GithubOptions>,
};

/** Authentication profile connection options input */
export type AuthenticationProfileConnectionsOptionsInput = {
  google?: Maybe<GoogleOptionsInput>,
  facebook?: Maybe<FacebookOptionsInput>,
  github?: Maybe<GithubOptionsInput>,
};

/** AuthenticationProfiles create input */
export type AuthenticationProfileCreateInput = {
  name: Scalars['String'],
  type?: Maybe<Scalars['String']>,
  secret?: Maybe<Scalars['String']>,
  managementDomain?: Maybe<Scalars['String']>,
  clientId?: Maybe<Scalars['String']>,
  databaseName?: Maybe<Scalars['String']>,
  domain?: Maybe<Scalars['String']>,
  selfSignUpEnabled?: Maybe<Scalars['Boolean']>,
  selfSignUpEmailDomains?: Maybe<Array<Maybe<Scalars['String']>>>,
  roles?: Maybe<AuthenticationProfilesRolesRelationInput>,
  audiences?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** AuthenticationProfiles create many input */
export type AuthenticationProfileCreateManyInput = {
  name: Scalars['String'],
  type?: Maybe<Scalars['String']>,
  secret?: Maybe<Scalars['String']>,
  managementDomain?: Maybe<Scalars['String']>,
  clientId?: Maybe<Scalars['String']>,
  databaseName?: Maybe<Scalars['String']>,
  domain?: Maybe<Scalars['String']>,
  selfSignUpEnabled?: Maybe<Scalars['Boolean']>,
  selfSignUpEmailDomains?: Maybe<Array<Maybe<Scalars['String']>>>,
  roles?: Maybe<AuthenticationProfilesRolesManyRelationInput>,
  audiences?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** AuthenticationProfiles delete input */
export type AuthenticationProfileDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

export type AuthenticationProfileFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  type?: Maybe<StringPredicate>,
  secret?: Maybe<StringPredicate>,
  managementDomain?: Maybe<StringPredicate>,
  clientId?: Maybe<StringPredicate>,
  databaseName?: Maybe<StringPredicate>,
  domain?: Maybe<StringPredicate>,
  selfSignUpEnabled?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  roles?: Maybe<RoleRelationFilter>,
  AND?: Maybe<Array<AuthenticationProfileFilter>>,
  OR?: Maybe<Array<AuthenticationProfileFilter>>,
};

export type AuthenticationProfileGroupBy = {
  query: AuthenticationProfileGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type AuthenticationProfileGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  name?: Maybe<Array<GroupByField>>,
  type?: Maybe<Array<GroupByField>>,
  secret?: Maybe<Array<GroupByField>>,
  managementDomain?: Maybe<Array<GroupByField>>,
  clientId?: Maybe<Array<GroupByField>>,
  databaseName?: Maybe<Array<GroupByField>>,
  domain?: Maybe<Array<GroupByField>>,
  selfSignUpEnabled?: Maybe<Array<GroupByField>>,
  selfSignUpEmailDomains?: Maybe<Array<GroupByField>>,
  audiences?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  roles?: Maybe<RoleGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type AuthenticationProfileKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** AuthenticationProfileListResponse output */
export type AuthenticationProfileListResponse = {
  __typename?: 'AuthenticationProfileListResponse',
  /** List items */
  items: Array<AuthenticationProfile>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** AuthenticationProfileManyResponse output */
export type AuthenticationProfileManyResponse = {
  __typename?: 'AuthenticationProfileManyResponse',
  /** List items */
  items: Array<AuthenticationProfile>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type AuthenticationProfileOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'name_ASC' |
  'name_DESC' |
  'type_ASC' |
  'type_DESC' |
  'secret_ASC' |
  'secret_DESC' |
  'managementDomain_ASC' |
  'managementDomain_DESC' |
  'clientId_ASC' |
  'clientId_DESC' |
  'databaseName_ASC' |
  'databaseName_DESC' |
  'domain_ASC' |
  'domain_DESC' |
  'selfSignUpEnabled_ASC' |
  'selfSignUpEnabled_DESC';

/** AuthenticationProfiles subscription payload */
export type AuthenticationProfilePayload = {
  __typename?: 'AuthenticationProfilePayload',
  mutation: MutationType,
  node?: Maybe<AuthenticationProfile>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<AuthenticationProfile>,
};

export type AuthenticationProfilePermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  type?: Maybe<StringPredicate>,
  secret?: Maybe<StringPredicate>,
  managementDomain?: Maybe<StringPredicate>,
  clientId?: Maybe<StringPredicate>,
  databaseName?: Maybe<StringPredicate>,
  domain?: Maybe<StringPredicate>,
  selfSignUpEnabled?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  roles?: Maybe<RolePermissionRelationFilter>,
  AND?: Maybe<Array<AuthenticationProfilePermissionFilter>>,
  OR?: Maybe<Array<AuthenticationProfilePermissionFilter>>,
};

export type AuthenticationProfilePermissionRelationFilter = {
  some?: Maybe<AuthenticationProfilePermissionFilter>,
  every?: Maybe<AuthenticationProfilePermissionFilter>,
  none?: Maybe<AuthenticationProfilePermissionFilter>,
};

export type AuthenticationProfileRelationFilter = {
  some?: Maybe<AuthenticationProfileFilter>,
  every?: Maybe<AuthenticationProfileFilter>,
  none?: Maybe<AuthenticationProfileFilter>,
};

/** Roles create input from authenticationProfiles */
export type AuthenticationProfiles_RoleCreateInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersRelationInput>,
};

/** Roles update input from authenticationProfiles */
export type AuthenticationProfiles_RoleUpdateInput = {
  filter?: Maybe<RoleKeyFilter>,
  data: RoleUpdateInput,
};

export type AuthenticationProfileSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  name?: Maybe<SortOrder>,
  type?: Maybe<SortOrder>,
  secret?: Maybe<SortOrder>,
  managementDomain?: Maybe<SortOrder>,
  clientId?: Maybe<SortOrder>,
  databaseName?: Maybe<SortOrder>,
  domain?: Maybe<SortOrder>,
  selfSignUpEnabled?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** AuthenticationProfiles relation input */
export type AuthenticationProfilesRolesManyRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
};

/** AuthenticationProfiles relation input */
export type AuthenticationProfilesRolesRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<AuthenticationProfiles_RoleCreateInput>>>,
};

/** AuthenticationProfiles relation input */
export type AuthenticationProfilesRolesUpdateRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  disconnect?: Maybe<Array<RoleKeyFilter>>,
  reconnect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<AuthenticationProfiles_RoleCreateInput>>>,
  update?: Maybe<Array<Maybe<AuthenticationProfiles_RoleUpdateInput>>>,
};

/** AuthenticationProfiles subscription filter */
export type AuthenticationProfileSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<AuthenticationProfileFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** AuthenticationProfiles update input */
export type AuthenticationProfileUpdateByFilterInput = {
  name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  type?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  secret?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  managementDomain?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  clientId?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  databaseName?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  domain?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  selfSignUpEnabled?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
};

/** AuthenticationProfiles update input */
export type AuthenticationProfileUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  type?: Maybe<Scalars['String']>,
  secret?: Maybe<Scalars['String']>,
  managementDomain?: Maybe<Scalars['String']>,
  clientId?: Maybe<Scalars['String']>,
  databaseName?: Maybe<Scalars['String']>,
  domain?: Maybe<Scalars['String']>,
  selfSignUpEnabled?: Maybe<Scalars['Boolean']>,
  selfSignUpEmailDomains?: Maybe<Array<Maybe<Scalars['String']>>>,
  roles?: Maybe<AuthenticationProfilesRolesUpdateRelationInput>,
  audiences?: Maybe<Array<Maybe<Scalars['String']>>>,
};

export type AuthenticationSetting = {
  __typename?: 'AuthenticationSetting',
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  createdBy?: Maybe<User>,
  allowedCallbacks?: Maybe<Array<Maybe<Scalars['String']>>>,
  allowedWebOrigins?: Maybe<Array<Maybe<Scalars['String']>>>,
  allowedLogouts?: Maybe<Array<Maybe<Scalars['String']>>>,
  connections?: Maybe<AuthenticationProfileConnectionOptions>,
  _description?: Maybe<Scalars['String']>,
};

export type AuthenticationSettingFilter = {
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  AND?: Maybe<Array<AuthenticationSettingFilter>>,
  OR?: Maybe<Array<AuthenticationSettingFilter>>,
};

/** AuthenticationSettings subscription payload */
export type AuthenticationSettingPayload = {
  __typename?: 'AuthenticationSettingPayload',
  mutation: MutationType,
  node?: Maybe<AuthenticationSetting>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<AuthenticationSetting>,
};

/** AuthenticationSettings subscription filter */
export type AuthenticationSettingSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<AuthenticationSettingFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** AuthenticationSettings update input */
export type AuthenticationSettingUpdateInput = {
  allowedCallbacks?: Maybe<Array<Maybe<Scalars['String']>>>,
  allowedWebOrigins?: Maybe<Array<Maybe<Scalars['String']>>>,
  allowedLogouts?: Maybe<Array<Maybe<Scalars['String']>>>,
  connections?: Maybe<AuthenticationProfileConnectionsOptionsInput>,
};

/** TeamMembers update input from avatar */
export type Avatar_TeamMemberUpdateInput = {
  filter?: Maybe<TeamMemberKeyFilter>,
  data: TeamMemberUpdateInput,
};

/** Users create input from avatar */
export type Avatar_UserCreateInput = {
  email: Scalars['String'],
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarRelationInput>,
  roles?: Maybe<UsersRolesRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesRelationInput>,
};

/** Users update input from avatar */
export type Avatar_UserUpdateInput = {
  filter?: Maybe<UserKeyFilter>,
  data: UserUpdateInput,
};


export type BigIntPredicateHaving = {
  equals?: Maybe<Scalars['BigInt']>,
  not_equals?: Maybe<Scalars['BigInt']>,
  in?: Maybe<Array<Scalars['BigInt']>>,
  not_in?: Maybe<Array<Scalars['BigInt']>>,
  lt?: Maybe<Scalars['BigInt']>,
  lte?: Maybe<Scalars['BigInt']>,
  gt?: Maybe<Scalars['BigInt']>,
  gte?: Maybe<Scalars['BigInt']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<BigIntPredicateHaving>>,
  OR?: Maybe<Array<BigIntPredicateHaving>>,
};

export type BillingCurrentPlanResponse = {
  __typename?: 'BillingCurrentPlanResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  displayName?: Maybe<Scalars['String']>,
  trialEnd?: Maybe<Scalars['DateTime']>,
  status?: Maybe<WorkspaceStatus>,
  nextPlan?: Maybe<BillingNextPlanResponse>,
};

export type BillingDetailsResponse = {
  __typename?: 'BillingDetailsResponse',
  last4?: Maybe<Scalars['String']>,
  expMonth?: Maybe<Scalars['Int']>,
  expYear?: Maybe<Scalars['Int']>,
  brand?: Maybe<Scalars['String']>,
};

/** BillingDetailsUpdateMutationInput */
export type BillingDetailsUpdateMutationInput = {
  cardToken: Scalars['String'],
};

export type BillingInvoiceItem = {
  __typename?: 'BillingInvoiceItem',
  id: Scalars['ID'],
  periodStart?: Maybe<Scalars['DateTime']>,
  periodEnd?: Maybe<Scalars['DateTime']>,
  paid?: Maybe<Scalars['Boolean']>,
  invoicePdf?: Maybe<Scalars['String']>,
  amountDue?: Maybe<Scalars['Float']>,
  amountPaid?: Maybe<Scalars['Float']>,
  amountRemaining?: Maybe<Scalars['Float']>,
  endingBalance?: Maybe<Scalars['Float']>,
  number?: Maybe<Scalars['String']>,
  status?: Maybe<Scalars['String']>,
  total?: Maybe<Scalars['Float']>,
  description?: Maybe<Scalars['String']>,
};

export type BillingInvoicesListFilterType = 
  'WORKSPACE' |
  'CUSTOMER';

/** BillingInvoicesListResponse output */
export type BillingInvoicesListResponse = {
  __typename?: 'BillingInvoicesListResponse',
  /** List items */
  items: Array<BillingInvoiceItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type BillingLimitMetricItem = {
  __typename?: 'BillingLimitMetricItem',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  showPriority?: Maybe<Scalars['Int']>,
  unit?: Maybe<Scalars['String']>,
};

export type BillingMetricUsageItem = {
  __typename?: 'BillingMetricUsageItem',
  limitMetric?: Maybe<BillingLimitMetricItem>,
  value?: Maybe<Scalars['Float']>,
};

export type BillingMetricUsageQuotaItem = {
  __typename?: 'BillingMetricUsageQuotaItem',
  limitMetric?: Maybe<BillingLimitMetricItem>,
  value?: Maybe<Scalars['Float']>,
};

/** BillingMetricUsageQuotasListResponse output */
export type BillingMetricUsageQuotasListResponse = {
  __typename?: 'BillingMetricUsageQuotasListResponse',
  /** List items */
  items: Array<BillingMetricUsageQuotaItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type BillingMetricUsagesListFilter = {
  entryDate: DateTimePredicate,
};

/** BillingMetricUsagesListResponse output */
export type BillingMetricUsagesListResponse = {
  __typename?: 'BillingMetricUsagesListResponse',
  /** List items */
  items: Array<BillingMetricUsageItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type BillingNextPlanResponse = {
  __typename?: 'BillingNextPlanResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  displayName?: Maybe<Scalars['String']>,
};

export type BillingPlanBaseInfo = {
  __typename?: 'BillingPlanBaseInfo',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  isCustom?: Maybe<Scalars['Boolean']>,
  isLegacy?: Maybe<Scalars['Boolean']>,
  limitMetrics?: Maybe<Array<Maybe<BillingPlanLimitMetricItem>>>,
};

export type BillingPlanLimitMetricItem = {
  __typename?: 'BillingPlanLimitMetricItem',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  overagePrice?: Maybe<Scalars['Int']>,
  softLimit?: Maybe<Scalars['Float']>,
  hardLimit?: Maybe<Scalars['Float']>,
};

/** BillingPlanUpdateMutationInput */
export type BillingPlanUpdateMutationInput = {
  planId: Scalars['ID'],
};

export type BoolPredicate = {
  equals?: Maybe<Scalars['Boolean']>,
  not_equals?: Maybe<Scalars['Boolean']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
};

export type BoolPredicateHaving = {
  equals?: Maybe<Scalars['Boolean']>,
  not_equals?: Maybe<Scalars['Boolean']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<BoolPredicateHaving>>,
  OR?: Maybe<Array<BoolPredicateHaving>>,
};

/** ChangePasswordInput */
export type ChangePasswordInput = {
  refreshToken: Scalars['String'],
  email: Scalars['String'],
  oldPassword: Scalars['String'],
  newPassword: Scalars['String'],
  authProfileId: Scalars['ID'],
};

export type Channel = {
  __typename?: 'Channel',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  messages?: Maybe<MessageListResponse>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMemberListResponse>,
  public?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
  _description?: Maybe<Scalars['String']>,
};


export type ChannelMessagesArgs = {
  filter?: Maybe<MessageFilter>,
  orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>,
  sort?: Maybe<Array<MessageSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<MessageGroupBy>
};


export type ChannelMembersArgs = {
  filter?: Maybe<ChannelMemberFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelMemberOrderBy>>>,
  sort?: Maybe<Array<ChannelMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelMemberGroupBy>
};

/** ChannelMember create input from channel */
export type Channel_ChannelMemberCreateInput = {
  channel?: Maybe<ChannelMemberChannelRelationInput>,
  user?: Maybe<ChannelMemberUserRelationInput>,
  lastReadTS?: Maybe<Scalars['DateTime']>,
};

/** ChannelMember update input from channel */
export type Channel_ChannelMemberUpdateInput = {
  filter?: Maybe<ChannelMemberKeyFilter>,
  data: ChannelMemberUpdateInput,
};

/** Message create input from channel */
export type Channel_MessageCreateInput = {
  channel?: Maybe<MessageChannelRelationInput>,
  text: Scalars['String'],
  attachments?: Maybe<MessageAttachmentsRelationInput>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
};

/** Message update input from channel */
export type Channel_MessageUpdateInput = {
  filter?: Maybe<MessageKeyFilter>,
  data: MessageUpdateInput,
};

/** Channel create input */
export type ChannelCreateInput = {
  messages?: Maybe<ChannelMessagesRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

/** Channel create many input */
export type ChannelCreateManyInput = {
  messages?: Maybe<ChannelMessagesManyRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersManyRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

/** Channel delete input */
export type ChannelDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** ChannelFieldsPermissions create input */
export type ChannelFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  purpose?: Maybe<Scalars['Boolean']>,
  public?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['Boolean']>,
  type?: Maybe<Scalars['Boolean']>,
};

export type ChannelFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  purpose?: Maybe<StringPredicate>,
  public?: Maybe<BoolPredicate>,
  name?: Maybe<StringPredicate>,
  type?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  messages?: Maybe<MessageRelationFilter>,
  members?: Maybe<ChannelMemberRelationFilter>,
  AND?: Maybe<Array<ChannelFilter>>,
  OR?: Maybe<Array<ChannelFilter>>,
};

export type ChannelGroupBy = {
  query: ChannelGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type ChannelGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  purpose?: Maybe<Array<GroupByField>>,
  public?: Maybe<Array<GroupByField>>,
  name?: Maybe<Array<GroupByField>>,
  type?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  messages?: Maybe<MessageGroupByQuery>,
  members?: Maybe<ChannelMemberGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

/** Users create input from channelIdentities */
export type ChannelIdentities_UserCreateInput = {
  email: Scalars['String'],
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarRelationInput>,
  roles?: Maybe<UsersRolesRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesRelationInput>,
};

/** Users update input from channelIdentities */
export type ChannelIdentities_UserUpdateInput = {
  email?: Maybe<Scalars['String']>,
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarUpdateRelationInput>,
  roles?: Maybe<UsersRolesUpdateRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesUpdateRelationInput>,
};

export type ChannelKeyFilter = {
  id?: Maybe<Scalars['ID']>,
};

/** ChannelListResponse output */
export type ChannelListResponse = {
  __typename?: 'ChannelListResponse',
  /** List items */
  items: Array<Channel>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** ChannelManyResponse output */
export type ChannelManyResponse = {
  __typename?: 'ChannelManyResponse',
  /** List items */
  items: Array<Channel>,
  /** List items count */
  count: Scalars['Int'],
};

export type ChannelMember = {
  __typename?: 'ChannelMember',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  channel?: Maybe<Channel>,
  user?: Maybe<User>,
  lastReadTS?: Maybe<Scalars['DateTime']>,
  _description?: Maybe<Scalars['String']>,
  hasUnreads: Scalars['Boolean'],
};

/** ChannelMember relation input */
export type ChannelMemberChannelManyRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
};

/** ChannelMember relation input */
export type ChannelMemberChannelRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
  create?: Maybe<Members_ChannelCreateInput>,
};

/** ChannelMember relation input */
export type ChannelMemberChannelUpdateRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
  disconnect?: Maybe<ChannelKeyFilter>,
  reconnect?: Maybe<ChannelKeyFilter>,
  create?: Maybe<Members_ChannelCreateInput>,
  update?: Maybe<Members_ChannelUpdateInput>,
};

/** ChannelMember create input */
export type ChannelMemberCreateInput = {
  channel?: Maybe<ChannelMemberChannelRelationInput>,
  user?: Maybe<ChannelMemberUserRelationInput>,
  lastReadTS?: Maybe<Scalars['DateTime']>,
};

/** ChannelMember create many input */
export type ChannelMemberCreateManyInput = {
  channel: ChannelMemberChannelManyRelationInput,
  user: ChannelMemberUserManyRelationInput,
  lastReadTS?: Maybe<Scalars['DateTime']>,
};

/** ChannelMember delete input */
export type ChannelMemberDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** ChannelMemberFieldsPermissions create input */
export type ChannelMemberFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  lastReadTS?: Maybe<Scalars['Boolean']>,
};

export type ChannelMemberFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  lastReadTS?: Maybe<DateTimePredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  channel?: Maybe<ChannelFilter>,
  user?: Maybe<UserFilter>,
  AND?: Maybe<Array<ChannelMemberFilter>>,
  OR?: Maybe<Array<ChannelMemberFilter>>,
};

export type ChannelMemberGroupBy = {
  query: ChannelMemberGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type ChannelMemberGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  lastReadTS?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  channel?: Maybe<ChannelGroupByQuery>,
  user?: Maybe<UserGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type ChannelMemberKeyFilter = {
  id?: Maybe<Scalars['ID']>,
};

/** ChannelMemberListResponse output */
export type ChannelMemberListResponse = {
  __typename?: 'ChannelMemberListResponse',
  /** List items */
  items: Array<ChannelMember>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** ChannelMemberManyResponse output */
export type ChannelMemberManyResponse = {
  __typename?: 'ChannelMemberManyResponse',
  /** List items */
  items: Array<ChannelMember>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type ChannelMemberOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'lastReadTS_ASC' |
  'lastReadTS_DESC';

/** ChannelMember subscription payload */
export type ChannelMemberPayload = {
  __typename?: 'ChannelMemberPayload',
  mutation: MutationType,
  node?: Maybe<ChannelMember>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<ChannelMember>,
};

export type ChannelMemberPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  lastReadTS?: Maybe<DateTimePredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  channel?: Maybe<ChannelPermissionFilter>,
  user?: Maybe<UserPermissionFilter>,
  AND?: Maybe<Array<ChannelMemberPermissionFilter>>,
  OR?: Maybe<Array<ChannelMemberPermissionFilter>>,
};

export type ChannelMemberPermissionRelationFilter = {
  some?: Maybe<ChannelMemberPermissionFilter>,
  every?: Maybe<ChannelMemberPermissionFilter>,
  none?: Maybe<ChannelMemberPermissionFilter>,
};

export type ChannelMemberRelationFilter = {
  some?: Maybe<ChannelMemberFilter>,
  every?: Maybe<ChannelMemberFilter>,
  none?: Maybe<ChannelMemberFilter>,
};

/** Channel relation input */
export type ChannelMembersManyRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
};

export type ChannelMemberSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  lastReadTS?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  channel?: Maybe<ChannelSort>,
  user?: Maybe<UserSort>,
};

/** Channel relation input */
export type ChannelMembersRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
  create?: Maybe<Array<Maybe<Channel_ChannelMemberCreateInput>>>,
};

/** ChannelMember subscription filter */
export type ChannelMemberSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<ChannelMemberFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Channel relation input */
export type ChannelMembersUpdateRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
  disconnect?: Maybe<Array<ChannelMemberKeyFilter>>,
  reconnect?: Maybe<Array<ChannelMemberKeyFilter>>,
  create?: Maybe<Array<Maybe<Channel_ChannelMemberCreateInput>>>,
  update?: Maybe<Array<Maybe<Channel_ChannelMemberUpdateInput>>>,
};

/** ChannelMember update input */
export type ChannelMemberUpdateByFilterInput = {
  lastReadTS?: Maybe<Array<Maybe<UpdateByFilterDateTimeInput>>>,
};

/** ChannelMember update input */
export type ChannelMemberUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  channel?: Maybe<ChannelMemberChannelUpdateRelationInput>,
  user?: Maybe<ChannelMemberUserUpdateRelationInput>,
  lastReadTS?: Maybe<Scalars['DateTime']>,
};

/** ChannelMember relation input */
export type ChannelMemberUserManyRelationInput = {
  connect?: Maybe<UserKeyFilter>,
};

/** ChannelMember relation input */
export type ChannelMemberUserRelationInput = {
  connect?: Maybe<UserKeyFilter>,
  create?: Maybe<ChannelIdentities_UserCreateInput>,
};

/** ChannelMember relation input */
export type ChannelMemberUserUpdateRelationInput = {
  connect?: Maybe<UserKeyFilter>,
  disconnect?: Maybe<UserKeyFilter>,
  reconnect?: Maybe<UserKeyFilter>,
  create?: Maybe<ChannelIdentities_UserCreateInput>,
  update?: Maybe<ChannelIdentities_UserUpdateInput>,
};

/** Channel relation input */
export type ChannelMessagesManyRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
};

/** Channel relation input */
export type ChannelMessagesRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
  create?: Maybe<Array<Maybe<Channel_MessageCreateInput>>>,
};

/** Channel relation input */
export type ChannelMessagesUpdateRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
  disconnect?: Maybe<Array<MessageKeyFilter>>,
  reconnect?: Maybe<Array<MessageKeyFilter>>,
  create?: Maybe<Array<Maybe<Channel_MessageCreateInput>>>,
  update?: Maybe<Array<Maybe<Channel_MessageUpdateInput>>>,
};

/** No longer supported. Use `sort` instead. */
export type ChannelOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'purpose_ASC' |
  'purpose_DESC' |
  'public_ASC' |
  'public_DESC' |
  'name_ASC' |
  'name_DESC' |
  'type_ASC' |
  'type_DESC';

/** Channel subscription payload */
export type ChannelPayload = {
  __typename?: 'ChannelPayload',
  mutation: MutationType,
  node?: Maybe<Channel>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<Channel>,
};

export type ChannelPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  purpose?: Maybe<StringPredicate>,
  public?: Maybe<BoolPredicate>,
  name?: Maybe<StringPredicate>,
  type?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  messages?: Maybe<MessagePermissionRelationFilter>,
  members?: Maybe<ChannelMemberPermissionRelationFilter>,
  AND?: Maybe<Array<ChannelPermissionFilter>>,
  OR?: Maybe<Array<ChannelPermissionFilter>>,
};

export type ChannelSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  purpose?: Maybe<SortOrder>,
  public?: Maybe<SortOrder>,
  name?: Maybe<SortOrder>,
  type?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** Channel subscription filter */
export type ChannelSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<ChannelFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Channel update input */
export type ChannelUpdateByFilterInput = {
  purpose?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  public?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  type?: Maybe<Array<Maybe<UpdateByFilterStringSwitchInput>>>,
};

/** Channel update input */
export type ChannelUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  messages?: Maybe<ChannelMessagesUpdateRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersUpdateRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

/** Authentication Profile Attributes for Cognito */
export type CognitoAuthProfileAttributes = {
  __typename?: 'CognitoAuthProfileAttributes',
  clientAuthDomain?: Maybe<Scalars['String']>,
};

/** Computed field mode */
export type ComputedFieldMode = 
  'VIRTUAL' |
  'STORED';

/** Custom Table Field Type */
export type CustomTableField = {
  __typename?: 'CustomTableField',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType?: Maybe<FieldType>,
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<ComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  fieldTypeAttributes?: Maybe<FieldTypeAttributes>,
};


/** Date Field Attributes */
export type DateFieldTypeAttributes = {
  __typename?: 'DateFieldTypeAttributes',
  format: Scalars['String'],
};

export type DatePartFunctionType = 
  'DATE' |
  'TIME' |
  'WEEK' |
  'WEEK_DAY' |
  'WEEK_OF_YEAR' |
  'YEAR' |
  'YEAR_WEEK' |
  'DAY_NAME' |
  'DAY_OF_MONTH' |
  'DAY_OF_WEEK' |
  'DAY_OF_YEAR' |
  'QUARTER' |
  'MONTH' |
  'MONTH_NAME' |
  'HOUR' |
  'MINUTE' |
  'SECOND' |
  'MICROSECOND' |
  'LAST_DAY';

export type DatePredicateHaving = {
  equals?: Maybe<Scalars['Date']>,
  not_equals?: Maybe<Scalars['Date']>,
  in?: Maybe<Array<Scalars['Date']>>,
  not_in?: Maybe<Array<Scalars['Date']>>,
  lt?: Maybe<Scalars['Date']>,
  lte?: Maybe<Scalars['Date']>,
  gt?: Maybe<Scalars['Date']>,
  gte?: Maybe<Scalars['Date']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<DatePredicateHaving>>,
  OR?: Maybe<Array<DatePredicateHaving>>,
};


export type DateTimePredicate = {
  equals?: Maybe<Scalars['DateTime']>,
  not_equals?: Maybe<Scalars['DateTime']>,
  in?: Maybe<Array<Scalars['DateTime']>>,
  not_in?: Maybe<Array<Scalars['DateTime']>>,
  lt?: Maybe<Scalars['DateTime']>,
  lte?: Maybe<Scalars['DateTime']>,
  gt?: Maybe<Scalars['DateTime']>,
  gte?: Maybe<Scalars['DateTime']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
};

export type DateTimePredicateHaving = {
  equals?: Maybe<Scalars['DateTime']>,
  not_equals?: Maybe<Scalars['DateTime']>,
  in?: Maybe<Array<Scalars['DateTime']>>,
  not_in?: Maybe<Array<Scalars['DateTime']>>,
  lt?: Maybe<Scalars['DateTime']>,
  lte?: Maybe<Scalars['DateTime']>,
  gt?: Maybe<Scalars['DateTime']>,
  gte?: Maybe<Scalars['DateTime']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<DateTimePredicateHaving>>,
  OR?: Maybe<Array<DateTimePredicateHaving>>,
};

/** Date Type Format Enum */
export type DateTypeFormatEnum = 
  'DATE' |
  'DATETIME';

/** DeployDataResponse */
export type DeployDataResponse = {
  __typename?: 'DeployDataResponse',
  uploadBuildUrl: Scalars['String'],
  uploadMetaDataUrl: Scalars['String'],
  buildName: Scalars['String'],
};

/** DeployingBuildInput */
export type DeployingBuildInput = {
  buildName: Scalars['String'],
  options?: Maybe<DeployOptions>,
};

export type DeployModeEnum = 
  'FULL' |
  'ONLY_PLUGINS' |
  'ONLY_PROJECT' |
  'FUNCTIONS' |
  'MIGRATIONS';

/** DeployOptions */
export type DeployOptions = {
  mode?: Maybe<DeployModeEnum>,
  pluginNames?: Maybe<Array<Maybe<Scalars['String']>>>,
  extensionNames?: Maybe<Array<Maybe<Scalars['String']>>>,
};

export type DeployStatusEnum = 
  'deploying' |
  'complete_error' |
  'complete_success' |
  'compiling' |
  'preparing' |
  'initialize';

/** DeployStatusResult */
export type DeployStatusResult = {
  __typename?: 'DeployStatusResult',
  status: DeployStatusEnum,
  message?: Maybe<Scalars['String']>,
};

export type EnvironmentBackupItem = {
  __typename?: 'EnvironmentBackupItem',
  name: Scalars['String'],
  size: Scalars['Float'],
};

export type EnvironmentItem = {
  __typename?: 'EnvironmentItem',
  id: Scalars['ID'],
  name: Scalars['String'],
};

export type EnvironmentVariable = {
  __typename?: 'EnvironmentVariable',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  name?: Maybe<Scalars['String']>,
  value?: Maybe<Scalars['String']>,
  _description?: Maybe<Scalars['String']>,
};

/** EnvironmentVariables create input */
export type EnvironmentVariableCreateInput = {
  name: Scalars['String'],
  value: Scalars['String'],
};

/** EnvironmentVariables create many input */
export type EnvironmentVariableCreateManyInput = {
  name: Scalars['String'],
  value: Scalars['String'],
};

/** EnvironmentVariables delete input */
export type EnvironmentVariableDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

export type EnvironmentVariableFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  value?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  AND?: Maybe<Array<EnvironmentVariableFilter>>,
  OR?: Maybe<Array<EnvironmentVariableFilter>>,
};

export type EnvironmentVariableGroupBy = {
  query: EnvironmentVariableGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type EnvironmentVariableGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  name?: Maybe<Array<GroupByField>>,
  value?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type EnvironmentVariableKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** EnvironmentVariableListResponse output */
export type EnvironmentVariableListResponse = {
  __typename?: 'EnvironmentVariableListResponse',
  /** List items */
  items: Array<EnvironmentVariable>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** EnvironmentVariableManyResponse output */
export type EnvironmentVariableManyResponse = {
  __typename?: 'EnvironmentVariableManyResponse',
  /** List items */
  items: Array<EnvironmentVariable>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type EnvironmentVariableOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'name_ASC' |
  'name_DESC' |
  'value_ASC' |
  'value_DESC';

/** EnvironmentVariables subscription payload */
export type EnvironmentVariablePayload = {
  __typename?: 'EnvironmentVariablePayload',
  mutation: MutationType,
  node?: Maybe<EnvironmentVariable>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<EnvironmentVariable>,
};

export type EnvironmentVariableSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  name?: Maybe<SortOrder>,
  value?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** EnvironmentVariables subscription filter */
export type EnvironmentVariableSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<EnvironmentVariableFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** EnvironmentVariables update input */
export type EnvironmentVariableUpdateByFilterInput = {
  name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  value?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
};

/** EnvironmentVariables update input */
export type EnvironmentVariableUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  value?: Maybe<Scalars['String']>,
};

/** Facebook connection params */
export type FacebookOptions = {
  __typename?: 'FacebookOptions',
  enabled: Scalars['Boolean'],
  app_id: Scalars['String'],
  app_secret: Scalars['String'],
};

/** Facebook connection params input */
export type FacebookOptionsInput = {
  enabled: Scalars['Boolean'],
  app_id: Scalars['String'],
  app_secret: Scalars['String'],
};

/** Field Data Features */
export type FieldDataFeatures = {
  __typename?: 'FieldDataFeatures',
  create: Scalars['Boolean'],
  update: Scalars['Boolean'],
  sort: Scalars['Boolean'],
};

/** Field Schema Features */
export type FieldSchemaFeatures = {
  __typename?: 'FieldSchemaFeatures',
  update: Scalars['Boolean'],
  delete: Scalars['Boolean'],
};

/** Field types */
export type FieldType = 
  'ID' |
  'UUID' |
  'JSON' |
  'NUMBER' |
  'TEXT' |
  'DATE' |
  'SWITCH' |
  'RELATION' |
  'FILE' |
  'SMART' |
  'GEO' |
  'ONE_WAY_RELATION' |
  'MISSING_RELATION';

/** Field Type Attributes */
export type FieldTypeAttributes = DateFieldTypeAttributes | FileFieldTypeAttributes | MissingRelationFieldTypeAttributes | NumberFieldTypeAttributes | SmartFieldTypeAttributes | SwitchFieldTypeAttributes | TextFieldTypeAttributes | UuidFieldTypeAttributes | GeoFieldTypeAttributes;

/** Field Type Attributes Input */
export type FieldTypeAttributesInput = {
  format?: Maybe<Scalars['String']>,
  precision?: Maybe<Scalars['Int']>,
  currency?: Maybe<Scalars['String']>,
  minValue?: Maybe<Scalars['Float']>,
  maxValue?: Maybe<Scalars['Float']>,
  isBigInt?: Maybe<Scalars['Boolean']>,
  autoIncrement?: Maybe<Scalars['Boolean']>,
  fieldSize?: Maybe<Scalars['Int']>,
  expiration?: Maybe<Scalars['Int']>,
  listOptions?: Maybe<Array<Scalars['String']>>,
  maxSize?: Maybe<Scalars['Int']>,
  typeRestrictions?: Maybe<Array<Scalars['String']>>,
  srid?: Maybe<Scalars['Int']>,
};

export type File = {
  __typename?: 'File',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  fileId?: Maybe<Scalars['String']>,
  downloadUrl?: Maybe<Scalars['String']>,
  shareUrl?: Maybe<Scalars['String']>,
  provider?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  uploaded?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  uploadUrl?: Maybe<Scalars['String']>,
  fields?: Maybe<Scalars['JSON']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  settings_menuBarLogo?: Maybe<SettingListResponse>,
  settings_landingPageImage?: Maybe<SettingListResponse>,
  users_avatar?: Maybe<UserListResponse>,
  message_attachments?: Maybe<MessageListResponse>,
  teamMembers_avatar?: Maybe<TeamMemberListResponse>,
  previewUrl?: Maybe<Scalars['String']>,
  _description?: Maybe<Scalars['String']>,
};


export type FileSettings_MenuBarLogoArgs = {
  filter?: Maybe<SettingFilter>,
  orderBy?: Maybe<Array<Maybe<SettingOrderBy>>>,
  sort?: Maybe<Array<SettingSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<SettingGroupBy>
};


export type FileSettings_LandingPageImageArgs = {
  filter?: Maybe<SettingFilter>,
  orderBy?: Maybe<Array<Maybe<SettingOrderBy>>>,
  sort?: Maybe<Array<SettingSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<SettingGroupBy>
};


export type FileUsers_AvatarArgs = {
  filter?: Maybe<UserFilter>,
  orderBy?: Maybe<Array<Maybe<UserOrderBy>>>,
  sort?: Maybe<Array<UserSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<UserGroupBy>
};


export type FileMessage_AttachmentsArgs = {
  filter?: Maybe<MessageFilter>,
  orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>,
  sort?: Maybe<Array<MessageSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<MessageGroupBy>
};


export type FileTeamMembers_AvatarArgs = {
  filter?: Maybe<TeamMemberFilter>,
  orderBy?: Maybe<Array<Maybe<TeamMemberOrderBy>>>,
  sort?: Maybe<Array<TeamMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamMemberGroupBy>
};

/** Files create input */
export type FileCreateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarRelationInput>,
};

/** Files create many input */
export type FileCreateManyInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarManyRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsManyRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarManyRelationInput>,
};

/** Files delete input */
export type FileDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** FileFieldsPermissions create input */
export type FileFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  fileId?: Maybe<Scalars['Boolean']>,
  downloadUrl?: Maybe<Scalars['Boolean']>,
  shareUrl?: Maybe<Scalars['Boolean']>,
  provider?: Maybe<Scalars['Boolean']>,
  public?: Maybe<Scalars['Boolean']>,
  uploaded?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['Boolean']>,
  uploadUrl?: Maybe<Scalars['Boolean']>,
  fields?: Maybe<Scalars['Boolean']>,
  meta?: Maybe<Scalars['Boolean']>,
  mods?: Maybe<Scalars['Boolean']>,
};

/** File Field Attributes */
export type FileFieldTypeAttributes = {
  __typename?: 'FileFieldTypeAttributes',
  format: Scalars['String'],
  maxSize?: Maybe<Scalars['Int']>,
  showTitle?: Maybe<Scalars['Boolean']>,
  showUrl?: Maybe<Scalars['Boolean']>,
  typeRestrictions?: Maybe<Array<Scalars['String']>>,
  expiration?: Maybe<Scalars['Int']>,
};

export type FileFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  fileId?: Maybe<StringPredicate>,
  downloadUrl?: Maybe<StringPredicate>,
  shareUrl?: Maybe<StringPredicate>,
  provider?: Maybe<StringPredicate>,
  public?: Maybe<BoolPredicate>,
  uploaded?: Maybe<BoolPredicate>,
  filename?: Maybe<StringPredicate>,
  uploadUrl?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  settings_menuBarLogo?: Maybe<SettingRelationFilter>,
  settings_landingPageImage?: Maybe<SettingRelationFilter>,
  users_avatar?: Maybe<UserRelationFilter>,
  message_attachments?: Maybe<MessageRelationFilter>,
  teamMembers_avatar?: Maybe<TeamMemberRelationFilter>,
  AND?: Maybe<Array<FileFilter>>,
  OR?: Maybe<Array<FileFilter>>,
};

export type FileGroupBy = {
  query: FileGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type FileGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  fileId?: Maybe<Array<GroupByField>>,
  downloadUrl?: Maybe<Array<GroupByField>>,
  shareUrl?: Maybe<Array<GroupByField>>,
  provider?: Maybe<Array<GroupByField>>,
  public?: Maybe<Array<GroupByField>>,
  uploaded?: Maybe<Array<GroupByField>>,
  filename?: Maybe<Array<GroupByField>>,
  uploadUrl?: Maybe<Array<GroupByField>>,
  fields?: Maybe<Array<GroupByField>>,
  meta?: Maybe<Array<GroupByField>>,
  mods?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  settings_menuBarLogo?: Maybe<SettingGroupByQuery>,
  settings_landingPageImage?: Maybe<SettingGroupByQuery>,
  users_avatar?: Maybe<UserGroupByQuery>,
  message_attachments?: Maybe<MessageGroupByQuery>,
  teamMembers_avatar?: Maybe<TeamMemberGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type FileKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  fileId?: Maybe<Scalars['String']>,
};

/** FileListResponse output */
export type FileListResponse = {
  __typename?: 'FileListResponse',
  /** List items */
  items: Array<File>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** FileManyResponse output */
export type FileManyResponse = {
  __typename?: 'FileManyResponse',
  /** List items */
  items: Array<File>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type FileOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'fileId_ASC' |
  'fileId_DESC' |
  'downloadUrl_ASC' |
  'downloadUrl_DESC' |
  'shareUrl_ASC' |
  'shareUrl_DESC' |
  'provider_ASC' |
  'provider_DESC' |
  'public_ASC' |
  'public_DESC' |
  'uploaded_ASC' |
  'uploaded_DESC' |
  'filename_ASC' |
  'filename_DESC' |
  'uploadUrl_ASC' |
  'uploadUrl_DESC' |
  'fields_ASC' |
  'fields_DESC' |
  'meta_ASC' |
  'meta_DESC' |
  'mods_ASC' |
  'mods_DESC';

/** Files subscription payload */
export type FilePayload = {
  __typename?: 'FilePayload',
  mutation: MutationType,
  node?: Maybe<File>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<File>,
};

export type FilePermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  fileId?: Maybe<StringPredicate>,
  downloadUrl?: Maybe<StringPredicate>,
  shareUrl?: Maybe<StringPredicate>,
  provider?: Maybe<StringPredicate>,
  public?: Maybe<BoolPredicate>,
  uploaded?: Maybe<BoolPredicate>,
  filename?: Maybe<StringPredicate>,
  uploadUrl?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  settings_menuBarLogo?: Maybe<SettingPermissionRelationFilter>,
  settings_landingPageImage?: Maybe<SettingPermissionRelationFilter>,
  users_avatar?: Maybe<UserPermissionRelationFilter>,
  message_attachments?: Maybe<MessagePermissionRelationFilter>,
  teamMembers_avatar?: Maybe<TeamMemberPermissionRelationFilter>,
  AND?: Maybe<Array<FilePermissionFilter>>,
  OR?: Maybe<Array<FilePermissionFilter>>,
};

export type FilePermissionRelationFilter = {
  some?: Maybe<FilePermissionFilter>,
  every?: Maybe<FilePermissionFilter>,
  none?: Maybe<FilePermissionFilter>,
};

export type FileRelationFilter = {
  some?: Maybe<FileFilter>,
  every?: Maybe<FileFilter>,
  none?: Maybe<FileFilter>,
};

/** Files relation input */
export type FilesMessage_AttachmentsManyRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
};

/** Files relation input */
export type FilesMessage_AttachmentsRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
  create?: Maybe<Array<Maybe<Attachments_MessageCreateInput>>>,
};

/** Files relation input */
export type FilesMessage_AttachmentsUpdateRelationInput = {
  connect?: Maybe<Array<MessageKeyFilter>>,
  disconnect?: Maybe<Array<MessageKeyFilter>>,
  reconnect?: Maybe<Array<MessageKeyFilter>>,
  create?: Maybe<Array<Maybe<Attachments_MessageCreateInput>>>,
  update?: Maybe<Array<Maybe<Attachments_MessageUpdateInput>>>,
};

export type FileSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  fileId?: Maybe<SortOrder>,
  downloadUrl?: Maybe<SortOrder>,
  shareUrl?: Maybe<SortOrder>,
  provider?: Maybe<SortOrder>,
  public?: Maybe<SortOrder>,
  uploaded?: Maybe<SortOrder>,
  filename?: Maybe<SortOrder>,
  uploadUrl?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** Files relation input */
export type FilesTeamMembers_AvatarManyRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
};

/** Files relation input */
export type FilesTeamMembers_AvatarRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
};

/** Files relation input */
export type FilesTeamMembers_AvatarUpdateRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
  disconnect?: Maybe<Array<TeamMemberKeyFilter>>,
  reconnect?: Maybe<Array<TeamMemberKeyFilter>>,
  update?: Maybe<Array<Maybe<Avatar_TeamMemberUpdateInput>>>,
};

/** Files subscription filter */
export type FileSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<FileFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Files relation input */
export type FilesUsers_AvatarManyRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
};

/** Files relation input */
export type FilesUsers_AvatarRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
  create?: Maybe<Array<Maybe<Avatar_UserCreateInput>>>,
};

/** Files relation input */
export type FilesUsers_AvatarUpdateRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
  disconnect?: Maybe<Array<UserKeyFilter>>,
  reconnect?: Maybe<Array<UserKeyFilter>>,
  create?: Maybe<Array<Maybe<Avatar_UserCreateInput>>>,
  update?: Maybe<Array<Maybe<Avatar_UserUpdateInput>>>,
};

/** File Type Format Enum */
export type FileTypeFormatEnum = 
  'FILE' |
  'IMAGE';

/** Files update input */
export type FileUpdateByFilterInput = {
  downloadUrl?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  shareUrl?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  provider?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  public?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  uploaded?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  filename?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  uploadUrl?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  fields?: Maybe<Array<Maybe<UpdateByFilterJsonInput>>>,
  meta?: Maybe<Array<Maybe<UpdateByFilterJsonInput>>>,
  mods?: Maybe<Array<Maybe<UpdateByFilterJsonInput>>>,
};

/** Files update input */
export type FileUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarUpdateRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsUpdateRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarUpdateRelationInput>,
};

export type FileUploadInfoResponse = {
  __typename?: 'FileUploadInfoResponse',
  policy: Scalars['String'],
  signature: Scalars['String'],
  apiKey: Scalars['String'],
  path: Scalars['String'],
};

export type FindOrCreateDmInput = {
  usersIds: Array<Scalars['ID']>,
};

export type FindOrCreateDmMember = {
  __typename?: 'FindOrCreateDMMember',
  id: Scalars['ID'],
  user: FindOrCreateDmUser,
};

export type FindOrCreateDmMemberList = {
  __typename?: 'FindOrCreateDMMemberList',
  count: Scalars['Int'],
  items: Array<FindOrCreateDmMember>,
};

export type FindOrCreateDmResponse = {
  __typename?: 'FindOrCreateDMResponse',
  id: Scalars['ID'],
  name: Scalars['String'],
  members: FindOrCreateDmMemberList,
};

export type FindOrCreateDmUser = {
  __typename?: 'FindOrCreateDMUser',
  id: Scalars['ID'],
};

export type FloatPredicateHaving = {
  equals?: Maybe<Scalars['Float']>,
  not_equals?: Maybe<Scalars['Float']>,
  in?: Maybe<Array<Scalars['Float']>>,
  not_in?: Maybe<Array<Scalars['Float']>>,
  lt?: Maybe<Scalars['Float']>,
  lte?: Maybe<Scalars['Float']>,
  gt?: Maybe<Scalars['Float']>,
  gte?: Maybe<Scalars['Float']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<FloatPredicateHaving>>,
  OR?: Maybe<Array<FloatPredicateHaving>>,
};

/** FunctionInfo */
export type FunctionInfo = {
  name: Scalars['String'],
  functionType: FunctionType,
  description?: Maybe<Scalars['String']>,
  application?: Maybe<Application>,
};

/** FunctionInfoFilter */
export type FunctionInfoFilter = {
  name?: Maybe<Scalars['String']>,
  functionType?: Maybe<FunctionType>,
  description?: Maybe<Scalars['String']>,
};

/** FunctionInfoOrderBy */
export type FunctionInfoOrderBy = 
  'name_ASC' |
  'name_DESC' |
  'functionType_ASC' |
  'functionType_DESC' |
  'description_ASC' |
  'description_DESC';

/** FunctionListResponse output */
export type FunctionListResponse = {
  __typename?: 'FunctionListResponse',
  /** List items */
  items: Array<FunctionInfo>,
  /** List items count */
  count: Scalars['Int'],
};

/** FunctionResolverInfo */
export type FunctionResolverInfo = FunctionInfo & {
  __typename?: 'FunctionResolverInfo',
  name: Scalars['String'],
  functionType: FunctionType,
  description?: Maybe<Scalars['String']>,
  gqlType: Scalars['String'],
  application?: Maybe<Application>,
};

/** FunctionTaskInfo */
export type FunctionTaskInfo = FunctionInfo & {
  __typename?: 'FunctionTaskInfo',
  name: Scalars['String'],
  functionType: FunctionType,
  description?: Maybe<Scalars['String']>,
  scheduleExpression?: Maybe<Scalars['String']>,
  application?: Maybe<Application>,
};

/** FunctionTriggerInfo */
export type FunctionTriggerInfo = FunctionInfo & {
  __typename?: 'FunctionTriggerInfo',
  name: Scalars['String'],
  functionType: FunctionType,
  description?: Maybe<Scalars['String']>,
  operation: Scalars['String'],
  tableName: Scalars['String'],
  type: Scalars['String'],
  application?: Maybe<Application>,
};

/** FunctionType */
export type FunctionType = 
  'resolver' |
  'trigger' |
  'webhook' |
  'task' |
  'schedule';

/** FunctionWebhookInfo */
export type FunctionWebhookInfo = FunctionInfo & {
  __typename?: 'FunctionWebhookInfo',
  name: Scalars['String'],
  functionType: FunctionType,
  description?: Maybe<Scalars['String']>,
  httpMethod: Scalars['String'],
  workspaceRelativePath: Scalars['String'],
  workspaceFullPath: Scalars['String'],
  application?: Maybe<Application>,
};

/** Geo Field Attributes */
export type GeoFieldTypeAttributes = {
  __typename?: 'GeoFieldTypeAttributes',
  format: Scalars['String'],
  srid?: Maybe<Scalars['Int']>,
};

/** Github connection params */
export type GithubOptions = {
  __typename?: 'GithubOptions',
  enabled: Scalars['Boolean'],
  client_id: Scalars['String'],
  client_secret: Scalars['String'],
};

/** Github connection params input */
export type GithubOptionsInput = {
  enabled: Scalars['Boolean'],
  client_id: Scalars['String'],
  client_secret: Scalars['String'],
};

/** Google connection params */
export type GoogleOptions = {
  __typename?: 'GoogleOptions',
  enabled: Scalars['Boolean'],
  client_id: Scalars['String'],
  client_secret: Scalars['String'],
};

/** Google connection params input */
export type GoogleOptionsInput = {
  enabled: Scalars['Boolean'],
  client_id: Scalars['String'],
  client_secret: Scalars['String'],
};

export type GroupByField = {
  as?: Maybe<Scalars['String']>,
  fn?: Maybe<Array<Maybe<GroupByFieldFunction>>>,
};

export type GroupByFieldFunction = {
  aggregate?: Maybe<AggregationFunctionType>,
  distinct?: Maybe<Scalars['Boolean']>,
  datePart?: Maybe<DatePartFunctionType>,
  abs?: Maybe<Scalars['Boolean']>,
  ceil?: Maybe<Scalars['Boolean']>,
  crc32?: Maybe<Scalars['Boolean']>,
  floor?: Maybe<Scalars['Boolean']>,
  mod?: Maybe<Scalars['Int']>,
  round?: Maybe<Scalars['Int']>,
  sign?: Maybe<Scalars['Boolean']>,
  truncate?: Maybe<Scalars['Int']>,
  left?: Maybe<Scalars['Int']>,
  right?: Maybe<Scalars['Int']>,
  locate?: Maybe<LocateFunctionArguments>,
  substring?: Maybe<SubstringFunctionArguments>,
  replace?: Maybe<ReplaceFunctionArguments>,
  reverse?: Maybe<Scalars['Boolean']>,
  trim?: Maybe<TrimFunctionArguments>,
  ltrim?: Maybe<Scalars['Boolean']>,
  rtrim?: Maybe<Scalars['Boolean']>,
  lower?: Maybe<Scalars['Boolean']>,
  upper?: Maybe<Scalars['Boolean']>,
  ascii?: Maybe<Scalars['Boolean']>,
  hex?: Maybe<Scalars['Boolean']>,
  bitLength?: Maybe<Scalars['Boolean']>,
  charLength?: Maybe<Scalars['Boolean']>,
  length?: Maybe<Scalars['Boolean']>,
  like?: Maybe<PatternFunctionArguments>,
  notLike?: Maybe<PatternFunctionArguments>,
  lpad?: Maybe<StringPadFunctionArguments>,
  rpad?: Maybe<StringPadFunctionArguments>,
  ifNull?: Maybe<Scalars['String']>,
  isNull?: Maybe<Scalars['Boolean']>,
  nullIf?: Maybe<Scalars['String']>,
};

export type GroupByResponse = {
  __typename?: 'GroupByResponse',
  ID?: Maybe<Scalars['ID']>,
  String?: Maybe<Scalars['String']>,
  Int?: Maybe<Scalars['Int']>,
  BigInt?: Maybe<Scalars['BigInt']>,
  Float?: Maybe<Scalars['Float']>,
  DateTime?: Maybe<Scalars['DateTime']>,
  Date?: Maybe<Scalars['Date']>,
  Boolean?: Maybe<Scalars['Boolean']>,
  JSON?: Maybe<Scalars['JSON']>,
  GroupIds?: Maybe<Array<Scalars['ID']>>,
  UserGroup: UserListResponse,
  FileGroup: FileListResponse,
  RoleGroup: RoleListResponse,
  ApiTokenGroup: ApiTokenListResponse,
  EnvironmentVariableGroup: EnvironmentVariableListResponse,
  AuthenticationProfileGroup: AuthenticationProfileListResponse,
  TeamMemberGroup: TeamMemberListResponse,
  MessageGroup: MessageListResponse,
  ChannelGroup: ChannelListResponse,
  ChannelMemberGroup: ChannelMemberListResponse,
};


export type GroupByResponseUserGroupArgs = {
  filter?: Maybe<UserFilter>,
  orderBy?: Maybe<Array<Maybe<UserOrderBy>>>,
  sort?: Maybe<Array<UserSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<UserGroupBy>
};


export type GroupByResponseFileGroupArgs = {
  filter?: Maybe<FileFilter>,
  orderBy?: Maybe<Array<Maybe<FileOrderBy>>>,
  sort?: Maybe<Array<FileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<FileGroupBy>
};


export type GroupByResponseRoleGroupArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};


export type GroupByResponseApiTokenGroupArgs = {
  filter?: Maybe<ApiTokenFilter>,
  orderBy?: Maybe<Array<Maybe<ApiTokenOrderBy>>>,
  sort?: Maybe<Array<ApiTokenSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ApiTokenGroupBy>
};


export type GroupByResponseEnvironmentVariableGroupArgs = {
  filter?: Maybe<EnvironmentVariableFilter>,
  orderBy?: Maybe<Array<Maybe<EnvironmentVariableOrderBy>>>,
  sort?: Maybe<Array<EnvironmentVariableSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<EnvironmentVariableGroupBy>
};


export type GroupByResponseAuthenticationProfileGroupArgs = {
  filter?: Maybe<AuthenticationProfileFilter>,
  orderBy?: Maybe<Array<Maybe<AuthenticationProfileOrderBy>>>,
  sort?: Maybe<Array<AuthenticationProfileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<AuthenticationProfileGroupBy>
};


export type GroupByResponseTeamMemberGroupArgs = {
  filter?: Maybe<TeamMemberFilter>,
  orderBy?: Maybe<Array<Maybe<TeamMemberOrderBy>>>,
  sort?: Maybe<Array<TeamMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamMemberGroupBy>
};


export type GroupByResponseMessageGroupArgs = {
  filter?: Maybe<MessageFilter>,
  orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>,
  sort?: Maybe<Array<MessageSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<MessageGroupBy>
};


export type GroupByResponseChannelGroupArgs = {
  filter?: Maybe<ChannelFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelOrderBy>>>,
  sort?: Maybe<Array<ChannelSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelGroupBy>
};


export type GroupByResponseChannelMemberGroupArgs = {
  filter?: Maybe<ChannelMemberFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelMemberOrderBy>>>,
  sort?: Maybe<Array<ChannelMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelMemberGroupBy>
};

export type GroupBySort = {
  alias: Scalars['String'],
  direction: SortOrder,
};

export type GroupIdentifiersGroupByField = {
  as: Scalars['String'],
};

export type Having = {
  alias?: Maybe<Scalars['String']>,
  id?: Maybe<IdPredicateHaving>,
  string?: Maybe<StringPredicateHaving>,
  int?: Maybe<IntPredicateHaving>,
  bigint?: Maybe<BigIntPredicateHaving>,
  float?: Maybe<FloatPredicateHaving>,
  bool?: Maybe<BoolPredicateHaving>,
  date?: Maybe<DatePredicateHaving>,
  datetime?: Maybe<DateTimePredicateHaving>,
  AND?: Maybe<Array<Having>>,
  OR?: Maybe<Array<Having>>,
};

export type IdPredicate = {
  equals?: Maybe<Scalars['ID']>,
  not_equals?: Maybe<Scalars['ID']>,
  in?: Maybe<Array<Scalars['ID']>>,
  not_in?: Maybe<Array<Scalars['ID']>>,
  contains?: Maybe<Scalars['ID']>,
  not_contains?: Maybe<Scalars['ID']>,
  starts_with?: Maybe<Scalars['ID']>,
  not_starts_with?: Maybe<Scalars['ID']>,
  ends_with?: Maybe<Scalars['ID']>,
  not_ends_with?: Maybe<Scalars['ID']>,
  lt?: Maybe<Scalars['ID']>,
  lte?: Maybe<Scalars['ID']>,
  gt?: Maybe<Scalars['ID']>,
  gte?: Maybe<Scalars['ID']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
};

export type IdPredicateHaving = {
  equals?: Maybe<Scalars['ID']>,
  not_equals?: Maybe<Scalars['ID']>,
  in?: Maybe<Array<Scalars['ID']>>,
  not_in?: Maybe<Array<Scalars['ID']>>,
  contains?: Maybe<Scalars['ID']>,
  not_contains?: Maybe<Scalars['ID']>,
  starts_with?: Maybe<Scalars['ID']>,
  not_starts_with?: Maybe<Scalars['ID']>,
  ends_with?: Maybe<Scalars['ID']>,
  not_ends_with?: Maybe<Scalars['ID']>,
  lt?: Maybe<Scalars['ID']>,
  lte?: Maybe<Scalars['ID']>,
  gt?: Maybe<Scalars['ID']>,
  gte?: Maybe<Scalars['ID']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<IdPredicateHaving>>,
  OR?: Maybe<Array<IdPredicateHaving>>,
};

/** ImportedTable */
export type ImportedTable = {
  __typename?: 'ImportedTable',
  id: Scalars['ID'],
  name: Scalars['String'],
};

/** Table Create Index Input */
export type IndexCreateInput = {
  tableId: Scalars['ID'],
  type: TableIndexType,
  columns: Array<TableIndexColumnInput>,
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
};

/** Table Delete Index Input */
export type IndexDeleteInput = {
  id: Scalars['ID'],
};

/** Table Update Index Input */
export type IndexUpdateInput = {
  id: Scalars['ID'],
  type?: Maybe<TableIndexType>,
  columns?: Maybe<Array<TableIndexColumnInput>>,
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
};

export type IntPredicate = {
  equals?: Maybe<Scalars['Int']>,
  not_equals?: Maybe<Scalars['Int']>,
  in?: Maybe<Array<Scalars['Int']>>,
  not_in?: Maybe<Array<Scalars['Int']>>,
  lt?: Maybe<Scalars['Int']>,
  lte?: Maybe<Scalars['Int']>,
  gt?: Maybe<Scalars['Int']>,
  gte?: Maybe<Scalars['Int']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
};

export type IntPredicateHaving = {
  equals?: Maybe<Scalars['Int']>,
  not_equals?: Maybe<Scalars['Int']>,
  in?: Maybe<Array<Scalars['Int']>>,
  not_in?: Maybe<Array<Scalars['Int']>>,
  lt?: Maybe<Scalars['Int']>,
  lte?: Maybe<Scalars['Int']>,
  gt?: Maybe<Scalars['Int']>,
  gte?: Maybe<Scalars['Int']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<IntPredicateHaving>>,
  OR?: Maybe<Array<IntPredicateHaving>>,
};

export type IntrospectionQueryResponse = {
  __typename?: 'IntrospectionQueryResponse',
  url: Scalars['String'],
};

/** Invited By Name */
export type InvitedByName = {
  __typename?: 'InvitedByName',
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  workspaceName?: Maybe<Scalars['String']>,
  email?: Maybe<Scalars['String']>,
};

/** InviteMembersInput */
export type InviteMembersInput = {
  recipients: Array<InviteRecipientInput>,
};

/** InviteRecipientInput */
export type InviteRecipientInput = {
  email: Scalars['String'],
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  roles?: Maybe<Array<Scalars['ID']>>,
};

/** InvokeData */
export type InvokeData = {
  functionName: Scalars['String'],
  inputArgs?: Maybe<Scalars['String']>,
};

/** InvokeFunctionResponse */
export type InvokeFunctionResponse = {
  __typename?: 'InvokeFunctionResponse',
  responseData: Scalars['String'],
};


export type LocateFunctionArguments = {
  str: Scalars['String'],
  pos?: Maybe<Scalars['Int']>,
};

/** LoginResponse */
export type LoginResponse = {
  __typename?: 'LoginResponse',
  success?: Maybe<Scalars['Boolean']>,
  auth?: Maybe<Auth>,
  workspaces?: Maybe<Array<WorkspaceInfo>>,
};

/** Channel create input from members */
export type Members_ChannelCreateInput = {
  messages?: Maybe<ChannelMessagesRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

/** Channel update input from members */
export type Members_ChannelUpdateInput = {
  messages?: Maybe<ChannelMessagesUpdateRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersUpdateRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

export type Message = {
  __typename?: 'Message',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  channel?: Maybe<Channel>,
  text?: Maybe<Scalars['String']>,
  attachments?: Maybe<FileListResponse>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
  _description?: Maybe<Scalars['String']>,
};


export type MessageAttachmentsArgs = {
  filter?: Maybe<FileFilter>,
  orderBy?: Maybe<Array<Maybe<FileOrderBy>>>,
  sort?: Maybe<Array<FileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<FileGroupBy>
};

/** Files create input from message_attachments */
export type Message_Attachments_FileCreateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarRelationInput>,
};

/** Files update input from message_attachments */
export type Message_Attachments_FileUpdateInput = {
  filter?: Maybe<FileKeyFilter>,
  data: FileUpdateInput,
};

/** Message relation input */
export type MessageAttachmentsManyRelationInput = {
  connect?: Maybe<Array<FileKeyFilter>>,
};

/** Message relation input */
export type MessageAttachmentsRelationInput = {
  connect?: Maybe<Array<FileKeyFilter>>,
  create?: Maybe<Array<Maybe<Message_Attachments_FileCreateInput>>>,
};

/** Message relation input */
export type MessageAttachmentsUpdateRelationInput = {
  connect?: Maybe<Array<FileKeyFilter>>,
  disconnect?: Maybe<Array<FileKeyFilter>>,
  reconnect?: Maybe<Array<FileKeyFilter>>,
  create?: Maybe<Array<Maybe<Message_Attachments_FileCreateInput>>>,
  update?: Maybe<Array<Maybe<Message_Attachments_FileUpdateInput>>>,
};

/** Message relation input */
export type MessageChannelManyRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
};

/** Message relation input */
export type MessageChannelRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
  create?: Maybe<Messages_ChannelCreateInput>,
};

/** Message relation input */
export type MessageChannelUpdateRelationInput = {
  connect?: Maybe<ChannelKeyFilter>,
  disconnect?: Maybe<ChannelKeyFilter>,
  reconnect?: Maybe<ChannelKeyFilter>,
  create?: Maybe<Messages_ChannelCreateInput>,
  update?: Maybe<Messages_ChannelUpdateInput>,
};

/** Message create input */
export type MessageCreateInput = {
  channel?: Maybe<MessageChannelRelationInput>,
  text: Scalars['String'],
  attachments?: Maybe<MessageAttachmentsRelationInput>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
};

/** Message create many input */
export type MessageCreateManyInput = {
  channel: MessageChannelManyRelationInput,
  text: Scalars['String'],
  attachments?: Maybe<MessageAttachmentsManyRelationInput>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
};

/** Message delete input */
export type MessageDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** MessageFieldsPermissions create input */
export type MessageFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  text?: Maybe<Scalars['Boolean']>,
  parentID?: Maybe<Scalars['Boolean']>,
  isDeleted?: Maybe<Scalars['Boolean']>,
};

export type MessageFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  text?: Maybe<StringPredicate>,
  parentID?: Maybe<StringPredicate>,
  isDeleted?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  channel?: Maybe<ChannelFilter>,
  attachments?: Maybe<FileRelationFilter>,
  AND?: Maybe<Array<MessageFilter>>,
  OR?: Maybe<Array<MessageFilter>>,
};

export type MessageGroupBy = {
  query: MessageGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type MessageGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  text?: Maybe<Array<GroupByField>>,
  parentID?: Maybe<Array<GroupByField>>,
  isDeleted?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  channel?: Maybe<ChannelGroupByQuery>,
  attachments?: Maybe<FileGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type MessageKeyFilter = {
  id?: Maybe<Scalars['ID']>,
};

/** MessageListResponse output */
export type MessageListResponse = {
  __typename?: 'MessageListResponse',
  /** List items */
  items: Array<Message>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** MessageManyResponse output */
export type MessageManyResponse = {
  __typename?: 'MessageManyResponse',
  /** List items */
  items: Array<Message>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type MessageOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'text_ASC' |
  'text_DESC' |
  'parentID_ASC' |
  'parentID_DESC' |
  'isDeleted_ASC' |
  'isDeleted_DESC';

/** Message subscription payload */
export type MessagePayload = {
  __typename?: 'MessagePayload',
  mutation: MutationType,
  node?: Maybe<Message>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<Message>,
};

export type MessagePermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  text?: Maybe<StringPredicate>,
  parentID?: Maybe<StringPredicate>,
  isDeleted?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  channel?: Maybe<ChannelPermissionFilter>,
  attachments?: Maybe<FilePermissionRelationFilter>,
  AND?: Maybe<Array<MessagePermissionFilter>>,
  OR?: Maybe<Array<MessagePermissionFilter>>,
};

export type MessagePermissionRelationFilter = {
  some?: Maybe<MessagePermissionFilter>,
  every?: Maybe<MessagePermissionFilter>,
  none?: Maybe<MessagePermissionFilter>,
};

export type MessageRelationFilter = {
  some?: Maybe<MessageFilter>,
  every?: Maybe<MessageFilter>,
  none?: Maybe<MessageFilter>,
};

/** Channel create input from messages */
export type Messages_ChannelCreateInput = {
  messages?: Maybe<ChannelMessagesRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

/** Channel update input from messages */
export type Messages_ChannelUpdateInput = {
  messages?: Maybe<ChannelMessagesUpdateRelationInput>,
  purpose?: Maybe<Scalars['String']>,
  members?: Maybe<ChannelMembersUpdateRelationInput>,
  public?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  /** channel - A channel
   * 
   * im - Individual Messages (DM)
   * 
   * group - Multiple DM
 */
  type?: Maybe<Scalars['String']>,
};

export type MessageSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  text?: Maybe<SortOrder>,
  parentID?: Maybe<SortOrder>,
  isDeleted?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  channel?: Maybe<ChannelSort>,
};

/** Message subscription filter */
export type MessageSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<MessageFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Message update input */
export type MessageUpdateByFilterInput = {
  text?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  parentID?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  isDeleted?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
};

/** Message update input */
export type MessageUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  channel?: Maybe<MessageChannelUpdateRelationInput>,
  text?: Maybe<Scalars['String']>,
  attachments?: Maybe<MessageAttachmentsUpdateRelationInput>,
  parentID?: Maybe<Scalars['String']>,
  /** Temporary solution for be notified when message is deleted via subscriptions. */
  isDeleted?: Maybe<Scalars['Boolean']>,
};

/** MissingRelation */
export type MissingRelation = {
  __typename?: 'MissingRelation',
  table: Scalars['String'],
};

/** MissingRelation Field Attributes */
export type MissingRelationFieldTypeAttributes = {
  __typename?: 'MissingRelationFieldTypeAttributes',
  missingTable: Scalars['String'],
};

export type Mutation = {
  __typename?: 'Mutation',
  apiTokenCreate: ApiTokenResponse,
  apiTokenDelete?: Maybe<SuccessResponse>,
  apiTokenDestroy?: Maybe<SuccessResponse>,
  apiTokenRestore: ApiToken,
  apiTokenUpdate: ApiToken,
  apiTokenUpdateByFilter: ApiTokenManyResponse,
  applicationDelete?: Maybe<SuccessResponse>,
  applicationInstall?: Maybe<Application>,
  applicationUpdate?: Maybe<Application>,
  authenticationProfileCreate: AuthenticationProfile,
  authenticationProfileCreateMany: AuthenticationProfileManyResponse,
  authenticationProfileDelete?: Maybe<SuccessResponse>,
  authenticationProfileDestroy?: Maybe<SuccessResponse>,
  authenticationProfileRestore: AuthenticationProfile,
  authenticationProfileUpdate: AuthenticationProfile,
  authenticationProfileUpdateByFilter: AuthenticationProfileManyResponse,
  authenticationSettingsUpdate: AuthenticationSetting,
  billingDetailsUpdate?: Maybe<BillingDetailsResponse>,
  billingPlanUpdate?: Maybe<BillingCurrentPlanResponse>,
  channelCreate: Channel,
  channelCreateMany: ChannelManyResponse,
  channelDelete?: Maybe<SuccessResponse>,
  channelDestroy?: Maybe<SuccessResponse>,
  channelMemberCreate: ChannelMember,
  channelMemberCreateMany: ChannelMemberManyResponse,
  channelMemberDelete?: Maybe<SuccessResponse>,
  channelMemberDestroy?: Maybe<SuccessResponse>,
  channelMemberRestore: ChannelMember,
  channelMemberUpdate: ChannelMember,
  channelMemberUpdateByFilter: ChannelMemberManyResponse,
  channelRestore: Channel,
  channelUpdate: Channel,
  channelUpdateByFilter: ChannelManyResponse,
  deploy?: Maybe<Scalars['Boolean']>,
  environmentVariableCreate: EnvironmentVariable,
  environmentVariableCreateMany: EnvironmentVariableManyResponse,
  environmentVariableDelete?: Maybe<SuccessResponse>,
  environmentVariableDestroy?: Maybe<SuccessResponse>,
  environmentVariableRestore: EnvironmentVariable,
  environmentVariableUpdate: EnvironmentVariable,
  environmentVariableUpdateByFilter: EnvironmentVariableManyResponse,
  fieldCreate: TableField,
  fieldDelete: SuccessResponse,
  fieldUpdate: TableField,
  fieldUpdatePosition: SuccessResponse,
  fileCreate: File,
  fileCreateMany: FileManyResponse,
  fileDelete?: Maybe<SuccessResponse>,
  fileDestroy?: Maybe<SuccessResponse>,
  fileRestore: File,
  fileUpdate: File,
  fileUpdateByFilter: FileManyResponse,
  indexCreate: TableIndex,
  indexDelete?: Maybe<SuccessResponse>,
  indexUpdate: TableIndex,
  inviteMembers: Array<Maybe<TeamInvitation>>,
  invoke?: Maybe<InvokeFunctionResponse>,
  messageCreate: Message,
  messageCreateMany: MessageManyResponse,
  messageDelete?: Maybe<SuccessResponse>,
  messageDestroy?: Maybe<SuccessResponse>,
  messageRestore: Message,
  messageUpdate: Message,
  messageUpdateByFilter: MessageManyResponse,
  prepareDeploy: DeployDataResponse,
  roleCreate: Role,
  roleCreateMany: RoleManyResponse,
  roleDelete?: Maybe<SuccessResponse>,
  roleDestroy?: Maybe<SuccessResponse>,
  roleRestore: Role,
  roleUpdate: Role,
  roleUpdateByFilter: RoleManyResponse,
  sendInvitationTo8base?: Maybe<SuccessResponse>,
  settingsUpdate: Setting,
  system?: Maybe<SystemMutation>,
  tableCreate: Table,
  tableDelete: SuccessResponse,
  tableUpdate: Table,
  teamInvitationAccept: TeamInvitationAcceptResponse,
  teamInvitationCancel?: Maybe<SuccessResponse>,
  teamInvitationDelete?: Maybe<SuccessResponse>,
  teamInvitationDestroy?: Maybe<SuccessResponse>,
  teamInvitationResend?: Maybe<SuccessResponse>,
  teamInvitationRestore: TeamInvitation,
  teamMemberDelete?: Maybe<SuccessResponse>,
  teamMemberDestroy?: Maybe<SuccessResponse>,
  teamMemberRestore: TeamMember,
  teamMemberUpdate: TeamMember,
  teamMemberUpdateByFilter: TeamMemberManyResponse,
  userChangePassword?: Maybe<SuccessResponse>,
  userCreate: User,
  userCreateMany: UserManyResponse,
  userDelete?: Maybe<SuccessResponse>,
  userDestroy?: Maybe<SuccessResponse>,
  userLogin?: Maybe<LoginResponse>,
  userPasswordForgot?: Maybe<SuccessResponse>,
  userPasswordForgotConfirm?: Maybe<SuccessResponse>,
  userRefreshToken?: Maybe<Auth>,
  userRestore: User,
  userSignUp: User,
  userSignUpResend?: Maybe<SuccessResponse>,
  userSignUpWithPassword: User,
  userSignUpWithToken: User,
  userUpdate: User,
  userUpdateByFilter: UserManyResponse,
  userVerificationEmailResend?: Maybe<SuccessResponse>,
  viewCreate: Table,
  viewUpdate: Table,
  workspaceCreate?: Maybe<WorkspaceCreateResponse>,
  workspaceCreateAsync?: Maybe<WorkspaceCreateResponse>,
  workspaceDelete?: Maybe<SuccessResponse>,
  workspaceLeave?: Maybe<SuccessResponse>,
  workspaceUpdate?: Maybe<WorkspaceUpdateResponse>,
  findOrCreateDM?: Maybe<FindOrCreateDmResponse>,
};


export type MutationApiTokenCreateArgs = {
  data: ApiTokenCreateInput
};


export type MutationApiTokenDeleteArgs = {
  data?: Maybe<ApiTokenDeleteInput>,
  filter?: Maybe<ApiTokenKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationApiTokenDestroyArgs = {
  filter?: Maybe<ApiTokenKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationApiTokenRestoreArgs = {
  id: Scalars['String']
};


export type MutationApiTokenUpdateArgs = {
  data: ApiTokenUpdateInput,
  filter?: Maybe<ApiTokenKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationApiTokenUpdateByFilterArgs = {
  data: ApiTokenUpdateByFilterInput,
  filter?: Maybe<ApiTokenFilter>
};


export type MutationApplicationDeleteArgs = {
  data: ApplicationDeleteMutationInput
};


export type MutationApplicationInstallArgs = {
  data: ApplicationInstallInput
};


export type MutationApplicationUpdateArgs = {
  data: ApplicationUpdateInput
};


export type MutationAuthenticationProfileCreateArgs = {
  data: AuthenticationProfileCreateInput
};


export type MutationAuthenticationProfileCreateManyArgs = {
  data: Array<Maybe<AuthenticationProfileCreateManyInput>>
};


export type MutationAuthenticationProfileDeleteArgs = {
  data?: Maybe<AuthenticationProfileDeleteInput>,
  filter?: Maybe<AuthenticationProfileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationAuthenticationProfileDestroyArgs = {
  filter?: Maybe<AuthenticationProfileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationAuthenticationProfileRestoreArgs = {
  id: Scalars['String']
};


export type MutationAuthenticationProfileUpdateArgs = {
  data: AuthenticationProfileUpdateInput,
  filter?: Maybe<AuthenticationProfileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationAuthenticationProfileUpdateByFilterArgs = {
  data: AuthenticationProfileUpdateByFilterInput,
  filter?: Maybe<AuthenticationProfileFilter>
};


export type MutationAuthenticationSettingsUpdateArgs = {
  data: AuthenticationSettingUpdateInput
};


export type MutationBillingDetailsUpdateArgs = {
  data: BillingDetailsUpdateMutationInput
};


export type MutationBillingPlanUpdateArgs = {
  data: BillingPlanUpdateMutationInput
};


export type MutationChannelCreateArgs = {
  data: ChannelCreateInput
};


export type MutationChannelCreateManyArgs = {
  data: Array<Maybe<ChannelCreateManyInput>>
};


export type MutationChannelDeleteArgs = {
  data?: Maybe<ChannelDeleteInput>,
  filter?: Maybe<ChannelKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationChannelDestroyArgs = {
  filter?: Maybe<ChannelKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationChannelMemberCreateArgs = {
  data: ChannelMemberCreateInput
};


export type MutationChannelMemberCreateManyArgs = {
  data: Array<Maybe<ChannelMemberCreateManyInput>>
};


export type MutationChannelMemberDeleteArgs = {
  data?: Maybe<ChannelMemberDeleteInput>,
  filter?: Maybe<ChannelMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationChannelMemberDestroyArgs = {
  filter?: Maybe<ChannelMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationChannelMemberRestoreArgs = {
  id: Scalars['String']
};


export type MutationChannelMemberUpdateArgs = {
  data: ChannelMemberUpdateInput,
  filter?: Maybe<ChannelMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationChannelMemberUpdateByFilterArgs = {
  data: ChannelMemberUpdateByFilterInput,
  filter?: Maybe<ChannelMemberFilter>
};


export type MutationChannelRestoreArgs = {
  id: Scalars['String']
};


export type MutationChannelUpdateArgs = {
  data: ChannelUpdateInput,
  filter?: Maybe<ChannelKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationChannelUpdateByFilterArgs = {
  data: ChannelUpdateByFilterInput,
  filter?: Maybe<ChannelFilter>
};


export type MutationDeployArgs = {
  data?: Maybe<DeployingBuildInput>
};


export type MutationEnvironmentVariableCreateArgs = {
  data: EnvironmentVariableCreateInput
};


export type MutationEnvironmentVariableCreateManyArgs = {
  data: Array<Maybe<EnvironmentVariableCreateManyInput>>
};


export type MutationEnvironmentVariableDeleteArgs = {
  data?: Maybe<EnvironmentVariableDeleteInput>,
  filter?: Maybe<EnvironmentVariableKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationEnvironmentVariableDestroyArgs = {
  filter?: Maybe<EnvironmentVariableKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationEnvironmentVariableRestoreArgs = {
  id: Scalars['String']
};


export type MutationEnvironmentVariableUpdateArgs = {
  data: EnvironmentVariableUpdateInput,
  filter?: Maybe<EnvironmentVariableKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationEnvironmentVariableUpdateByFilterArgs = {
  data: EnvironmentVariableUpdateByFilterInput,
  filter?: Maybe<EnvironmentVariableFilter>
};


export type MutationFieldCreateArgs = {
  data: TableFieldCreateInput
};


export type MutationFieldDeleteArgs = {
  data: TableFieldDeleteInput
};


export type MutationFieldUpdateArgs = {
  data: TableFieldUpdateInput
};


export type MutationFieldUpdatePositionArgs = {
  data: TableFieldPositionUpdateInput
};


export type MutationFileCreateArgs = {
  data: FileCreateInput
};


export type MutationFileCreateManyArgs = {
  data: Array<Maybe<FileCreateManyInput>>
};


export type MutationFileDeleteArgs = {
  data?: Maybe<FileDeleteInput>,
  filter?: Maybe<FileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationFileDestroyArgs = {
  filter?: Maybe<FileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationFileRestoreArgs = {
  id: Scalars['String']
};


export type MutationFileUpdateArgs = {
  data: FileUpdateInput,
  filter?: Maybe<FileKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationFileUpdateByFilterArgs = {
  data: FileUpdateByFilterInput,
  filter?: Maybe<FileFilter>
};


export type MutationIndexCreateArgs = {
  data: IndexCreateInput
};


export type MutationIndexDeleteArgs = {
  data: IndexDeleteInput
};


export type MutationIndexUpdateArgs = {
  data: IndexUpdateInput
};


export type MutationInviteMembersArgs = {
  data: InviteMembersInput,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationInvokeArgs = {
  data?: Maybe<InvokeData>
};


export type MutationMessageCreateArgs = {
  data: MessageCreateInput
};


export type MutationMessageCreateManyArgs = {
  data: Array<Maybe<MessageCreateManyInput>>
};


export type MutationMessageDeleteArgs = {
  data?: Maybe<MessageDeleteInput>,
  filter?: Maybe<MessageKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationMessageDestroyArgs = {
  filter?: Maybe<MessageKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationMessageRestoreArgs = {
  id: Scalars['String']
};


export type MutationMessageUpdateArgs = {
  data: MessageUpdateInput,
  filter?: Maybe<MessageKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationMessageUpdateByFilterArgs = {
  data: MessageUpdateByFilterInput,
  filter?: Maybe<MessageFilter>
};


export type MutationRoleCreateArgs = {
  data: RoleCreateInput
};


export type MutationRoleCreateManyArgs = {
  data: Array<Maybe<RoleCreateManyInput>>
};


export type MutationRoleDeleteArgs = {
  data?: Maybe<RoleDeleteInput>,
  filter?: Maybe<RoleKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationRoleDestroyArgs = {
  filter?: Maybe<RoleKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationRoleRestoreArgs = {
  id: Scalars['String']
};


export type MutationRoleUpdateArgs = {
  data: RoleUpdateInput,
  filter?: Maybe<RoleKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationRoleUpdateByFilterArgs = {
  data: RoleUpdateByFilterInput,
  filter?: Maybe<RoleFilter>
};


export type MutationSendInvitationTo8baseArgs = {
  inviteEmail: Scalars['String']
};


export type MutationSettingsUpdateArgs = {
  data: SettingUpdateInput
};


export type MutationTableCreateArgs = {
  data: TableCreateInput
};


export type MutationTableDeleteArgs = {
  data: TableDeleteInput
};


export type MutationTableUpdateArgs = {
  data: TableUpdateInput
};


export type MutationTeamInvitationAcceptArgs = {
  data: TeamInvitationAcceptInput
};


export type MutationTeamInvitationCancelArgs = {
  data: TeamInvitationCancelInput
};


export type MutationTeamInvitationDeleteArgs = {
  data?: Maybe<TeamInvitationDeleteInput>,
  filter?: Maybe<TeamInvitationKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationTeamInvitationDestroyArgs = {
  filter?: Maybe<TeamInvitationKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationTeamInvitationResendArgs = {
  data: TeamInvitationResendInput
};


export type MutationTeamInvitationRestoreArgs = {
  id: Scalars['String']
};


export type MutationTeamMemberDeleteArgs = {
  data?: Maybe<TeamMemberDeleteInput>,
  filter?: Maybe<TeamMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationTeamMemberDestroyArgs = {
  filter?: Maybe<TeamMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationTeamMemberRestoreArgs = {
  id: Scalars['String']
};


export type MutationTeamMemberUpdateArgs = {
  data: TeamMemberUpdateInput,
  filter?: Maybe<TeamMemberKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationTeamMemberUpdateByFilterArgs = {
  data: TeamMemberUpdateByFilterInput,
  filter?: Maybe<TeamMemberFilter>
};


export type MutationUserChangePasswordArgs = {
  data: ChangePasswordInput
};


export type MutationUserCreateArgs = {
  data: UserCreateInput
};


export type MutationUserCreateManyArgs = {
  data: Array<Maybe<UserCreateManyInput>>
};


export type MutationUserDeleteArgs = {
  data?: Maybe<UserDeleteInput>,
  filter?: Maybe<UserKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationUserDestroyArgs = {
  filter?: Maybe<UserKeyFilter>,
  force?: Maybe<Scalars['Boolean']>
};


export type MutationUserLoginArgs = {
  data: UserLoginInput
};


export type MutationUserPasswordForgotArgs = {
  data: PasswordForgotInput
};


export type MutationUserPasswordForgotConfirmArgs = {
  data: PasswordForgotConfirmInput
};


export type MutationUserRefreshTokenArgs = {
  data: RefreshTokenInput
};


export type MutationUserRestoreArgs = {
  id: Scalars['String']
};


export type MutationUserSignUpArgs = {
  user: UserCreateInput,
  authProfileId?: Maybe<Scalars['ID']>
};


export type MutationUserSignUpResendArgs = {
  data: SignUpResendInput
};


export type MutationUserSignUpWithPasswordArgs = {
  user: UserCreateInput,
  password: Scalars['String'],
  authProfileId?: Maybe<Scalars['ID']>
};


export type MutationUserSignUpWithTokenArgs = {
  user: UserCreateInput,
  authProfileId?: Maybe<Scalars['ID']>
};


export type MutationUserUpdateArgs = {
  data: UserUpdateInput,
  filter?: Maybe<UserKeyFilter>,
  force?: Maybe<Scalars['Boolean']>,
  destroyDetached?: Maybe<Scalars['Boolean']>
};


export type MutationUserUpdateByFilterArgs = {
  data: UserUpdateByFilterInput,
  filter?: Maybe<UserFilter>
};


export type MutationUserVerificationEmailResendArgs = {
  data: VerificationEmailResendInput,
  authProfileId?: Maybe<Scalars['ID']>
};


export type MutationViewCreateArgs = {
  data: ViewCreateInput
};


export type MutationViewUpdateArgs = {
  data: ViewUpdateInput
};


export type MutationWorkspaceCreateArgs = {
  data: WorkspaceCreateMutationInput
};


export type MutationWorkspaceCreateAsyncArgs = {
  data: WorkspaceCreateMutationInput
};


export type MutationWorkspaceDeleteArgs = {
  data: WorkspaceDeleteMutationInput
};


export type MutationWorkspaceLeaveArgs = {
  force?: Maybe<Scalars['Boolean']>
};


export type MutationWorkspaceUpdateArgs = {
  data: WorkspaceUpdateMutationInput
};


export type MutationFindOrCreateDmArgs = {
  data: FindOrCreateDmInput
};

export type MutationType = 
  'create' |
  'update' |
  'delete' |
  'destroy';

/** Number Field Attributes */
export type NumberFieldTypeAttributes = {
  __typename?: 'NumberFieldTypeAttributes',
  format: Scalars['String'],
  precision?: Maybe<Scalars['Int']>,
  currency?: Maybe<Scalars['String']>,
  minValue?: Maybe<Scalars['Float']>,
  maxValue?: Maybe<Scalars['Float']>,
  isBigInt?: Maybe<Scalars['Boolean']>,
  autoIncrement?: Maybe<Scalars['Boolean']>,
};

/** Number Type Format Enum */
export type NumberTypeFormatEnum = 
  'NUMBER' |
  'CURRENCY' |
  'PERCENTAGE' |
  'FRACTION' |
  'SCIENTIFIC';

/** PasswordForgotConfirmInput */
export type PasswordForgotConfirmInput = {
  email: Scalars['String'],
  code: Scalars['String'],
  newPassword: Scalars['String'],
  authProfileId: Scalars['ID'],
};

/** PasswordForgotInput */
export type PasswordForgotInput = {
  email: Scalars['String'],
  authProfileId: Scalars['ID'],
};

export type PatternFunctionArguments = {
  pattern: Scalars['String'],
  escape?: Maybe<Scalars['String']>,
};

export type Permission = {
  __typename?: 'Permission',
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  createdBy?: Maybe<User>,
  appId?: Maybe<Scalars['String']>,
  resourceType?: Maybe<Scalars['String']>,
  resource?: Maybe<Scalars['String']>,
  permission?: Maybe<Scalars['JSON']>,
  role?: Maybe<Role>,
  _description?: Maybe<Scalars['String']>,
};

export type PermissionFilter = {
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  appId?: Maybe<StringPredicate>,
  resourceType?: Maybe<StringPredicate>,
  resource?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  role?: Maybe<RoleFilter>,
  AND?: Maybe<Array<PermissionFilter>>,
  OR?: Maybe<Array<PermissionFilter>>,
};

export type PermissionGroupByQuery = {
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  appId?: Maybe<Array<GroupByField>>,
  resourceType?: Maybe<Array<GroupByField>>,
  resource?: Maybe<Array<GroupByField>>,
  permission?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  role?: Maybe<RoleGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

/** Permission Filter */
export type PermissionInputFilter = {
  resourceType?: Maybe<PermissionResourceTypeEnum>,
  action?: Maybe<Scalars['String']>,
  resource?: Maybe<Scalars['String']>,
  applicationName?: Maybe<Scalars['String']>,
};

/** PermissionListResponse output */
export type PermissionListResponse = {
  __typename?: 'PermissionListResponse',
  /** List items */
  items: Array<Permission>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** Permissions subscription payload */
export type PermissionPayload = {
  __typename?: 'PermissionPayload',
  mutation: MutationType,
  node?: Maybe<Permission>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<Permission>,
};

export type PermissionPermissionFilter = {
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  appId?: Maybe<StringPredicate>,
  resourceType?: Maybe<StringPredicate>,
  resource?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  role?: Maybe<RolePermissionFilter>,
  AND?: Maybe<Array<PermissionPermissionFilter>>,
  OR?: Maybe<Array<PermissionPermissionFilter>>,
};

export type PermissionPermissionRelationFilter = {
  some?: Maybe<PermissionPermissionFilter>,
  every?: Maybe<PermissionPermissionFilter>,
  none?: Maybe<PermissionPermissionFilter>,
};

export type PermissionRelationFilter = {
  some?: Maybe<PermissionFilter>,
  every?: Maybe<PermissionFilter>,
  none?: Maybe<PermissionFilter>,
};

export type PermissionResourceTypeEnum = 
  'data' |
  'custom';

/** custom permissions input */
export type PermissionsCustom = {
  data?: Maybe<PermissionsCustomData>,
  logic?: Maybe<PermissionsCustomLogic>,
  api?: Maybe<PermissionsCustomApi>,
  users?: Maybe<PermissionsCustomUsers>,
  settings?: Maybe<PermissionsCustomSettings>,
};

export type PermissionsCustomApi = {
  findOrCreateDM?: Maybe<PermissionsCustomApiResolver>,
};

export type PermissionsCustomApiResolver = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomData = {
  schemaManagement?: Maybe<PermissionsCustomDataSchemaManagement>,
  viewerAccess?: Maybe<PermissionsCustomDataViewerAccess>,
};

export type PermissionsCustomDataSchemaManagement = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomDataViewerAccess = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomLogic = {
  view?: Maybe<PermissionsCustomLogicView>,
  deploy?: Maybe<PermissionsCustomLogicDeploy>,
  invoke?: Maybe<PermissionsCustomLogicInvoke>,
  logs?: Maybe<PermissionsCustomLogicLogs>,
};

export type PermissionsCustomLogicDeploy = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomLogicInvoke = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomLogicLogs = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomLogicView = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomSettings = {
  workspaceAdministration?: Maybe<PermissionsCustomSettingsWorkspaceAdministration>,
};

export type PermissionsCustomSettingsWorkspaceAdministration = {
  allow: Scalars['Boolean'],
};

export type PermissionsCustomUsers = {
  teamAdministration?: Maybe<PermissionsCustomUsersTeamAdministration>,
};

export type PermissionsCustomUsersTeamAdministration = {
  allow: Scalars['Boolean'],
};

/** Schema tables permissions input */
export type PermissionsData = {
  Users?: Maybe<PermissionsDataUsers>,
  Files?: Maybe<PermissionsDataFiles>,
  Roles?: Maybe<PermissionsDataRoles>,
  Message?: Maybe<PermissionsDataMessage>,
  Channel?: Maybe<PermissionsDataChannel>,
  ChannelMember?: Maybe<PermissionsDataChannelMember>,
};

export type PermissionsDataChannel = {
  create?: Maybe<PermissionsDataChannelCreate>,
  read?: Maybe<PermissionsDataChannelRead>,
  update?: Maybe<PermissionsDataChannelUpdate>,
  delete?: Maybe<PermissionsDataChannelDelete>,
  destroy?: Maybe<PermissionsDataChannelDestroy>,
};

export type PermissionsDataChannelCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataChannelDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataChannelDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataChannelMember = {
  create?: Maybe<PermissionsDataChannelMemberCreate>,
  read?: Maybe<PermissionsDataChannelMemberRead>,
  update?: Maybe<PermissionsDataChannelMemberUpdate>,
  delete?: Maybe<PermissionsDataChannelMemberDelete>,
  destroy?: Maybe<PermissionsDataChannelMemberDestroy>,
};

export type PermissionsDataChannelMemberCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataChannelMemberDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataChannelMemberDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataChannelMemberRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<ChannelMemberPermissionFilter>,
  fields?: Maybe<ChannelMemberFieldsPermissions>,
};

export type PermissionsDataChannelMemberUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<ChannelMemberPermissionFilter>,
  fields?: Maybe<ChannelMemberFieldsPermissions>,
};

export type PermissionsDataChannelRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<ChannelPermissionFilter>,
  fields?: Maybe<ChannelFieldsPermissions>,
};

export type PermissionsDataChannelUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<ChannelPermissionFilter>,
  fields?: Maybe<ChannelFieldsPermissions>,
};

export type PermissionsDataFiles = {
  create?: Maybe<PermissionsDataFilesCreate>,
  read?: Maybe<PermissionsDataFilesRead>,
  update?: Maybe<PermissionsDataFilesUpdate>,
  delete?: Maybe<PermissionsDataFilesDelete>,
  destroy?: Maybe<PermissionsDataFilesDestroy>,
};

export type PermissionsDataFilesCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataFilesDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataFilesDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataFilesRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<FilePermissionFilter>,
  fields?: Maybe<FileFieldsPermissions>,
};

export type PermissionsDataFilesUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<FilePermissionFilter>,
  fields?: Maybe<FileFieldsPermissions>,
};

export type PermissionsDataMessage = {
  create?: Maybe<PermissionsDataMessageCreate>,
  read?: Maybe<PermissionsDataMessageRead>,
  update?: Maybe<PermissionsDataMessageUpdate>,
  delete?: Maybe<PermissionsDataMessageDelete>,
  destroy?: Maybe<PermissionsDataMessageDestroy>,
};

export type PermissionsDataMessageCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataMessageDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataMessageDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataMessageRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<MessagePermissionFilter>,
  fields?: Maybe<MessageFieldsPermissions>,
};

export type PermissionsDataMessageUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<MessagePermissionFilter>,
  fields?: Maybe<MessageFieldsPermissions>,
};

export type PermissionsDataRoles = {
  create?: Maybe<PermissionsDataRolesCreate>,
  read?: Maybe<PermissionsDataRolesRead>,
  update?: Maybe<PermissionsDataRolesUpdate>,
  delete?: Maybe<PermissionsDataRolesDelete>,
  destroy?: Maybe<PermissionsDataRolesDestroy>,
};

export type PermissionsDataRolesCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataRolesDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataRolesDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataRolesRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<RolePermissionFilter>,
  fields?: Maybe<RoleFieldsPermissions>,
};

export type PermissionsDataRolesUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<RolePermissionFilter>,
  fields?: Maybe<RoleFieldsPermissions>,
};

export type PermissionsDataUsers = {
  create?: Maybe<PermissionsDataUsersCreate>,
  read?: Maybe<PermissionsDataUsersRead>,
  update?: Maybe<PermissionsDataUsersUpdate>,
  delete?: Maybe<PermissionsDataUsersDelete>,
  destroy?: Maybe<PermissionsDataUsersDestroy>,
};

export type PermissionsDataUsersCreate = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataUsersDelete = {
  allow: Scalars['Boolean'],
  restore?: Maybe<Scalars['Boolean']>,
  review?: Maybe<Scalars['Boolean']>,
};

export type PermissionsDataUsersDestroy = {
  allow: Scalars['Boolean'],
};

export type PermissionsDataUsersRead = {
  allow: Scalars['Boolean'],
  filter?: Maybe<UserPermissionFilter>,
  fields?: Maybe<UserFieldsPermissions>,
};

export type PermissionsDataUsersUpdate = {
  allow: Scalars['Boolean'],
  filter?: Maybe<UserPermissionFilter>,
  fields?: Maybe<UserFieldsPermissions>,
};

/** PermissionsInput create input */
export type PermissionsInput = {
  data?: Maybe<PermissionsData>,
  custom?: Maybe<PermissionsCustom>,
};

/** Permissions subscription filter */
export type PermissionSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<PermissionFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

export type Query = {
  __typename?: 'Query',
  apiToken?: Maybe<ApiToken>,
  apiTokensList: ApiTokenListResponse,
  application?: Maybe<Application>,
  applicationsList?: Maybe<ApplicationListResponse>,
  asyncSessionStatus?: Maybe<AsyncSessionStatusResponse>,
  authenticationProfile?: Maybe<AuthenticationProfile>,
  authenticationProfilesList: AuthenticationProfileListResponse,
  authenticationSettings?: Maybe<AuthenticationSetting>,
  billingCurrentPlan?: Maybe<BillingCurrentPlanResponse>,
  billingDetails?: Maybe<BillingDetailsResponse>,
  billingInvoicesList: BillingInvoicesListResponse,
  billingMetricUsageQuotasList: BillingMetricUsageQuotasListResponse,
  billingMetricUsagesList: BillingMetricUsagesListResponse,
  channel?: Maybe<Channel>,
  channelMember?: Maybe<ChannelMember>,
  channelMembersList: ChannelMemberListResponse,
  channelsList: ChannelListResponse,
  companyName?: Maybe<Scalars['String']>,
  deployStatus: DeployStatusResult,
  environmentVariable?: Maybe<EnvironmentVariable>,
  environmentVariablesList: EnvironmentVariableListResponse,
  file?: Maybe<File>,
  fileUploadInfo?: Maybe<FileUploadInfoResponse>,
  filesList: FileListResponse,
  functionsList?: Maybe<FunctionListResponse>,
  logs?: Maybe<Array<Maybe<Scalars['String']>>>,
  message?: Maybe<Message>,
  messagesList: MessageListResponse,
  role?: Maybe<Role>,
  rolesList: RoleListResponse,
  settings?: Maybe<Setting>,
  system?: Maybe<SystemQuery>,
  table?: Maybe<Table>,
  tableField?: Maybe<TableField>,
  tablesList: TableListResponse,
  teamInvitationDetails?: Maybe<TeamInvitationDetails>,
  teamInvitationsDetailsList?: Maybe<TeamInvitationsDetailsList>,
  teamMember?: Maybe<TeamMember>,
  teamMembersList: TeamMemberListResponse,
  user?: Maybe<User>,
  userBillingConfiguration: UserBillingConfigurationResponse,
  userInvitationsList?: Maybe<UserInvitationList>,
  usersList: UserListResponse,
  workspacesList?: Maybe<WorkspaceListResponse>,
};


export type QueryApiTokenArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryApiTokensListArgs = {
  filter?: Maybe<ApiTokenFilter>,
  orderBy?: Maybe<Array<Maybe<ApiTokenOrderBy>>>,
  sort?: Maybe<Array<ApiTokenSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ApiTokenGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryApplicationArgs = {
  id: Scalars['String']
};


export type QueryAsyncSessionStatusArgs = {
  sessionId: Scalars['String']
};


export type QueryAuthenticationProfileArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryAuthenticationProfilesListArgs = {
  filter?: Maybe<AuthenticationProfileFilter>,
  orderBy?: Maybe<Array<Maybe<AuthenticationProfileOrderBy>>>,
  sort?: Maybe<Array<AuthenticationProfileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<AuthenticationProfileGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryBillingInvoicesListArgs = {
  by?: Maybe<BillingInvoicesListFilterType>,
  limit?: Maybe<Scalars['Int']>,
  before?: Maybe<Scalars['ID']>,
  after?: Maybe<Scalars['ID']>
};


export type QueryBillingMetricUsagesListArgs = {
  filter?: Maybe<BillingMetricUsagesListFilter>
};


export type QueryChannelArgs = {
  id?: Maybe<Scalars['ID']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryChannelMemberArgs = {
  id?: Maybe<Scalars['ID']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryChannelMembersListArgs = {
  filter?: Maybe<ChannelMemberFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelMemberOrderBy>>>,
  sort?: Maybe<Array<ChannelMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelMemberGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryChannelsListArgs = {
  filter?: Maybe<ChannelFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelOrderBy>>>,
  sort?: Maybe<Array<ChannelSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryDeployStatusArgs = {
  buildName: Scalars['String']
};


export type QueryEnvironmentVariableArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryEnvironmentVariablesListArgs = {
  filter?: Maybe<EnvironmentVariableFilter>,
  orderBy?: Maybe<Array<Maybe<EnvironmentVariableOrderBy>>>,
  sort?: Maybe<Array<EnvironmentVariableSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<EnvironmentVariableGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryFileArgs = {
  id?: Maybe<Scalars['ID']>,
  fileId?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryFilesListArgs = {
  filter?: Maybe<FileFilter>,
  orderBy?: Maybe<Array<Maybe<FileOrderBy>>>,
  sort?: Maybe<Array<FileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<FileGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryFunctionsListArgs = {
  applicationId?: Maybe<Scalars['String']>,
  filter?: Maybe<FunctionInfoFilter>,
  orderBy?: Maybe<Array<Maybe<FunctionInfoOrderBy>>>
};


export type QueryLogsArgs = {
  functionName: Scalars['String'],
  applicationId?: Maybe<Scalars['String']>,
  limit?: Maybe<Scalars['Int']>,
  startTime?: Maybe<Scalars['DateTime']>,
  endTime?: Maybe<Scalars['DateTime']>
};


export type QueryMessageArgs = {
  id?: Maybe<Scalars['ID']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryMessagesListArgs = {
  filter?: Maybe<MessageFilter>,
  orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>,
  sort?: Maybe<Array<MessageSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<MessageGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryRoleArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryRolesListArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryTableArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>
};


export type QueryTableFieldArgs = {
  id: Scalars['ID']
};


export type QueryTablesListArgs = {
  filter?: Maybe<TableListFilter>
};


export type QueryTeamInvitationDetailsArgs = {
  uuid: Scalars['String']
};


export type QueryTeamMemberArgs = {
  id?: Maybe<Scalars['ID']>,
  userId?: Maybe<Scalars['ID']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryTeamMembersListArgs = {
  filter?: Maybe<TeamMemberFilter>,
  orderBy?: Maybe<Array<Maybe<TeamMemberOrderBy>>>,
  sort?: Maybe<Array<TeamMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamMemberGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryUserArgs = {
  id?: Maybe<Scalars['ID']>,
  email?: Maybe<Scalars['String']>,
  withDeleted?: Maybe<Scalars['Boolean']>
};


export type QueryUsersListArgs = {
  filter?: Maybe<UserFilter>,
  orderBy?: Maybe<Array<Maybe<UserOrderBy>>>,
  sort?: Maybe<Array<UserSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<UserGroupBy>,
  withDeleted?: Maybe<Scalars['Boolean']>
};

/** RefreshTokenInput */
export type RefreshTokenInput = {
  email?: Maybe<Scalars['String']>,
  refreshToken: Scalars['String'],
  authProfileId?: Maybe<Scalars['ID']>,
};

/** Relation */
export type Relation = {
  __typename?: 'Relation',
  refTable: Table,
  refField?: Maybe<TableField>,
  relationTableName?: Maybe<Scalars['String']>,
  relationFieldName?: Maybe<Scalars['String']>,
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList?: Maybe<Scalars['Boolean']>,
  refFieldIsRequired?: Maybe<Scalars['Boolean']>,
};

/** Relation Create Input */
export type RelationCreateInput = {
  refTableId: Scalars['ID'],
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList: Scalars['Boolean'],
  refFieldIsRequired: Scalars['Boolean'],
};

/** Relation Update Input */
export type RelationUpdateInput = {
  refTableId?: Maybe<Scalars['ID']>,
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList?: Maybe<Scalars['Boolean']>,
  refFieldIsRequired?: Maybe<Scalars['Boolean']>,
};

export type ReplaceFunctionArguments = {
  from: Scalars['String'],
  to: Scalars['String'],
};

export type Role = {
  __typename?: 'Role',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  name?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  users?: Maybe<UserListResponse>,
  apiTokens?: Maybe<ApiTokenListResponse>,
  authenticationProfiles?: Maybe<AuthenticationProfileListResponse>,
  teamMembers?: Maybe<TeamMemberListResponse>,
  permissions?: Maybe<PermissionListResponse>,
  _description?: Maybe<Scalars['String']>,
};


export type RoleUsersArgs = {
  filter?: Maybe<UserFilter>,
  orderBy?: Maybe<Array<Maybe<UserOrderBy>>>,
  sort?: Maybe<Array<UserSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<UserGroupBy>
};


export type RoleApiTokensArgs = {
  filter?: Maybe<ApiTokenFilter>,
  orderBy?: Maybe<Array<Maybe<ApiTokenOrderBy>>>,
  sort?: Maybe<Array<ApiTokenSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ApiTokenGroupBy>
};


export type RoleAuthenticationProfilesArgs = {
  filter?: Maybe<AuthenticationProfileFilter>,
  orderBy?: Maybe<Array<Maybe<AuthenticationProfileOrderBy>>>,
  sort?: Maybe<Array<AuthenticationProfileSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<AuthenticationProfileGroupBy>
};


export type RoleTeamMembersArgs = {
  filter?: Maybe<TeamMemberFilter>,
  orderBy?: Maybe<Array<Maybe<TeamMemberOrderBy>>>,
  sort?: Maybe<Array<TeamMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamMemberGroupBy>
};


export type RolePermissionsArgs = {
  filter?: Maybe<PermissionInputFilter>
};

/** Roles create input */
export type RoleCreateInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersRelationInput>,
};

/** Roles create many input */
export type RoleCreateManyInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersManyRelationInput>,
  apiTokens?: Maybe<RolesApiTokensManyRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesManyRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersManyRelationInput>,
};

/** Roles delete input */
export type RoleDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** RoleFieldsPermissions create input */
export type RoleFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['Boolean']>,
  description?: Maybe<Scalars['Boolean']>,
};

export type RoleFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  description?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  users?: Maybe<UserRelationFilter>,
  permissions?: Maybe<PermissionRelationFilter>,
  apiTokens?: Maybe<ApiTokenRelationFilter>,
  authenticationProfiles?: Maybe<AuthenticationProfileRelationFilter>,
  teamMembers?: Maybe<TeamMemberRelationFilter>,
  AND?: Maybe<Array<RoleFilter>>,
  OR?: Maybe<Array<RoleFilter>>,
};

export type RoleGroupBy = {
  query: RoleGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type RoleGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  name?: Maybe<Array<GroupByField>>,
  description?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  users?: Maybe<UserGroupByQuery>,
  permissions?: Maybe<PermissionGroupByQuery>,
  apiTokens?: Maybe<ApiTokenGroupByQuery>,
  authenticationProfiles?: Maybe<AuthenticationProfileGroupByQuery>,
  teamMembers?: Maybe<TeamMemberGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type RoleKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** RoleListResponse output */
export type RoleListResponse = {
  __typename?: 'RoleListResponse',
  /** List items */
  items: Array<Role>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** RoleManyResponse output */
export type RoleManyResponse = {
  __typename?: 'RoleManyResponse',
  /** List items */
  items: Array<Role>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type RoleOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'name_ASC' |
  'name_DESC' |
  'description_ASC' |
  'description_DESC' |
  'systemType_ASC' |
  'systemType_DESC';

/** Roles subscription payload */
export type RolePayload = {
  __typename?: 'RolePayload',
  mutation: MutationType,
  node?: Maybe<Role>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<Role>,
};

export type RolePermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  name?: Maybe<StringPredicate>,
  description?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  users?: Maybe<UserPermissionRelationFilter>,
  permissions?: Maybe<PermissionPermissionRelationFilter>,
  apiTokens?: Maybe<ApiTokenPermissionRelationFilter>,
  authenticationProfiles?: Maybe<AuthenticationProfilePermissionRelationFilter>,
  teamMembers?: Maybe<TeamMemberPermissionRelationFilter>,
  AND?: Maybe<Array<RolePermissionFilter>>,
  OR?: Maybe<Array<RolePermissionFilter>>,
};

export type RolePermissionRelationFilter = {
  some?: Maybe<RolePermissionFilter>,
  every?: Maybe<RolePermissionFilter>,
  none?: Maybe<RolePermissionFilter>,
};

export type RoleRelationFilter = {
  some?: Maybe<RoleFilter>,
  every?: Maybe<RoleFilter>,
  none?: Maybe<RoleFilter>,
};

/** ApiTokens update input from roles */
export type Roles_ApiTokenUpdateInput = {
  filter?: Maybe<ApiTokenKeyFilter>,
  data: ApiTokenUpdateInput,
};

/** AuthenticationProfiles create input from roles */
export type Roles_AuthenticationProfileCreateInput = {
  name: Scalars['String'],
  type?: Maybe<Scalars['String']>,
  secret?: Maybe<Scalars['String']>,
  managementDomain?: Maybe<Scalars['String']>,
  clientId?: Maybe<Scalars['String']>,
  databaseName?: Maybe<Scalars['String']>,
  domain?: Maybe<Scalars['String']>,
  selfSignUpEnabled?: Maybe<Scalars['Boolean']>,
  selfSignUpEmailDomains?: Maybe<Array<Maybe<Scalars['String']>>>,
  roles?: Maybe<AuthenticationProfilesRolesRelationInput>,
  audiences?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** AuthenticationProfiles update input from roles */
export type Roles_AuthenticationProfileUpdateInput = {
  filter?: Maybe<AuthenticationProfileKeyFilter>,
  data: AuthenticationProfileUpdateInput,
};

/** TeamMembers update input from roles */
export type Roles_TeamMemberUpdateInput = {
  filter?: Maybe<TeamMemberKeyFilter>,
  data: TeamMemberUpdateInput,
};

/** Users create input from roles */
export type Roles_UserCreateInput = {
  email: Scalars['String'],
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarRelationInput>,
  roles?: Maybe<UsersRolesRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesRelationInput>,
};

/** Users update input from roles */
export type Roles_UserUpdateInput = {
  filter?: Maybe<UserKeyFilter>,
  data: UserUpdateInput,
};

/** Roles relation input */
export type RolesApiTokensManyRelationInput = {
  connect?: Maybe<Array<ApiTokenKeyFilter>>,
};

/** Roles relation input */
export type RolesApiTokensRelationInput = {
  connect?: Maybe<Array<ApiTokenKeyFilter>>,
};

/** Roles relation input */
export type RolesApiTokensUpdateRelationInput = {
  connect?: Maybe<Array<ApiTokenKeyFilter>>,
  disconnect?: Maybe<Array<ApiTokenKeyFilter>>,
  reconnect?: Maybe<Array<ApiTokenKeyFilter>>,
  update?: Maybe<Array<Maybe<Roles_ApiTokenUpdateInput>>>,
};

/** Roles relation input */
export type RolesAuthenticationProfilesManyRelationInput = {
  connect?: Maybe<Array<AuthenticationProfileKeyFilter>>,
};

/** Roles relation input */
export type RolesAuthenticationProfilesRelationInput = {
  connect?: Maybe<Array<AuthenticationProfileKeyFilter>>,
  create?: Maybe<Array<Maybe<Roles_AuthenticationProfileCreateInput>>>,
};

/** Roles relation input */
export type RolesAuthenticationProfilesUpdateRelationInput = {
  connect?: Maybe<Array<AuthenticationProfileKeyFilter>>,
  disconnect?: Maybe<Array<AuthenticationProfileKeyFilter>>,
  reconnect?: Maybe<Array<AuthenticationProfileKeyFilter>>,
  create?: Maybe<Array<Maybe<Roles_AuthenticationProfileCreateInput>>>,
  update?: Maybe<Array<Maybe<Roles_AuthenticationProfileUpdateInput>>>,
};

export type RoleSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  name?: Maybe<SortOrder>,
  description?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
};

/** Roles relation input */
export type RolesTeamMembersManyRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
};

/** Roles relation input */
export type RolesTeamMembersRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
};

/** Roles relation input */
export type RolesTeamMembersUpdateRelationInput = {
  connect?: Maybe<Array<TeamMemberKeyFilter>>,
  disconnect?: Maybe<Array<TeamMemberKeyFilter>>,
  reconnect?: Maybe<Array<TeamMemberKeyFilter>>,
  update?: Maybe<Array<Maybe<Roles_TeamMemberUpdateInput>>>,
};

/** Roles subscription filter */
export type RoleSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<RoleFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Roles relation input */
export type RolesUsersManyRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
};

/** Roles relation input */
export type RolesUsersRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
  create?: Maybe<Array<Maybe<Roles_UserCreateInput>>>,
};

/** Roles relation input */
export type RolesUsersUpdateRelationInput = {
  connect?: Maybe<Array<UserKeyFilter>>,
  disconnect?: Maybe<Array<UserKeyFilter>>,
  reconnect?: Maybe<Array<UserKeyFilter>>,
  create?: Maybe<Array<Maybe<Roles_UserCreateInput>>>,
  update?: Maybe<Array<Maybe<Roles_UserUpdateInput>>>,
};

/** Roles update input */
export type RoleUpdateByFilterInput = {
  name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  description?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  systemType?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
};

/** Roles update input */
export type RoleUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersUpdateRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensUpdateRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesUpdateRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersUpdateRelationInput>,
};

/** Schema Origin */
export type SchemaOrigin = {
  __typename?: 'SchemaOrigin',
  type: SchemaOriginType,
  provider?: Maybe<Scalars['String']>,
};

/** Schema Origin Type Enum */
export type SchemaOriginType = 
  'REMOTE' |
  'LOCAL' |
  'VIEW';

export type Setting = {
  __typename?: 'Setting',
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  createdBy?: Maybe<User>,
  passwordMinLength?: Maybe<Scalars['Int']>,
  passwordRequireNumbers?: Maybe<Scalars['Boolean']>,
  passwordRequireSpecial?: Maybe<Scalars['Boolean']>,
  passwordRequireUppercase?: Maybe<Scalars['Boolean']>,
  passwordRequireLowercase?: Maybe<Scalars['Boolean']>,
  passwordUpdateInterval?: Maybe<Scalars['Int']>,
  rememberDevice?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  dateFormat?: Maybe<Scalars['String']>,
  currency?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  menuBarLogo?: Maybe<File>,
  landingPageImage?: Maybe<File>,
  vanityUrl?: Maybe<Scalars['String']>,
  buttonLinkColor?: Maybe<Scalars['String']>,
  userInterfaceStyle?: Maybe<Scalars['String']>,
  menuBarBGColor?: Maybe<Scalars['String']>,
  menuBarIconsColor?: Maybe<Scalars['String']>,
  bgColor?: Maybe<Scalars['String']>,
  containerColor?: Maybe<Scalars['String']>,
  leftNavColor?: Maybe<Scalars['String']>,
  _description?: Maybe<Scalars['String']>,
};

export type SettingFilter = {
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  passwordMinLength?: Maybe<IntPredicate>,
  passwordRequireNumbers?: Maybe<BoolPredicate>,
  passwordRequireSpecial?: Maybe<BoolPredicate>,
  passwordRequireUppercase?: Maybe<BoolPredicate>,
  passwordRequireLowercase?: Maybe<BoolPredicate>,
  passwordUpdateInterval?: Maybe<IntPredicate>,
  rememberDevice?: Maybe<StringPredicate>,
  language?: Maybe<StringPredicate>,
  dateFormat?: Maybe<StringPredicate>,
  currency?: Maybe<StringPredicate>,
  timezone?: Maybe<StringPredicate>,
  vanityUrl?: Maybe<StringPredicate>,
  buttonLinkColor?: Maybe<StringPredicate>,
  userInterfaceStyle?: Maybe<StringPredicate>,
  menuBarBGColor?: Maybe<StringPredicate>,
  menuBarIconsColor?: Maybe<StringPredicate>,
  bgColor?: Maybe<StringPredicate>,
  containerColor?: Maybe<StringPredicate>,
  leftNavColor?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  menuBarLogo?: Maybe<FileFilter>,
  landingPageImage?: Maybe<FileFilter>,
  AND?: Maybe<Array<SettingFilter>>,
  OR?: Maybe<Array<SettingFilter>>,
};

export type SettingGroupBy = {
  query: SettingGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type SettingGroupByQuery = {
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  passwordMinLength?: Maybe<Array<GroupByField>>,
  passwordRequireNumbers?: Maybe<Array<GroupByField>>,
  passwordRequireSpecial?: Maybe<Array<GroupByField>>,
  passwordRequireUppercase?: Maybe<Array<GroupByField>>,
  passwordRequireLowercase?: Maybe<Array<GroupByField>>,
  passwordUpdateInterval?: Maybe<Array<GroupByField>>,
  rememberDevice?: Maybe<Array<GroupByField>>,
  language?: Maybe<Array<GroupByField>>,
  dateFormat?: Maybe<Array<GroupByField>>,
  currency?: Maybe<Array<GroupByField>>,
  timezone?: Maybe<Array<GroupByField>>,
  vanityUrl?: Maybe<Array<GroupByField>>,
  buttonLinkColor?: Maybe<Array<GroupByField>>,
  userInterfaceStyle?: Maybe<Array<GroupByField>>,
  menuBarBGColor?: Maybe<Array<GroupByField>>,
  menuBarIconsColor?: Maybe<Array<GroupByField>>,
  bgColor?: Maybe<Array<GroupByField>>,
  containerColor?: Maybe<Array<GroupByField>>,
  leftNavColor?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  menuBarLogo?: Maybe<FileGroupByQuery>,
  landingPageImage?: Maybe<FileGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

/** SettingListResponse output */
export type SettingListResponse = {
  __typename?: 'SettingListResponse',
  /** List items */
  items: Array<Setting>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** No longer supported. Use `sort` instead. */
export type SettingOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'passwordMinLength_ASC' |
  'passwordMinLength_DESC' |
  'passwordRequireNumbers_ASC' |
  'passwordRequireNumbers_DESC' |
  'passwordRequireSpecial_ASC' |
  'passwordRequireSpecial_DESC' |
  'passwordRequireUppercase_ASC' |
  'passwordRequireUppercase_DESC' |
  'passwordRequireLowercase_ASC' |
  'passwordRequireLowercase_DESC' |
  'passwordUpdateInterval_ASC' |
  'passwordUpdateInterval_DESC' |
  'rememberDevice_ASC' |
  'rememberDevice_DESC' |
  'language_ASC' |
  'language_DESC' |
  'dateFormat_ASC' |
  'dateFormat_DESC' |
  'currency_ASC' |
  'currency_DESC' |
  'timezone_ASC' |
  'timezone_DESC' |
  'vanityUrl_ASC' |
  'vanityUrl_DESC' |
  'buttonLinkColor_ASC' |
  'buttonLinkColor_DESC' |
  'userInterfaceStyle_ASC' |
  'userInterfaceStyle_DESC' |
  'menuBarBGColor_ASC' |
  'menuBarBGColor_DESC' |
  'menuBarIconsColor_ASC' |
  'menuBarIconsColor_DESC' |
  'bgColor_ASC' |
  'bgColor_DESC' |
  'containerColor_ASC' |
  'containerColor_DESC' |
  'leftNavColor_ASC' |
  'leftNavColor_DESC';

/** Settings subscription payload */
export type SettingPayload = {
  __typename?: 'SettingPayload',
  mutation: MutationType,
  node?: Maybe<Setting>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<Setting>,
};

export type SettingPermissionFilter = {
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  passwordMinLength?: Maybe<IntPredicate>,
  passwordRequireNumbers?: Maybe<BoolPredicate>,
  passwordRequireSpecial?: Maybe<BoolPredicate>,
  passwordRequireUppercase?: Maybe<BoolPredicate>,
  passwordRequireLowercase?: Maybe<BoolPredicate>,
  passwordUpdateInterval?: Maybe<IntPredicate>,
  rememberDevice?: Maybe<StringPredicate>,
  language?: Maybe<StringPredicate>,
  dateFormat?: Maybe<StringPredicate>,
  currency?: Maybe<StringPredicate>,
  timezone?: Maybe<StringPredicate>,
  vanityUrl?: Maybe<StringPredicate>,
  buttonLinkColor?: Maybe<StringPredicate>,
  userInterfaceStyle?: Maybe<StringPredicate>,
  menuBarBGColor?: Maybe<StringPredicate>,
  menuBarIconsColor?: Maybe<StringPredicate>,
  bgColor?: Maybe<StringPredicate>,
  containerColor?: Maybe<StringPredicate>,
  leftNavColor?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  menuBarLogo?: Maybe<FilePermissionFilter>,
  landingPageImage?: Maybe<FilePermissionFilter>,
  AND?: Maybe<Array<SettingPermissionFilter>>,
  OR?: Maybe<Array<SettingPermissionFilter>>,
};

export type SettingPermissionRelationFilter = {
  some?: Maybe<SettingPermissionFilter>,
  every?: Maybe<SettingPermissionFilter>,
  none?: Maybe<SettingPermissionFilter>,
};

export type SettingRelationFilter = {
  some?: Maybe<SettingFilter>,
  every?: Maybe<SettingFilter>,
  none?: Maybe<SettingFilter>,
};

export type SettingSort = {
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  passwordMinLength?: Maybe<SortOrder>,
  passwordRequireNumbers?: Maybe<SortOrder>,
  passwordRequireSpecial?: Maybe<SortOrder>,
  passwordRequireUppercase?: Maybe<SortOrder>,
  passwordRequireLowercase?: Maybe<SortOrder>,
  passwordUpdateInterval?: Maybe<SortOrder>,
  rememberDevice?: Maybe<SortOrder>,
  language?: Maybe<SortOrder>,
  dateFormat?: Maybe<SortOrder>,
  currency?: Maybe<SortOrder>,
  timezone?: Maybe<SortOrder>,
  vanityUrl?: Maybe<SortOrder>,
  buttonLinkColor?: Maybe<SortOrder>,
  userInterfaceStyle?: Maybe<SortOrder>,
  menuBarBGColor?: Maybe<SortOrder>,
  menuBarIconsColor?: Maybe<SortOrder>,
  bgColor?: Maybe<SortOrder>,
  containerColor?: Maybe<SortOrder>,
  leftNavColor?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  menuBarLogo?: Maybe<FileSort>,
  landingPageImage?: Maybe<FileSort>,
};

/** Settings subscription filter */
export type SettingSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<SettingFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Settings update input */
export type SettingUpdateInput = {
  passwordMinLength?: Maybe<Scalars['Int']>,
  passwordRequireNumbers?: Maybe<Scalars['Boolean']>,
  passwordRequireSpecial?: Maybe<Scalars['Boolean']>,
  passwordRequireUppercase?: Maybe<Scalars['Boolean']>,
  passwordRequireLowercase?: Maybe<Scalars['Boolean']>,
  passwordUpdateInterval?: Maybe<Scalars['Int']>,
  rememberDevice?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  dateFormat?: Maybe<Scalars['String']>,
  currency?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  vanityUrl?: Maybe<Scalars['String']>,
  buttonLinkColor?: Maybe<Scalars['String']>,
  userInterfaceStyle?: Maybe<Scalars['String']>,
  menuBarBGColor?: Maybe<Scalars['String']>,
  menuBarIconsColor?: Maybe<Scalars['String']>,
  bgColor?: Maybe<Scalars['String']>,
  containerColor?: Maybe<Scalars['String']>,
  leftNavColor?: Maybe<Scalars['String']>,
};

/** SignUpResendInput */
export type SignUpResendInput = {
  email: Scalars['String'],
};

/** Smart Field Attributes */
export type SmartFieldTypeAttributes = {
  __typename?: 'SmartFieldTypeAttributes',
  format: Scalars['String'],
  innerFields?: Maybe<Array<Maybe<CustomTableField>>>,
};

/** Smart Type Format Enum */
export type SmartTypeFormatEnum = 
  'ADDRESS' |
  'PHONE';

/** SortOrder */
export type SortOrder = 
  'ASC' |
  'DESC';

export type StringPadFunctionArguments = {
  len: Scalars['Int'],
  str: Scalars['String'],
};

export type StringPredicate = {
  equals?: Maybe<Scalars['String']>,
  not_equals?: Maybe<Scalars['String']>,
  in?: Maybe<Array<Scalars['String']>>,
  not_in?: Maybe<Array<Scalars['String']>>,
  contains?: Maybe<Scalars['String']>,
  not_contains?: Maybe<Scalars['String']>,
  starts_with?: Maybe<Scalars['String']>,
  not_starts_with?: Maybe<Scalars['String']>,
  ends_with?: Maybe<Scalars['String']>,
  not_ends_with?: Maybe<Scalars['String']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
};

export type StringPredicateHaving = {
  equals?: Maybe<Scalars['String']>,
  not_equals?: Maybe<Scalars['String']>,
  in?: Maybe<Array<Scalars['String']>>,
  not_in?: Maybe<Array<Scalars['String']>>,
  contains?: Maybe<Scalars['String']>,
  not_contains?: Maybe<Scalars['String']>,
  starts_with?: Maybe<Scalars['String']>,
  not_starts_with?: Maybe<Scalars['String']>,
  ends_with?: Maybe<Scalars['String']>,
  not_ends_with?: Maybe<Scalars['String']>,
  is_empty?: Maybe<Scalars['Boolean']>,
  is_not_empty?: Maybe<Scalars['Boolean']>,
  AND?: Maybe<Array<StringPredicateHaving>>,
  OR?: Maybe<Array<StringPredicateHaving>>,
};

export type StringTrimMode = 
  'BOTH' |
  'LEADING' |
  'TRAILING';

export type Subscription = {
  __typename?: 'Subscription',
  ApiTokens?: Maybe<ApiTokenPayload>,
  AuthenticationProfiles?: Maybe<AuthenticationProfilePayload>,
  AuthenticationSettings?: Maybe<AuthenticationSettingPayload>,
  Channel?: Maybe<ChannelPayload>,
  ChannelMember?: Maybe<ChannelMemberPayload>,
  EnvironmentVariables?: Maybe<EnvironmentVariablePayload>,
  Files?: Maybe<FilePayload>,
  Message?: Maybe<MessagePayload>,
  Permissions?: Maybe<PermissionPayload>,
  Roles?: Maybe<RolePayload>,
  Settings?: Maybe<SettingPayload>,
  TeamInvitations?: Maybe<TeamInvitationPayload>,
  TeamMembers?: Maybe<TeamMemberPayload>,
  Users?: Maybe<UserPayload>,
};


export type SubscriptionApiTokensArgs = {
  filter?: Maybe<ApiTokenSubscriptionFilter>
};


export type SubscriptionAuthenticationProfilesArgs = {
  filter?: Maybe<AuthenticationProfileSubscriptionFilter>
};


export type SubscriptionAuthenticationSettingsArgs = {
  filter?: Maybe<AuthenticationSettingSubscriptionFilter>
};


export type SubscriptionChannelArgs = {
  filter?: Maybe<ChannelSubscriptionFilter>
};


export type SubscriptionChannelMemberArgs = {
  filter?: Maybe<ChannelMemberSubscriptionFilter>
};


export type SubscriptionEnvironmentVariablesArgs = {
  filter?: Maybe<EnvironmentVariableSubscriptionFilter>
};


export type SubscriptionFilesArgs = {
  filter?: Maybe<FileSubscriptionFilter>
};


export type SubscriptionMessageArgs = {
  filter?: Maybe<MessageSubscriptionFilter>
};


export type SubscriptionPermissionsArgs = {
  filter?: Maybe<PermissionSubscriptionFilter>
};


export type SubscriptionRolesArgs = {
  filter?: Maybe<RoleSubscriptionFilter>
};


export type SubscriptionSettingsArgs = {
  filter?: Maybe<SettingSubscriptionFilter>
};


export type SubscriptionTeamInvitationsArgs = {
  filter?: Maybe<TeamInvitationSubscriptionFilter>
};


export type SubscriptionTeamMembersArgs = {
  filter?: Maybe<TeamMemberSubscriptionFilter>
};


export type SubscriptionUsersArgs = {
  filter?: Maybe<UserSubscriptionFilter>
};

export type SubstringFunctionArguments = {
  pos: Scalars['Int'],
  len?: Maybe<Scalars['Int']>,
};

export type SuccessResponse = {
  __typename?: 'SuccessResponse',
  success?: Maybe<Scalars['Boolean']>,
};

/** Switch Field Attributes */
export type SwitchFieldTypeAttributes = {
  __typename?: 'SwitchFieldTypeAttributes',
  format: Scalars['String'],
  listOptions?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** Switch Type Format Enum */
export type SwitchTypeFormatEnum = 
  'ON_OFF' |
  'YES_NO' |
  'TRUE_FALSE' |
  'ACTIVE_INACTIVE' |
  'HIGH_LOW' |
  'CUSTOM';

/** Application */
export type SystemApplication = {
  __typename?: 'SystemApplication',
  id: Scalars['ID'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  createdAt: Scalars['DateTime'],
  appType: Scalars['String'],
  status: SystemApplicationStatusEnum,
};

/** ApplicationDeleteMutationInput */
export type SystemApplicationDeleteMutationInput = {
  id: Scalars['String'],
  force?: Maybe<Scalars['Boolean']>,
};

/** Application install input */
export type SystemApplicationInstallInput = {
  appType: Scalars['String'],
  name: Scalars['String'],
  status?: Maybe<SystemApplicationStatusEnum>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** SystemApplicationListResponse output */
export type SystemApplicationListResponse = {
  __typename?: 'SystemApplicationListResponse',
  /** List items */
  items: Array<SystemApplication>,
  /** List items count */
  count: Scalars['Int'],
};

/** Application Status Enum */
export type SystemApplicationStatusEnum = 
  'ACTIVE' |
  'INACTIVE';

/** Application update input */
export type SystemApplicationUpdateInput = {
  id: Scalars['String'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  status?: Maybe<SystemApplicationStatusEnum>,
};

export type SystemBillingCurrentPlanResponse = {
  __typename?: 'SystemBillingCurrentPlanResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  displayName?: Maybe<Scalars['String']>,
  trialEnd?: Maybe<Scalars['DateTime']>,
  status?: Maybe<SystemWorkspaceStatus>,
  nextPlan?: Maybe<SystemBillingNextPlanResponse>,
};

export type SystemBillingDetailsResponse = {
  __typename?: 'SystemBillingDetailsResponse',
  last4?: Maybe<Scalars['String']>,
  expMonth?: Maybe<Scalars['Int']>,
  expYear?: Maybe<Scalars['Int']>,
  brand?: Maybe<Scalars['String']>,
};

/** BillingDetailsUpdateMutationInput */
export type SystemBillingDetailsUpdateMutationInput = {
  cardToken: Scalars['String'],
};

export type SystemBillingInvoiceItem = {
  __typename?: 'SystemBillingInvoiceItem',
  id: Scalars['ID'],
  periodStart?: Maybe<Scalars['DateTime']>,
  periodEnd?: Maybe<Scalars['DateTime']>,
  paid?: Maybe<Scalars['Boolean']>,
  invoicePdf?: Maybe<Scalars['String']>,
  amountDue?: Maybe<Scalars['Float']>,
  amountPaid?: Maybe<Scalars['Float']>,
  amountRemaining?: Maybe<Scalars['Float']>,
  endingBalance?: Maybe<Scalars['Float']>,
  number?: Maybe<Scalars['String']>,
  status?: Maybe<Scalars['String']>,
  total?: Maybe<Scalars['Float']>,
  description?: Maybe<Scalars['String']>,
};

export type SystemBillingInvoicesListFilterType = 
  'WORKSPACE' |
  'CUSTOMER';

/** SystemBillingInvoicesListResponse output */
export type SystemBillingInvoicesListResponse = {
  __typename?: 'SystemBillingInvoicesListResponse',
  /** List items */
  items: Array<SystemBillingInvoiceItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type SystemBillingLimitMetricItem = {
  __typename?: 'SystemBillingLimitMetricItem',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  showPriority?: Maybe<Scalars['Int']>,
  unit?: Maybe<Scalars['String']>,
};

export type SystemBillingMetricUsageItem = {
  __typename?: 'SystemBillingMetricUsageItem',
  limitMetric?: Maybe<SystemBillingLimitMetricItem>,
  value?: Maybe<Scalars['Float']>,
};

export type SystemBillingMetricUsageQuotaItem = {
  __typename?: 'SystemBillingMetricUsageQuotaItem',
  limitMetric?: Maybe<SystemBillingLimitMetricItem>,
  value?: Maybe<Scalars['Float']>,
};

/** SystemBillingMetricUsageQuotasListResponse output */
export type SystemBillingMetricUsageQuotasListResponse = {
  __typename?: 'SystemBillingMetricUsageQuotasListResponse',
  /** List items */
  items: Array<SystemBillingMetricUsageQuotaItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type SystemBillingMetricUsagesListFilter = {
  entryDate: DateTimePredicate,
};

/** SystemBillingMetricUsagesListResponse output */
export type SystemBillingMetricUsagesListResponse = {
  __typename?: 'SystemBillingMetricUsagesListResponse',
  /** List items */
  items: Array<SystemBillingMetricUsageItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type SystemBillingNextPlanResponse = {
  __typename?: 'SystemBillingNextPlanResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  displayName?: Maybe<Scalars['String']>,
};

export type SystemBillingPlanBaseInfo = {
  __typename?: 'SystemBillingPlanBaseInfo',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  price?: Maybe<Scalars['Int']>,
  isCustom?: Maybe<Scalars['Boolean']>,
  isLegacy?: Maybe<Scalars['Boolean']>,
  limitMetrics?: Maybe<Array<Maybe<SystemBillingPlanLimitMetricItem>>>,
};

export type SystemBillingPlanLimitMetricItem = {
  __typename?: 'SystemBillingPlanLimitMetricItem',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  overagePrice?: Maybe<Scalars['Int']>,
  softLimit?: Maybe<Scalars['Float']>,
  hardLimit?: Maybe<Scalars['Float']>,
};

/** BillingPlanUpdateMutationInput */
export type SystemBillingPlanUpdateMutationInput = {
  planId: Scalars['ID'],
};

export type SystemBranchEnvironmentMode = 
  'FULL' |
  'SYSTEM';

/** Ci Status */
export type SystemCiStatusOutput = {
  __typename?: 'SystemCiStatusOutput',
  status: Scalars['String'],
  migrations?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** Computed field mode */
export type SystemComputedFieldMode = 
  'VIRTUAL' |
  'STORED';

/** Custom Table Field Type */
export type SystemCustomTableField = {
  __typename?: 'SystemCustomTableField',
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType?: Maybe<SystemFieldType>,
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<SystemComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  fieldTypeAttributes?: Maybe<SystemFieldTypeAttributes>,
};

/** Date Field Attributes */
export type SystemDateFieldTypeAttributes = {
  __typename?: 'SystemDateFieldTypeAttributes',
  format: Scalars['String'],
};

/** Date Type Format Enum */
export type SystemDateTypeFormatEnum = 
  'DATE' |
  'DATETIME';

/** DeployDataResponse */
export type SystemDeployDataResponse = {
  __typename?: 'SystemDeployDataResponse',
  uploadBuildUrl: Scalars['String'],
  uploadMetaDataUrl: Scalars['String'],
  buildName: Scalars['String'],
};

/** DeployingBuildInput */
export type SystemDeployingBuildInput = {
  buildName: Scalars['String'],
  options?: Maybe<SystemDeployOptions>,
};

export type SystemDeployModeEnum = 
  'FULL' |
  'ONLY_PLUGINS' |
  'ONLY_PROJECT' |
  'FUNCTIONS' |
  'MIGRATIONS';

/** DeployOptions */
export type SystemDeployOptions = {
  mode?: Maybe<SystemDeployModeEnum>,
  pluginNames?: Maybe<Array<Maybe<Scalars['String']>>>,
  extensionNames?: Maybe<Array<Maybe<Scalars['String']>>>,
};

export type SystemDeployStatusEnum = 
  'deploying' |
  'complete_error' |
  'complete_success' |
  'compiling' |
  'preparing' |
  'initialize';

/** SystemDeployStatusResult */
export type SystemDeployStatusResult = {
  __typename?: 'SystemDeployStatusResult',
  status: SystemDeployStatusEnum,
  message?: Maybe<Scalars['String']>,
};

/** SystemEnvironmentBackupListResponse output */
export type SystemEnvironmentBackupListResponse = {
  __typename?: 'SystemEnvironmentBackupListResponse',
  /** List items */
  items: Array<EnvironmentBackupItem>,
  /** List items count */
  count: Scalars['Int'],
};

/** SystemEnvironmentsListResponse output */
export type SystemEnvironmentsListResponse = {
  __typename?: 'SystemEnvironmentsListResponse',
  /** List items */
  items: Array<EnvironmentItem>,
  /** List items count */
  count: Scalars['Int'],
};

/** Field Data Features */
export type SystemFieldDataFeatures = {
  __typename?: 'SystemFieldDataFeatures',
  create: Scalars['Boolean'],
  update: Scalars['Boolean'],
  sort: Scalars['Boolean'],
};

/** Field Schema Features */
export type SystemFieldSchemaFeatures = {
  __typename?: 'SystemFieldSchemaFeatures',
  update: Scalars['Boolean'],
  delete: Scalars['Boolean'],
};

/** Field types */
export type SystemFieldType = 
  'ID' |
  'UUID' |
  'JSON' |
  'NUMBER' |
  'TEXT' |
  'DATE' |
  'SWITCH' |
  'RELATION' |
  'FILE' |
  'SMART' |
  'GEO' |
  'ONE_WAY_RELATION' |
  'MISSING_RELATION';

/** Field Type Attributes */
export type SystemFieldTypeAttributes = SystemDateFieldTypeAttributes | SystemFileFieldTypeAttributes | SystemMissingRelationFieldTypeAttributes | SystemNumberFieldTypeAttributes | SystemSmartFieldTypeAttributes | SystemSwitchFieldTypeAttributes | SystemTextFieldTypeAttributes | SystemUuidFieldTypeAttributes | SystemGeoFieldTypeAttributes;

/** Field Type Attributes Input */
export type SystemFieldTypeAttributesInput = {
  format?: Maybe<Scalars['String']>,
  precision?: Maybe<Scalars['Int']>,
  currency?: Maybe<Scalars['String']>,
  minValue?: Maybe<Scalars['Float']>,
  maxValue?: Maybe<Scalars['Float']>,
  isBigInt?: Maybe<Scalars['Boolean']>,
  autoIncrement?: Maybe<Scalars['Boolean']>,
  fieldSize?: Maybe<Scalars['Int']>,
  expiration?: Maybe<Scalars['Int']>,
  listOptions?: Maybe<Array<Scalars['String']>>,
  maxSize?: Maybe<Scalars['Int']>,
  typeRestrictions?: Maybe<Array<Scalars['String']>>,
  srid?: Maybe<Scalars['Int']>,
};

/** File Field Attributes */
export type SystemFileFieldTypeAttributes = {
  __typename?: 'SystemFileFieldTypeAttributes',
  format: Scalars['String'],
  maxSize?: Maybe<Scalars['Int']>,
  showTitle?: Maybe<Scalars['Boolean']>,
  showUrl?: Maybe<Scalars['Boolean']>,
  typeRestrictions?: Maybe<Array<Scalars['String']>>,
  expiration?: Maybe<Scalars['Int']>,
};

/** File Type Format Enum */
export type SystemFileTypeFormatEnum = 
  'FILE' |
  'IMAGE';

/** FunctionInfo */
export type SystemFunctionInfo = {
  name: Scalars['String'],
  functionType: SystemFunctionType,
  description?: Maybe<Scalars['String']>,
  application?: Maybe<SystemApplication>,
};

/** FunctionInfoFilter */
export type SystemFunctionInfoFilter = {
  name?: Maybe<Scalars['String']>,
  functionType?: Maybe<SystemFunctionType>,
  description?: Maybe<Scalars['String']>,
};

/** FunctionInfoOrderBy */
export type SystemFunctionInfoOrderBy = 
  'name_ASC' |
  'name_DESC' |
  'functionType_ASC' |
  'functionType_DESC' |
  'description_ASC' |
  'description_DESC';

/** SystemFunctionListResponse output */
export type SystemFunctionListResponse = {
  __typename?: 'SystemFunctionListResponse',
  /** List items */
  items: Array<SystemFunctionInfo>,
  /** List items count */
  count: Scalars['Int'],
};

/** FunctionLogEntry */
export type SystemFunctionLogEntry = {
  __typename?: 'SystemFunctionLogEntry',
  timestamp?: Maybe<Scalars['DateTime']>,
  message?: Maybe<Scalars['String']>,
};

/** FunctionResolverInfo */
export type SystemFunctionResolverInfo = SystemFunctionInfo & {
  __typename?: 'SystemFunctionResolverInfo',
  name: Scalars['String'],
  functionType: SystemFunctionType,
  description?: Maybe<Scalars['String']>,
  gqlType: Scalars['String'],
  application?: Maybe<SystemApplication>,
};

/** FunctionTaskInfo */
export type SystemFunctionTaskInfo = SystemFunctionInfo & {
  __typename?: 'SystemFunctionTaskInfo',
  name: Scalars['String'],
  functionType: SystemFunctionType,
  description?: Maybe<Scalars['String']>,
  scheduleExpression?: Maybe<Scalars['String']>,
  application?: Maybe<SystemApplication>,
};

/** FunctionTriggerInfo */
export type SystemFunctionTriggerInfo = SystemFunctionInfo & {
  __typename?: 'SystemFunctionTriggerInfo',
  name: Scalars['String'],
  functionType: SystemFunctionType,
  description?: Maybe<Scalars['String']>,
  operation: Scalars['String'],
  tableName: Scalars['String'],
  type: Scalars['String'],
  application?: Maybe<SystemApplication>,
};

/** FunctionType */
export type SystemFunctionType = 
  'resolver' |
  'trigger' |
  'webhook' |
  'task' |
  'schedule';

/** FunctionWebhookInfo */
export type SystemFunctionWebhookInfo = SystemFunctionInfo & {
  __typename?: 'SystemFunctionWebhookInfo',
  name: Scalars['String'],
  functionType: SystemFunctionType,
  description?: Maybe<Scalars['String']>,
  httpMethod: Scalars['String'],
  workspaceRelativePath: Scalars['String'],
  workspaceFullPath: Scalars['String'],
  application?: Maybe<SystemApplication>,
};

/** Geo Field Attributes */
export type SystemGeoFieldTypeAttributes = {
  __typename?: 'SystemGeoFieldTypeAttributes',
  format: Scalars['String'],
  srid?: Maybe<Scalars['Int']>,
};

/** Table Create Index Input */
export type SystemIndexCreateInput = {
  tableId: Scalars['ID'],
  type: TableIndexType,
  columns: Array<SystemTableIndexColumnInput>,
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
};

/** Table Delete Index Input */
export type SystemIndexDeleteInput = {
  id: Scalars['ID'],
};

/** Table Update Index Input */
export type SystemIndexUpdateInput = {
  id: Scalars['ID'],
  type?: Maybe<TableIndexType>,
  columns?: Maybe<Array<SystemTableIndexColumnInput>>,
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
};

/** InvokeData */
export type SystemInvokeData = {
  functionName: Scalars['String'],
  inputArgs?: Maybe<Scalars['String']>,
};

/** InvokeFunctionResponse */
export type SystemInvokeFunctionResponse = {
  __typename?: 'SystemInvokeFunctionResponse',
  responseData: Scalars['String'],
};

/** MissingRelation Field Attributes */
export type SystemMissingRelationFieldTypeAttributes = {
  __typename?: 'SystemMissingRelationFieldTypeAttributes',
  missingTable: Scalars['String'],
};

export type SystemMutation = {
  __typename?: 'SystemMutation',
  applicationDelete?: Maybe<SuccessResponse>,
  applicationInstall?: Maybe<SystemApplication>,
  applicationUpdate?: Maybe<SystemApplication>,
  billingDetailsUpdate?: Maybe<SystemBillingDetailsResponse>,
  billingPlanUpdate?: Maybe<SystemBillingCurrentPlanResponse>,
  ciCommit?: Maybe<AsyncSession>,
  deploy?: Maybe<Scalars['Boolean']>,
  environmentBackup?: Maybe<AsyncSession>,
  environmentBranch?: Maybe<AsyncSession>,
  environmentDelete?: Maybe<SuccessResponse>,
  environmentRestore?: Maybe<AsyncSession>,
  fieldCreate: SystemTableField,
  fieldDelete: SuccessResponse,
  fieldUpdate: SystemTableField,
  fieldUpdatePosition: SuccessResponse,
  indexCreate: SystemTableIndex,
  indexDelete?: Maybe<SuccessResponse>,
  indexUpdate: SystemTableIndex,
  invoke?: Maybe<SystemInvokeFunctionResponse>,
  prepareDeploy: SystemDeployDataResponse,
  tableCreate: SystemTable,
  tableDelete: SuccessResponse,
  tableUpdate: SystemTable,
  viewCreate: SystemTable,
  viewUpdate: SystemTable,
  workspaceCreate?: Maybe<SystemWorkspaceCreateResponse>,
  workspaceCreateAsync?: Maybe<SystemWorkspaceCreateResponse>,
  workspaceDelete?: Maybe<SuccessResponse>,
  workspaceLeave?: Maybe<SuccessResponse>,
  workspaceUpdate?: Maybe<SystemWorkspaceUpdateResponse>,
};


export type SystemMutationApplicationDeleteArgs = {
  data: SystemApplicationDeleteMutationInput
};


export type SystemMutationApplicationInstallArgs = {
  data: SystemApplicationInstallInput
};


export type SystemMutationApplicationUpdateArgs = {
  data: SystemApplicationUpdateInput
};


export type SystemMutationBillingDetailsUpdateArgs = {
  data: SystemBillingDetailsUpdateMutationInput
};


export type SystemMutationBillingPlanUpdateArgs = {
  data: SystemBillingPlanUpdateMutationInput
};


export type SystemMutationDeployArgs = {
  data?: Maybe<SystemDeployingBuildInput>
};


export type SystemMutationEnvironmentBackupArgs = {
  environmentName: Scalars['String']
};


export type SystemMutationEnvironmentBranchArgs = {
  name: Scalars['String'],
  mode?: Maybe<SystemBranchEnvironmentMode>
};


export type SystemMutationEnvironmentDeleteArgs = {
  environmentName: Scalars['String']
};


export type SystemMutationEnvironmentRestoreArgs = {
  environmentName: Scalars['String'],
  backup: Scalars['String']
};


export type SystemMutationFieldCreateArgs = {
  data: SystemTableFieldCreateInput
};


export type SystemMutationFieldDeleteArgs = {
  data: SystemTableFieldDeleteInput
};


export type SystemMutationFieldUpdateArgs = {
  data: SystemTableFieldUpdateInput
};


export type SystemMutationFieldUpdatePositionArgs = {
  data: SystemTableFieldPositionUpdateInput
};


export type SystemMutationIndexCreateArgs = {
  data: SystemIndexCreateInput
};


export type SystemMutationIndexDeleteArgs = {
  data: SystemIndexDeleteInput
};


export type SystemMutationIndexUpdateArgs = {
  data: SystemIndexUpdateInput
};


export type SystemMutationInvokeArgs = {
  data?: Maybe<SystemInvokeData>
};


export type SystemMutationTableCreateArgs = {
  data: SystemTableCreateInput
};


export type SystemMutationTableDeleteArgs = {
  data: SystemTableDeleteInput
};


export type SystemMutationTableUpdateArgs = {
  data: SystemTableUpdateInput
};


export type SystemMutationViewCreateArgs = {
  data: SystemViewCreateInput
};


export type SystemMutationViewUpdateArgs = {
  data: SystemViewUpdateInput
};


export type SystemMutationWorkspaceCreateArgs = {
  data: SystemWorkspaceCreateMutationInput
};


export type SystemMutationWorkspaceCreateAsyncArgs = {
  data: SystemWorkspaceCreateMutationInput
};


export type SystemMutationWorkspaceDeleteArgs = {
  data: SystemWorkspaceDeleteMutationInput
};


export type SystemMutationWorkspaceLeaveArgs = {
  force?: Maybe<Scalars['Boolean']>
};


export type SystemMutationWorkspaceUpdateArgs = {
  data: SystemWorkspaceUpdateMutationInput
};

/** Number Field Attributes */
export type SystemNumberFieldTypeAttributes = {
  __typename?: 'SystemNumberFieldTypeAttributes',
  format: Scalars['String'],
  precision?: Maybe<Scalars['Int']>,
  currency?: Maybe<Scalars['String']>,
  minValue?: Maybe<Scalars['Float']>,
  maxValue?: Maybe<Scalars['Float']>,
  isBigInt?: Maybe<Scalars['Boolean']>,
  autoIncrement?: Maybe<Scalars['Boolean']>,
};

/** Number Type Format Enum */
export type SystemNumberTypeFormatEnum = 
  'NUMBER' |
  'CURRENCY' |
  'PERCENTAGE' |
  'FRACTION' |
  'SCIENTIFIC';

/** Diff Environment Input */
export type SystemPlanEnvironmentOutput = {
  __typename?: 'SystemPlanEnvironmentOutput',
  url?: Maybe<Scalars['String']>,
};

export type SystemQuery = {
  __typename?: 'SystemQuery',
  application?: Maybe<SystemApplication>,
  applicationsList?: Maybe<SystemApplicationListResponse>,
  billingCurrentPlan?: Maybe<SystemBillingCurrentPlanResponse>,
  billingDetails?: Maybe<SystemBillingDetailsResponse>,
  billingInvoicesList: SystemBillingInvoicesListResponse,
  billingMetricUsageQuotasList: SystemBillingMetricUsageQuotasListResponse,
  billingMetricUsagesList: SystemBillingMetricUsagesListResponse,
  ciPlan?: Maybe<SystemPlanEnvironmentOutput>,
  ciStatus?: Maybe<SystemCiStatusOutput>,
  deployStatus: SystemDeployStatusResult,
  environmentBackupsList?: Maybe<SystemEnvironmentBackupListResponse>,
  environmentsList?: Maybe<SystemEnvironmentsListResponse>,
  functionsList?: Maybe<SystemFunctionListResponse>,
  introspection?: Maybe<IntrospectionQueryResponse>,
  logs?: Maybe<Array<Maybe<Scalars['String']>>>,
  logsList?: Maybe<Array<Maybe<SystemFunctionLogEntry>>>,
  table?: Maybe<SystemTable>,
  tableField?: Maybe<SystemTableField>,
  tablesList: SystemTableListResponse,
  userBillingConfiguration: SystemUserBillingConfigurationResponse,
  workspacesList?: Maybe<SystemWorkspaceListResponse>,
};


export type SystemQueryApplicationArgs = {
  id: Scalars['String']
};


export type SystemQueryBillingInvoicesListArgs = {
  by?: Maybe<SystemBillingInvoicesListFilterType>,
  limit?: Maybe<Scalars['Int']>,
  before?: Maybe<Scalars['ID']>,
  after?: Maybe<Scalars['ID']>
};


export type SystemQueryBillingMetricUsagesListArgs = {
  filter?: Maybe<SystemBillingMetricUsagesListFilter>
};


export type SystemQueryDeployStatusArgs = {
  buildName: Scalars['String']
};


export type SystemQueryEnvironmentBackupsListArgs = {
  environmentName?: Maybe<Scalars['String']>
};


export type SystemQueryFunctionsListArgs = {
  applicationId?: Maybe<Scalars['String']>,
  filter?: Maybe<SystemFunctionInfoFilter>,
  orderBy?: Maybe<Array<Maybe<SystemFunctionInfoOrderBy>>>
};


export type SystemQueryLogsArgs = {
  functionName: Scalars['String'],
  applicationId?: Maybe<Scalars['String']>,
  limit?: Maybe<Scalars['Int']>,
  startTime?: Maybe<Scalars['DateTime']>,
  endTime?: Maybe<Scalars['DateTime']>
};


export type SystemQueryLogsListArgs = {
  functionName: Scalars['String'],
  applicationId?: Maybe<Scalars['String']>,
  limit?: Maybe<Scalars['Int']>,
  startTime?: Maybe<Scalars['DateTime']>,
  endTime?: Maybe<Scalars['DateTime']>
};


export type SystemQueryTableArgs = {
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>
};


export type SystemQueryTableFieldArgs = {
  id: Scalars['ID']
};


export type SystemQueryTablesListArgs = {
  filter?: Maybe<SystemTableListFilter>
};

/** Relation */
export type SystemRelation = {
  __typename?: 'SystemRelation',
  refTable: SystemTable,
  refField?: Maybe<SystemTableField>,
  relationTableName?: Maybe<Scalars['String']>,
  relationFieldName?: Maybe<Scalars['String']>,
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList?: Maybe<Scalars['Boolean']>,
  refFieldIsRequired?: Maybe<Scalars['Boolean']>,
};

/** Relation Create Input */
export type SystemRelationCreateInput = {
  refTableId: Scalars['ID'],
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList: Scalars['Boolean'],
  refFieldIsRequired: Scalars['Boolean'],
};

/** Relation Update Input */
export type SystemRelationUpdateInput = {
  refTableId?: Maybe<Scalars['ID']>,
  refFieldName?: Maybe<Scalars['String']>,
  refFieldDisplayName?: Maybe<Scalars['String']>,
  refFieldIsList?: Maybe<Scalars['Boolean']>,
  refFieldIsRequired?: Maybe<Scalars['Boolean']>,
};

/** Schema Origin */
export type SystemSchemaOrigin = {
  __typename?: 'SystemSchemaOrigin',
  type: SystemSchemaOriginType,
  provider?: Maybe<Scalars['String']>,
};

/** Schema Origin Type Enum */
export type SystemSchemaOriginType = 
  'REMOTE' |
  'LOCAL' |
  'VIEW';

/** Smart Field Attributes */
export type SystemSmartFieldTypeAttributes = {
  __typename?: 'SystemSmartFieldTypeAttributes',
  format: Scalars['String'],
  innerFields?: Maybe<Array<Maybe<SystemCustomTableField>>>,
};

/** Smart Type Format Enum */
export type SystemSmartTypeFormatEnum = 
  'ADDRESS' |
  'PHONE';

/** Switch Field Attributes */
export type SystemSwitchFieldTypeAttributes = {
  __typename?: 'SystemSwitchFieldTypeAttributes',
  format: Scalars['String'],
  listOptions?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** Switch Type Format Enum */
export type SystemSwitchTypeFormatEnum = 
  'ON_OFF' |
  'YES_NO' |
  'TRUE_FALSE' |
  'ACTIVE_INACTIVE' |
  'HIGH_LOW' |
  'CUSTOM';

/** Table */
export type SystemTable = {
  __typename?: 'SystemTable',
  id: Scalars['ID'],
  application?: Maybe<SystemApplication>,
  isSystem: Scalars['Boolean'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  fields?: Maybe<Array<SystemTableField>>,
  indexes?: Maybe<Array<SystemTableIndex>>,
  origin: SystemSchemaOrigin,
  schemaFeatures: SystemTableSchemaFeatures,
  dataFeatures: SystemTableDataFeatures,
  attributes?: Maybe<SystemTableAttributes>,
  description?: Maybe<Scalars['String']>,
};

/** Table Attributes */
export type SystemTableAttributes = SystemViewAttributes;

/** Table Create Input */
export type SystemTableCreateInput = {
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** Table Data Features */
export type SystemTableDataFeatures = {
  __typename?: 'SystemTableDataFeatures',
  create: Scalars['Boolean'],
  update: Scalars['Boolean'],
  delete: Scalars['Boolean'],
};

/** Table Delete Input */
export type SystemTableDeleteInput = {
  id: Scalars['ID'],
};

/** TableField */
export type SystemTableField = {
  __typename?: 'SystemTableField',
  id: Scalars['ID'],
  table: SystemTable,
  isSystem: Scalars['Boolean'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType: SystemFieldType,
  origin: SystemSchemaOrigin,
  schemaFeatures: SystemFieldSchemaFeatures,
  dataFeatures: SystemFieldDataFeatures,
  isMeta: Scalars['Boolean'],
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<SystemComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  fieldTypeAttributes?: Maybe<SystemFieldTypeAttributes>,
  relation?: Maybe<SystemRelation>,
};

/** Table Field Create Input */
export type SystemTableFieldCreateInput = {
  tableId: Scalars['ID'],
  force?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType: SystemFieldType,
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  initialValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<SystemComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  position?: Maybe<Scalars['Int']>,
  fieldTypeAttributes?: Maybe<SystemFieldTypeAttributesInput>,
  relation?: Maybe<SystemRelationCreateInput>,
};

/** Table Field Delete Input */
export type SystemTableFieldDeleteInput = {
  id: Scalars['ID'],
};

/** Table Field Position Update Input */
export type SystemTableFieldPositionUpdateInput = {
  id: Scalars['ID'],
  newPosition: Scalars['Int'],
};

/** Table Field Update Input */
export type SystemTableFieldUpdateInput = {
  id: Scalars['ID'],
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType?: Maybe<SystemFieldType>,
  isList?: Maybe<Scalars['Boolean']>,
  isRequired?: Maybe<Scalars['Boolean']>,
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  initialValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<SystemComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  position?: Maybe<Scalars['Int']>,
  fieldTypeAttributes?: Maybe<SystemFieldTypeAttributesInput>,
  relation?: Maybe<SystemRelationUpdateInput>,
};

/** Table Index */
export type SystemTableIndex = {
  __typename?: 'SystemTableIndex',
  id: Scalars['ID'],
  table: SystemTable,
  type: Scalars['String'],
  columns?: Maybe<Array<SystemTableIndexColumn>>,
  name?: Maybe<Scalars['String']>,
  isSystem: Scalars['Boolean'],
};

/** Table Index Column */
export type SystemTableIndexColumn = {
  __typename?: 'SystemTableIndexColumn',
  name: Scalars['String'],
};

/** Table Index Column Input */
export type SystemTableIndexColumnInput = {
  name: Scalars['String'],
};

/** Table List Filter */
export type SystemTableListFilter = {
  onlyUserTables?: Maybe<Scalars['Boolean']>,
  tableNames?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** Table List Response */
export type SystemTableListResponse = {
  __typename?: 'SystemTableListResponse',
  items?: Maybe<Array<Maybe<SystemTable>>>,
  count?: Maybe<Scalars['Int']>,
};

/** Table Schema Create Features */
export type SystemTableSchemaCreateFeatures = {
  __typename?: 'SystemTableSchemaCreateFeatures',
  ID: Scalars['Boolean'],
  UUID: Scalars['Boolean'],
  JSON: Scalars['Boolean'],
  NUMBER: Scalars['Boolean'],
  TEXT: Scalars['Boolean'],
  DATE: Scalars['Boolean'],
  SWITCH: Scalars['Boolean'],
  RELATION: Scalars['Boolean'],
  FILE: Scalars['Boolean'],
  SMART: Scalars['Boolean'],
  GEO: Scalars['Boolean'],
  ONE_WAY_RELATION: Scalars['Boolean'],
  MISSING_RELATION: Scalars['Boolean'],
};

/** Table Schema Features */
export type SystemTableSchemaFeatures = {
  __typename?: 'SystemTableSchemaFeatures',
  create: SystemTableSchemaCreateFeatures,
  update?: Maybe<SystemTableSchemaMetaFieldFeatures>,
  computedFields: Scalars['Boolean'],
};

/** Table Schema Meta Field Features */
export type SystemTableSchemaMetaFieldFeatures = {
  __typename?: 'SystemTableSchemaMetaFieldFeatures',
  name: Scalars['Boolean'],
  displayName: Scalars['Boolean'],
};

/** Table Update Input */
export type SystemTableUpdateInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** Text Field Attributes */
export type SystemTextFieldTypeAttributes = {
  __typename?: 'SystemTextFieldTypeAttributes',
  format: Scalars['String'],
  fieldSize?: Maybe<Scalars['Int']>,
};

/** Text Type Format Enum */
export type SystemTextTypeFormatEnum = 
  'UNFORMATTED' |
  'NAME' |
  'EIN' |
  'EMAIL';

export type SystemUserAccountInfo = {
  __typename?: 'SystemUserAccountInfo',
  email: Scalars['String'],
  createdAt?: Maybe<Scalars['DateTime']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  learningMode?: Maybe<Scalars['Boolean']>,
  permissions?: Maybe<Scalars['String']>,
  role?: Maybe<Scalars['String']>,
  isDeveloper?: Maybe<Scalars['Boolean']>,
  type?: Maybe<SystemUserType>,
  companyName?: Maybe<Scalars['String']>,
  projectDescription?: Maybe<Scalars['String']>,
  avatar?: Maybe<UserInfoAvatar>,
};

export type SystemUserBillingConfigurationResponse = {
  __typename?: 'SystemUserBillingConfigurationResponse',
  isFreePlanAvailable: Scalars['Boolean'],
  isCancelSubscriptionAvailable: Scalars['Boolean'],
  availablePlans: Array<SystemBillingPlanBaseInfo>,
};

/** User Type */
export type SystemUserType = 
  'Agency' |
  'MyOwn' |
  'Team';

/** UUID Field Attributes */
export type SystemUuidFieldTypeAttributes = {
  __typename?: 'SystemUUIDFieldTypeAttributes',
  fieldSize?: Maybe<Scalars['Int']>,
};

/** View Attributes */
export type SystemViewAttributes = {
  __typename?: 'SystemViewAttributes',
  query?: Maybe<Scalars['String']>,
};

/** View Create Input */
export type SystemViewCreateInput = {
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  query: Scalars['String'],
  description?: Maybe<Scalars['String']>,
};

/** View Update Input */
export type SystemViewUpdateInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  query?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** WorkspaceCreateMutationInput */
export type SystemWorkspaceCreateMutationInput = {
  name: Scalars['String'],
  billingPlanId?: Maybe<Scalars['ID']>,
};

export type SystemWorkspaceCreateResponse = {
  __typename?: 'SystemWorkspaceCreateResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** WorkspaceDeleteMutationInput */
export type SystemWorkspaceDeleteMutationInput = {
  id: Scalars['ID'],
};

export type SystemWorkspaceImage = {
  __typename?: 'SystemWorkspaceImage',
  id?: Maybe<Scalars['String']>,
  downloadUrl?: Maybe<Scalars['String']>,
};

/** SystemWorkspaceListResponse output */
export type SystemWorkspaceListResponse = {
  __typename?: 'SystemWorkspaceListResponse',
  /** List items */
  items: Array<WorkspaceItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type SystemWorkspaceStatus = 
  'active' |
  'blocked' |
  'canceled' |
  'suspended' |
  'canceling' |
  'pending';

/** WorkspaceUpdateMutationInput */
export type SystemWorkspaceUpdateMutationInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
};

export type SystemWorkspaceUpdateResponse = {
  __typename?: 'SystemWorkspaceUpdateResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** Table */
export type Table = {
  __typename?: 'Table',
  id: Scalars['ID'],
  application?: Maybe<Application>,
  isSystem: Scalars['Boolean'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  fields?: Maybe<Array<TableField>>,
  indexes?: Maybe<Array<TableIndex>>,
  origin: SchemaOrigin,
  schemaFeatures: TableSchemaFeatures,
  dataFeatures: TableDataFeatures,
  attributes?: Maybe<TableAttributes>,
  description?: Maybe<Scalars['String']>,
};

/** Table Attributes */
export type TableAttributes = ViewAttributes;

/** Table Create Input */
export type TableCreateInput = {
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** Table Data Features */
export type TableDataFeatures = {
  __typename?: 'TableDataFeatures',
  create: Scalars['Boolean'],
  update: Scalars['Boolean'],
  delete: Scalars['Boolean'],
};

/** Table Delete Input */
export type TableDeleteInput = {
  id: Scalars['ID'],
};

/** TableField */
export type TableField = {
  __typename?: 'TableField',
  id: Scalars['ID'],
  table: Table,
  isSystem: Scalars['Boolean'],
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType: FieldType,
  origin: SchemaOrigin,
  schemaFeatures: FieldSchemaFeatures,
  dataFeatures: FieldDataFeatures,
  isMeta: Scalars['Boolean'],
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<ComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  fieldTypeAttributes?: Maybe<FieldTypeAttributes>,
  relation?: Maybe<Relation>,
};

/** Table Field Create Input */
export type TableFieldCreateInput = {
  tableId: Scalars['ID'],
  force?: Maybe<Scalars['Boolean']>,
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType: FieldType,
  isList: Scalars['Boolean'],
  isRequired: Scalars['Boolean'],
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  initialValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<ComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  position?: Maybe<Scalars['Int']>,
  fieldTypeAttributes?: Maybe<FieldTypeAttributesInput>,
  relation?: Maybe<RelationCreateInput>,
};

/** Table Field Delete Input */
export type TableFieldDeleteInput = {
  id: Scalars['ID'],
};

/** Table Field Position Update Input */
export type TableFieldPositionUpdateInput = {
  id: Scalars['ID'],
  newPosition: Scalars['Int'],
};

/** Table Field Update Input */
export type TableFieldUpdateInput = {
  id: Scalars['ID'],
  force?: Maybe<Scalars['Boolean']>,
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
  fieldType?: Maybe<FieldType>,
  isList?: Maybe<Scalars['Boolean']>,
  isRequired?: Maybe<Scalars['Boolean']>,
  isUnique?: Maybe<Scalars['Boolean']>,
  defaultValue?: Maybe<Scalars['String']>,
  initialValue?: Maybe<Scalars['String']>,
  computedMode?: Maybe<ComputedFieldMode>,
  expression?: Maybe<Scalars['String']>,
  position?: Maybe<Scalars['Int']>,
  fieldTypeAttributes?: Maybe<FieldTypeAttributesInput>,
  relation?: Maybe<RelationUpdateInput>,
};

/** Table Index */
export type TableIndex = {
  __typename?: 'TableIndex',
  id: Scalars['ID'],
  table: Table,
  type: Scalars['String'],
  columns?: Maybe<Array<TableIndexColumn>>,
  name?: Maybe<Scalars['String']>,
  isSystem: Scalars['Boolean'],
};

/** Table Index Column */
export type TableIndexColumn = {
  __typename?: 'TableIndexColumn',
  name: Scalars['String'],
};

/** Table Index Column Input */
export type TableIndexColumnInput = {
  name: Scalars['String'],
};

export type TableIndexType = 
  'INDEX' |
  'UNIQUE';

/** Table List Filter */
export type TableListFilter = {
  onlyUserTables?: Maybe<Scalars['Boolean']>,
  tableNames?: Maybe<Array<Maybe<Scalars['String']>>>,
};

/** Table List Response */
export type TableListResponse = {
  __typename?: 'TableListResponse',
  items?: Maybe<Array<Maybe<Table>>>,
  count?: Maybe<Scalars['Int']>,
};

/** Table Schema Create Features */
export type TableSchemaCreateFeatures = {
  __typename?: 'TableSchemaCreateFeatures',
  ID: Scalars['Boolean'],
  UUID: Scalars['Boolean'],
  JSON: Scalars['Boolean'],
  NUMBER: Scalars['Boolean'],
  TEXT: Scalars['Boolean'],
  DATE: Scalars['Boolean'],
  SWITCH: Scalars['Boolean'],
  RELATION: Scalars['Boolean'],
  FILE: Scalars['Boolean'],
  SMART: Scalars['Boolean'],
  GEO: Scalars['Boolean'],
  ONE_WAY_RELATION: Scalars['Boolean'],
  MISSING_RELATION: Scalars['Boolean'],
};

/** Table Schema Features */
export type TableSchemaFeatures = {
  __typename?: 'TableSchemaFeatures',
  create: TableSchemaCreateFeatures,
  update?: Maybe<TableSchemaMetaFieldFeatures>,
  computedFields: Scalars['Boolean'],
};

/** Table Schema Meta Field Features */
export type TableSchemaMetaFieldFeatures = {
  __typename?: 'TableSchemaMetaFieldFeatures',
  name: Scalars['Boolean'],
  displayName: Scalars['Boolean'],
};

/** Table Update Input */
export type TableUpdateInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

export type TeamInvitation = {
  __typename?: 'TeamInvitation',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  uuid?: Maybe<Scalars['String']>,
  email?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  resentOn?: Maybe<Scalars['DateTime']>,
  accepted?: Maybe<Scalars['Boolean']>,
  acceptedOn?: Maybe<Scalars['DateTime']>,
  invitee?: Maybe<TeamMember>,
  invitedBy?: Maybe<TeamMember>,
  _description?: Maybe<Scalars['String']>,
};

/** TeamInvitationAcceptInput */
export type TeamInvitationAcceptInput = {
  uuid: Scalars['String'],
  accepted: Scalars['Boolean'],
};

/** TeamInvitationAcceptResponse */
export type TeamInvitationAcceptResponse = {
  __typename?: 'TeamInvitationAcceptResponse',
  success: Scalars['Boolean'],
};

/** Cancel team members invitations input */
export type TeamInvitationCancelInput = {
  memberId: Scalars['ID'],
};

/** TeamInvitations delete input */
export type TeamInvitationDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** Team Invitation Details */
export type TeamInvitationDetails = {
  __typename?: 'TeamInvitationDetails',
  uuid?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  email?: Maybe<Scalars['String']>,
  isRegistered?: Maybe<Scalars['Boolean']>,
  invitedBy?: Maybe<InvitedByName>,
};

export type TeamInvitationFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  uuid?: Maybe<StringPredicate>,
  email?: Maybe<StringPredicate>,
  firstName?: Maybe<StringPredicate>,
  lastName?: Maybe<StringPredicate>,
  resentOn?: Maybe<DateTimePredicate>,
  accepted?: Maybe<BoolPredicate>,
  acceptedOn?: Maybe<DateTimePredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserFilter>,
  invitee?: Maybe<TeamMemberFilter>,
  invitedBy?: Maybe<TeamMemberFilter>,
  AND?: Maybe<Array<TeamInvitationFilter>>,
  OR?: Maybe<Array<TeamInvitationFilter>>,
};

export type TeamInvitationGroupBy = {
  query: TeamInvitationGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type TeamInvitationGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  uuid?: Maybe<Array<GroupByField>>,
  email?: Maybe<Array<GroupByField>>,
  firstName?: Maybe<Array<GroupByField>>,
  lastName?: Maybe<Array<GroupByField>>,
  resentOn?: Maybe<Array<GroupByField>>,
  accepted?: Maybe<Array<GroupByField>>,
  acceptedOn?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  invitee?: Maybe<TeamMemberGroupByQuery>,
  invitedBy?: Maybe<TeamMemberGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type TeamInvitationKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  uuid?: Maybe<Scalars['String']>,
};

/** TeamInvitationListResponse output */
export type TeamInvitationListResponse = {
  __typename?: 'TeamInvitationListResponse',
  /** List items */
  items: Array<TeamInvitation>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** No longer supported. Use `sort` instead. */
export type TeamInvitationOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'uuid_ASC' |
  'uuid_DESC' |
  'email_ASC' |
  'email_DESC' |
  'firstName_ASC' |
  'firstName_DESC' |
  'lastName_ASC' |
  'lastName_DESC' |
  'resentOn_ASC' |
  'resentOn_DESC' |
  'accepted_ASC' |
  'accepted_DESC' |
  'acceptedOn_ASC' |
  'acceptedOn_DESC';

/** TeamInvitations subscription payload */
export type TeamInvitationPayload = {
  __typename?: 'TeamInvitationPayload',
  mutation: MutationType,
  node?: Maybe<TeamInvitation>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<TeamInvitation>,
};

export type TeamInvitationPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  uuid?: Maybe<StringPredicate>,
  email?: Maybe<StringPredicate>,
  firstName?: Maybe<StringPredicate>,
  lastName?: Maybe<StringPredicate>,
  resentOn?: Maybe<DateTimePredicate>,
  accepted?: Maybe<BoolPredicate>,
  acceptedOn?: Maybe<DateTimePredicate>,
  _fullText?: Maybe<Scalars['String']>,
  createdBy?: Maybe<UserPermissionFilter>,
  invitee?: Maybe<TeamMemberPermissionFilter>,
  invitedBy?: Maybe<TeamMemberPermissionFilter>,
  AND?: Maybe<Array<TeamInvitationPermissionFilter>>,
  OR?: Maybe<Array<TeamInvitationPermissionFilter>>,
};

export type TeamInvitationPermissionRelationFilter = {
  some?: Maybe<TeamInvitationPermissionFilter>,
  every?: Maybe<TeamInvitationPermissionFilter>,
  none?: Maybe<TeamInvitationPermissionFilter>,
};

export type TeamInvitationRelationFilter = {
  some?: Maybe<TeamInvitationFilter>,
  every?: Maybe<TeamInvitationFilter>,
  none?: Maybe<TeamInvitationFilter>,
};

/** Resend team invitation input */
export type TeamInvitationResendInput = {
  memberId: Scalars['ID'],
};

/** Team Invitations Details List */
export type TeamInvitationsDetailsList = {
  __typename?: 'TeamInvitationsDetailsList',
  items?: Maybe<Array<Maybe<TeamInvitationDetails>>>,
  count?: Maybe<Scalars['Int']>,
};

export type TeamInvitationSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  uuid?: Maybe<SortOrder>,
  email?: Maybe<SortOrder>,
  firstName?: Maybe<SortOrder>,
  lastName?: Maybe<SortOrder>,
  resentOn?: Maybe<SortOrder>,
  accepted?: Maybe<SortOrder>,
  acceptedOn?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  invitee?: Maybe<TeamMemberSort>,
  invitedBy?: Maybe<TeamMemberSort>,
};

/** TeamInvitations subscription filter */
export type TeamInvitationSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<TeamInvitationFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

export type TeamMember = {
  __typename?: 'TeamMember',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  user?: Maybe<User>,
  status?: Maybe<Scalars['String']>,
  isOwner?: Maybe<Scalars['Boolean']>,
  avatar?: Maybe<File>,
  roles?: Maybe<RoleListResponse>,
  receivedTeamInvitations?: Maybe<TeamInvitationListResponse>,
  sentTeamInvitations?: Maybe<TeamInvitationListResponse>,
  email?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  learningMode?: Maybe<Scalars['Boolean']>,
  permissions?: Maybe<UserPermissionList>,
  _description?: Maybe<Scalars['String']>,
};


export type TeamMemberRolesArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};


export type TeamMemberReceivedTeamInvitationsArgs = {
  filter?: Maybe<TeamInvitationFilter>,
  orderBy?: Maybe<Array<Maybe<TeamInvitationOrderBy>>>,
  sort?: Maybe<Array<TeamInvitationSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamInvitationGroupBy>
};


export type TeamMemberSentTeamInvitationsArgs = {
  filter?: Maybe<TeamInvitationFilter>,
  orderBy?: Maybe<Array<Maybe<TeamInvitationOrderBy>>>,
  sort?: Maybe<Array<TeamInvitationSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<TeamInvitationGroupBy>
};


export type TeamMemberPermissionsArgs = {
  filter?: Maybe<PermissionInputFilter>
};

/** TeamMembers delete input */
export type TeamMemberDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

export type TeamMemberFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  status?: Maybe<StringPredicate>,
  isOwner?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  is_self?: Maybe<Scalars['Boolean']>,
  not_self?: Maybe<Scalars['Boolean']>,
  createdBy?: Maybe<UserFilter>,
  user?: Maybe<UserFilter>,
  avatar?: Maybe<FileFilter>,
  roles?: Maybe<RoleRelationFilter>,
  receivedTeamInvitations?: Maybe<TeamInvitationRelationFilter>,
  sentTeamInvitations?: Maybe<TeamInvitationRelationFilter>,
  AND?: Maybe<Array<TeamMemberFilter>>,
  OR?: Maybe<Array<TeamMemberFilter>>,
};

export type TeamMemberGroupBy = {
  query: TeamMemberGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type TeamMemberGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  status?: Maybe<Array<GroupByField>>,
  isOwner?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  user?: Maybe<UserGroupByQuery>,
  avatar?: Maybe<FileGroupByQuery>,
  roles?: Maybe<RoleGroupByQuery>,
  receivedTeamInvitations?: Maybe<TeamInvitationGroupByQuery>,
  sentTeamInvitations?: Maybe<TeamInvitationGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type TeamMemberKeyFilter = {
  id?: Maybe<Scalars['ID']>,
};

/** TeamMemberListResponse output */
export type TeamMemberListResponse = {
  __typename?: 'TeamMemberListResponse',
  /** List items */
  items: Array<TeamMember>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** TeamMemberManyResponse output */
export type TeamMemberManyResponse = {
  __typename?: 'TeamMemberManyResponse',
  /** List items */
  items: Array<TeamMember>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type TeamMemberOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'status_ASC' |
  'status_DESC' |
  'isOwner_ASC' |
  'isOwner_DESC';

/** TeamMembers subscription payload */
export type TeamMemberPayload = {
  __typename?: 'TeamMemberPayload',
  mutation: MutationType,
  node?: Maybe<TeamMember>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<TeamMember>,
};

export type TeamMemberPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  status?: Maybe<StringPredicate>,
  isOwner?: Maybe<BoolPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  is_self?: Maybe<Scalars['Boolean']>,
  not_self?: Maybe<Scalars['Boolean']>,
  createdBy?: Maybe<UserPermissionFilter>,
  user?: Maybe<UserPermissionFilter>,
  avatar?: Maybe<FilePermissionFilter>,
  roles?: Maybe<RolePermissionRelationFilter>,
  receivedTeamInvitations?: Maybe<TeamInvitationPermissionRelationFilter>,
  sentTeamInvitations?: Maybe<TeamInvitationPermissionRelationFilter>,
  AND?: Maybe<Array<TeamMemberPermissionFilter>>,
  OR?: Maybe<Array<TeamMemberPermissionFilter>>,
};

export type TeamMemberPermissionRelationFilter = {
  some?: Maybe<TeamMemberPermissionFilter>,
  every?: Maybe<TeamMemberPermissionFilter>,
  none?: Maybe<TeamMemberPermissionFilter>,
};

export type TeamMemberRelationFilter = {
  some?: Maybe<TeamMemberFilter>,
  every?: Maybe<TeamMemberFilter>,
  none?: Maybe<TeamMemberFilter>,
};

/** Files create input from teamMembers_avatar */
export type TeamMembers_Avatar_FileCreateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarRelationInput>,
};

/** Files update input from teamMembers_avatar */
export type TeamMembers_Avatar_FileUpdateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarUpdateRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsUpdateRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarUpdateRelationInput>,
};

/** Roles create input from teamMembers */
export type TeamMembers_RoleCreateInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersRelationInput>,
};

/** Roles update input from teamMembers */
export type TeamMembers_RoleUpdateInput = {
  filter?: Maybe<RoleKeyFilter>,
  data: RoleUpdateInput,
};

/** TeamMembers relation input */
export type TeamMembersAvatarUpdateRelationInput = {
  connect?: Maybe<FileKeyFilter>,
  disconnect?: Maybe<FileKeyFilter>,
  reconnect?: Maybe<FileKeyFilter>,
  create?: Maybe<TeamMembers_Avatar_FileCreateInput>,
  update?: Maybe<TeamMembers_Avatar_FileUpdateInput>,
};

export type TeamMemberSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  status?: Maybe<SortOrder>,
  isOwner?: Maybe<SortOrder>,
  email?: Maybe<SortOrder>,
  firstName?: Maybe<SortOrder>,
  lastName?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  user?: Maybe<UserSort>,
  avatar?: Maybe<FileSort>,
};

/** TeamMembers relation input */
export type TeamMembersReceivedTeamInvitationsUpdateRelationInput = {
  connect?: Maybe<Array<TeamInvitationKeyFilter>>,
  disconnect?: Maybe<Array<TeamInvitationKeyFilter>>,
  reconnect?: Maybe<Array<TeamInvitationKeyFilter>>,
};

/** TeamMembers relation input */
export type TeamMembersRolesUpdateRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  disconnect?: Maybe<Array<RoleKeyFilter>>,
  reconnect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<TeamMembers_RoleCreateInput>>>,
  update?: Maybe<Array<Maybe<TeamMembers_RoleUpdateInput>>>,
};

/** TeamMembers relation input */
export type TeamMembersSentTeamInvitationsUpdateRelationInput = {
  connect?: Maybe<Array<TeamInvitationKeyFilter>>,
  disconnect?: Maybe<Array<TeamInvitationKeyFilter>>,
  reconnect?: Maybe<Array<TeamInvitationKeyFilter>>,
};

/** TeamMembers subscription filter */
export type TeamMemberSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<TeamMemberFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** TeamMembers update input */
export type TeamMemberUpdateByFilterInput = {
  status?: Maybe<Array<Maybe<UpdateByFilterStringSwitchInput>>>,
  isOwner?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  learningMode?: Maybe<Scalars['Boolean']>,
};

/** TeamMembers update input */
export type TeamMemberUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  avatar?: Maybe<TeamMembersAvatarUpdateRelationInput>,
  roles?: Maybe<TeamMembersRolesUpdateRelationInput>,
  receivedTeamInvitations?: Maybe<TeamMembersReceivedTeamInvitationsUpdateRelationInput>,
  sentTeamInvitations?: Maybe<TeamMembersSentTeamInvitationsUpdateRelationInput>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  learningMode?: Maybe<Scalars['Boolean']>,
};

/** Text Field Attributes */
export type TextFieldTypeAttributes = {
  __typename?: 'TextFieldTypeAttributes',
  format: Scalars['String'],
  fieldSize?: Maybe<Scalars['Int']>,
};

/** Text Type Format Enum */
export type TextTypeFormatEnum = 
  'UNFORMATTED' |
  'NAME' |
  'EIN' |
  'EMAIL';


export type TrimFunctionArguments = {
  str: Scalars['String'],
  mode?: Maybe<StringTrimMode>,
};

export type UpdateByFilterBooleanSwitchInput = {
  set?: Maybe<Scalars['Boolean']>,
  invert?: Maybe<Scalars['Boolean']>,
};

export type UpdateByFilterDateTimeInput = {
  set?: Maybe<Scalars['String']>,
  add?: Maybe<UpdateByFilterDateTimePartsInput>,
  sub?: Maybe<UpdateByFilterDateTimePartsInput>,
};

export type UpdateByFilterDateTimePartsInput = {
  years?: Maybe<Scalars['Int']>,
  months?: Maybe<Scalars['Int']>,
  days?: Maybe<Scalars['Int']>,
  hours?: Maybe<Scalars['Int']>,
  minutes?: Maybe<Scalars['Int']>,
  seconds?: Maybe<Scalars['Int']>,
  microseconds?: Maybe<Scalars['Int']>,
};

export type UpdateByFilterJsonInput = {
  set?: Maybe<Scalars['JSON']>,
};

export type UpdateByFilterStringInput = {
  prefix?: Maybe<Scalars['String']>,
  postfix?: Maybe<Scalars['String']>,
  set?: Maybe<Scalars['String']>,
};

export type UpdateByFilterStringSwitchInput = {
  set?: Maybe<Scalars['String']>,
};

/** UpdatedFieldsFilter */
export type UpdatedFieldsFilter = {
  contains?: Maybe<Array<Maybe<Scalars['String']>>>,
  every?: Maybe<Array<Maybe<Scalars['String']>>>,
};

export type User = {
  __typename?: 'User',
  id?: Maybe<Scalars['ID']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  updatedAt?: Maybe<Scalars['DateTime']>,
  deletedAt?: Maybe<Scalars['Int']>,
  createdBy?: Maybe<User>,
  email?: Maybe<Scalars['String']>,
  status?: Maybe<Scalars['String']>,
  origin?: Maybe<Scalars['String']>,
  is8base?: Maybe<Scalars['Boolean']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<File>,
  roles?: Maybe<RoleListResponse>,
  channelIdentities?: Maybe<ChannelMemberListResponse>,
  learningMode?: Maybe<Scalars['Boolean']>,
  permissions?: Maybe<UserPermissionList>,
  _description?: Maybe<Scalars['String']>,
};


export type UserRolesArgs = {
  filter?: Maybe<RoleFilter>,
  orderBy?: Maybe<Array<Maybe<RoleOrderBy>>>,
  sort?: Maybe<Array<RoleSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<RoleGroupBy>
};


export type UserChannelIdentitiesArgs = {
  filter?: Maybe<ChannelMemberFilter>,
  orderBy?: Maybe<Array<Maybe<ChannelMemberOrderBy>>>,
  sort?: Maybe<Array<ChannelMemberSort>>,
  skip?: Maybe<Scalars['Int']>,
  after?: Maybe<Scalars['String']>,
  before?: Maybe<Scalars['String']>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  groupBy?: Maybe<ChannelMemberGroupBy>
};


export type UserPermissionsArgs = {
  filter?: Maybe<PermissionInputFilter>
};

/** ChannelMember create input from user */
export type User_ChannelMemberCreateInput = {
  channel: ChannelMemberChannelRelationInput,
  user?: Maybe<ChannelMemberUserRelationInput>,
  lastReadTS?: Maybe<Scalars['DateTime']>,
};

/** ChannelMember update input from user */
export type User_ChannelMemberUpdateInput = {
  filter?: Maybe<ChannelMemberKeyFilter>,
  data: ChannelMemberUpdateInput,
};

export type UserBillingConfigurationResponse = {
  __typename?: 'UserBillingConfigurationResponse',
  isFreePlanAvailable: Scalars['Boolean'],
  isCancelSubscriptionAvailable: Scalars['Boolean'],
  availablePlans: Array<BillingPlanBaseInfo>,
};

/** Users create input */
export type UserCreateInput = {
  email: Scalars['String'],
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarRelationInput>,
  roles?: Maybe<UsersRolesRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesRelationInput>,
};

/** Users create many input */
export type UserCreateManyInput = {
  email: Scalars['String'],
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarManyRelationInput>,
  roles?: Maybe<UsersRolesManyRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesManyRelationInput>,
};

/** Users delete input */
export type UserDeleteInput = {
  id?: Maybe<Scalars['ID']>,
  force?: Maybe<Scalars['Boolean']>,
};

/** UserFieldsPermissions create input */
export type UserFieldsPermissions = {
  createdAt?: Maybe<Scalars['Boolean']>,
  updatedAt?: Maybe<Scalars['Boolean']>,
  email?: Maybe<Scalars['Boolean']>,
  status?: Maybe<Scalars['Boolean']>,
  origin?: Maybe<Scalars['Boolean']>,
  is8base?: Maybe<Scalars['Boolean']>,
  firstName?: Maybe<Scalars['Boolean']>,
  lastName?: Maybe<Scalars['Boolean']>,
  cellPhone?: Maybe<Scalars['Boolean']>,
  workPhone?: Maybe<Scalars['Boolean']>,
  workPhoneExt?: Maybe<Scalars['Boolean']>,
  gender?: Maybe<Scalars['Boolean']>,
  birthday?: Maybe<Scalars['Boolean']>,
  language?: Maybe<Scalars['Boolean']>,
  timezone?: Maybe<Scalars['Boolean']>,
};

export type UserFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  email?: Maybe<StringPredicate>,
  status?: Maybe<StringPredicate>,
  origin?: Maybe<StringPredicate>,
  is8base?: Maybe<BoolPredicate>,
  firstName?: Maybe<StringPredicate>,
  lastName?: Maybe<StringPredicate>,
  cellPhone?: Maybe<StringPredicate>,
  workPhone?: Maybe<StringPredicate>,
  workPhoneExt?: Maybe<StringPredicate>,
  gender?: Maybe<StringPredicate>,
  birthday?: Maybe<StringPredicate>,
  language?: Maybe<StringPredicate>,
  timezone?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  is_self?: Maybe<Scalars['Boolean']>,
  not_self?: Maybe<Scalars['Boolean']>,
  createdBy?: Maybe<UserFilter>,
  avatar?: Maybe<FileFilter>,
  roles?: Maybe<RoleRelationFilter>,
  channelIdentities?: Maybe<ChannelMemberRelationFilter>,
  AND?: Maybe<Array<UserFilter>>,
  OR?: Maybe<Array<UserFilter>>,
};

export type UserGroupBy = {
  query: UserGroupByQuery,
  sort?: Maybe<Array<GroupBySort>>,
  having?: Maybe<Having>,
  first?: Maybe<Scalars['Int']>,
  last?: Maybe<Scalars['Int']>,
  skip?: Maybe<Scalars['Int']>,
};

export type UserGroupByQuery = {
  id?: Maybe<Array<GroupByField>>,
  createdAt?: Maybe<Array<GroupByField>>,
  updatedAt?: Maybe<Array<GroupByField>>,
  email?: Maybe<Array<GroupByField>>,
  status?: Maybe<Array<GroupByField>>,
  origin?: Maybe<Array<GroupByField>>,
  is8base?: Maybe<Array<GroupByField>>,
  firstName?: Maybe<Array<GroupByField>>,
  lastName?: Maybe<Array<GroupByField>>,
  cellPhone?: Maybe<Array<GroupByField>>,
  workPhone?: Maybe<Array<GroupByField>>,
  workPhoneExt?: Maybe<Array<GroupByField>>,
  gender?: Maybe<Array<GroupByField>>,
  birthday?: Maybe<Array<GroupByField>>,
  language?: Maybe<Array<GroupByField>>,
  timezone?: Maybe<Array<GroupByField>>,
  createdBy?: Maybe<UserGroupByQuery>,
  avatar?: Maybe<FileGroupByQuery>,
  roles?: Maybe<RoleGroupByQuery>,
  channelIdentities?: Maybe<ChannelMemberGroupByQuery>,
  _group?: Maybe<Array<GroupIdentifiersGroupByField>>,
};

export type UserInfoAvatar = {
  __typename?: 'UserInfoAvatar',
  id?: Maybe<Scalars['String']>,
  downloadUrl?: Maybe<Scalars['String']>,
};

/** Invitation Details */
export type UserInvitationDetails = {
  __typename?: 'UserInvitationDetails',
  uuid?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  email?: Maybe<Scalars['String']>,
  isRegistered?: Maybe<Scalars['Boolean']>,
  invitedBy?: Maybe<InvitedByName>,
};

/** User Invitation List */
export type UserInvitationList = {
  __typename?: 'UserInvitationList',
  items?: Maybe<Array<Maybe<UserInvitationDetails>>>,
  count?: Maybe<Scalars['Int']>,
};

export type UserKeyFilter = {
  id?: Maybe<Scalars['ID']>,
  email?: Maybe<Scalars['String']>,
};

/** UserListResponse output */
export type UserListResponse = {
  __typename?: 'UserListResponse',
  /** List items */
  items: Array<User>,
  /** List items count */
  count: Scalars['Int'],
  /** Aggregated items */
  groups: Array<GroupByResponse>,
};

/** UserLoginInput */
export type UserLoginInput = {
  email: Scalars['String'],
  password: Scalars['String'],
  fromInvitation?: Maybe<Scalars['String']>,
  authProfileId?: Maybe<Scalars['ID']>,
};

/** UserManyResponse output */
export type UserManyResponse = {
  __typename?: 'UserManyResponse',
  /** List items */
  items: Array<User>,
  /** List items count */
  count: Scalars['Int'],
};

/** No longer supported. Use `sort` instead. */
export type UserOrderBy = 
  'id_ASC' |
  'id_DESC' |
  'createdAt_ASC' |
  'createdAt_DESC' |
  'updatedAt_ASC' |
  'updatedAt_DESC' |
  'deletedAt_ASC' |
  'deletedAt_DESC' |
  'email_ASC' |
  'email_DESC' |
  'status_ASC' |
  'status_DESC' |
  'origin_ASC' |
  'origin_DESC' |
  'isOwner_ASC' |
  'isOwner_DESC' |
  'is8base_ASC' |
  'is8base_DESC' |
  'firstName_ASC' |
  'firstName_DESC' |
  'lastName_ASC' |
  'lastName_DESC' |
  'cellPhone_ASC' |
  'cellPhone_DESC' |
  'workPhone_ASC' |
  'workPhone_DESC' |
  'workPhoneExt_ASC' |
  'workPhoneExt_DESC' |
  'gender_ASC' |
  'gender_DESC' |
  'birthday_ASC' |
  'birthday_DESC' |
  'language_ASC' |
  'language_DESC' |
  'timezone_ASC' |
  'timezone_DESC';

/** Users subscription payload */
export type UserPayload = {
  __typename?: 'UserPayload',
  mutation: MutationType,
  node?: Maybe<User>,
  updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>,
  previousValues?: Maybe<User>,
};

/** User Permission */
export type UserPermission = {
  __typename?: 'UserPermission',
  resourceType?: Maybe<Scalars['String']>,
  resource?: Maybe<Scalars['String']>,
  permission?: Maybe<Scalars['JSON']>,
};

export type UserPermissionFilter = {
  id?: Maybe<IdPredicate>,
  createdAt?: Maybe<DateTimePredicate>,
  updatedAt?: Maybe<DateTimePredicate>,
  deletedAt?: Maybe<IntPredicate>,
  email?: Maybe<StringPredicate>,
  status?: Maybe<StringPredicate>,
  origin?: Maybe<StringPredicate>,
  is8base?: Maybe<BoolPredicate>,
  firstName?: Maybe<StringPredicate>,
  lastName?: Maybe<StringPredicate>,
  cellPhone?: Maybe<StringPredicate>,
  workPhone?: Maybe<StringPredicate>,
  workPhoneExt?: Maybe<StringPredicate>,
  gender?: Maybe<StringPredicate>,
  birthday?: Maybe<StringPredicate>,
  language?: Maybe<StringPredicate>,
  timezone?: Maybe<StringPredicate>,
  _fullText?: Maybe<Scalars['String']>,
  is_self?: Maybe<Scalars['Boolean']>,
  not_self?: Maybe<Scalars['Boolean']>,
  createdBy?: Maybe<UserPermissionFilter>,
  avatar?: Maybe<FilePermissionFilter>,
  roles?: Maybe<RolePermissionRelationFilter>,
  channelIdentities?: Maybe<ChannelMemberPermissionRelationFilter>,
  AND?: Maybe<Array<UserPermissionFilter>>,
  OR?: Maybe<Array<UserPermissionFilter>>,
};

/** User Permission List */
export type UserPermissionList = {
  __typename?: 'UserPermissionList',
  items?: Maybe<Array<UserPermission>>,
  count: Scalars['Int'],
};

export type UserPermissionRelationFilter = {
  some?: Maybe<UserPermissionFilter>,
  every?: Maybe<UserPermissionFilter>,
  none?: Maybe<UserPermissionFilter>,
};

export type UserRelationFilter = {
  some?: Maybe<UserFilter>,
  every?: Maybe<UserFilter>,
  none?: Maybe<UserFilter>,
};

/** Files create input from users_avatar */
export type Users_Avatar_FileCreateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarRelationInput>,
};

/** Files update input from users_avatar */
export type Users_Avatar_FileUpdateInput = {
  fileId?: Maybe<Scalars['String']>,
  public?: Maybe<Scalars['Boolean']>,
  filename?: Maybe<Scalars['String']>,
  meta?: Maybe<Scalars['JSON']>,
  mods?: Maybe<Scalars['JSON']>,
  users_avatar?: Maybe<FilesUsers_AvatarUpdateRelationInput>,
  message_attachments?: Maybe<FilesMessage_AttachmentsUpdateRelationInput>,
  teamMembers_avatar?: Maybe<FilesTeamMembers_AvatarUpdateRelationInput>,
};

/** Roles create input from users */
export type Users_RoleCreateInput = {
  name: Scalars['String'],
  description?: Maybe<Scalars['String']>,
  users?: Maybe<RolesUsersRelationInput>,
  permissions?: Maybe<PermissionsInput>,
  apiTokens?: Maybe<RolesApiTokensRelationInput>,
  authenticationProfiles?: Maybe<RolesAuthenticationProfilesRelationInput>,
  teamMembers?: Maybe<RolesTeamMembersRelationInput>,
};

/** Roles update input from users */
export type Users_RoleUpdateInput = {
  filter?: Maybe<RoleKeyFilter>,
  data: RoleUpdateInput,
};

/** Users relation input */
export type UsersAvatarManyRelationInput = {
  connect?: Maybe<FileKeyFilter>,
};

/** Users relation input */
export type UsersAvatarRelationInput = {
  connect?: Maybe<FileKeyFilter>,
  create?: Maybe<Users_Avatar_FileCreateInput>,
};

/** Users relation input */
export type UsersAvatarUpdateRelationInput = {
  connect?: Maybe<FileKeyFilter>,
  disconnect?: Maybe<FileKeyFilter>,
  reconnect?: Maybe<FileKeyFilter>,
  create?: Maybe<Users_Avatar_FileCreateInput>,
  update?: Maybe<Users_Avatar_FileUpdateInput>,
};

/** Users relation input */
export type UsersChannelIdentitiesManyRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
};

/** Users relation input */
export type UsersChannelIdentitiesRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
  create?: Maybe<Array<Maybe<User_ChannelMemberCreateInput>>>,
};

/** Users relation input */
export type UsersChannelIdentitiesUpdateRelationInput = {
  connect?: Maybe<Array<ChannelMemberKeyFilter>>,
  disconnect?: Maybe<Array<ChannelMemberKeyFilter>>,
  reconnect?: Maybe<Array<ChannelMemberKeyFilter>>,
  create?: Maybe<Array<Maybe<User_ChannelMemberCreateInput>>>,
  update?: Maybe<Array<Maybe<User_ChannelMemberUpdateInput>>>,
};

export type UserSort = {
  id?: Maybe<SortOrder>,
  createdAt?: Maybe<SortOrder>,
  updatedAt?: Maybe<SortOrder>,
  deletedAt?: Maybe<SortOrder>,
  email?: Maybe<SortOrder>,
  status?: Maybe<SortOrder>,
  origin?: Maybe<SortOrder>,
  is8base?: Maybe<SortOrder>,
  firstName?: Maybe<SortOrder>,
  lastName?: Maybe<SortOrder>,
  cellPhone?: Maybe<SortOrder>,
  workPhone?: Maybe<SortOrder>,
  workPhoneExt?: Maybe<SortOrder>,
  gender?: Maybe<SortOrder>,
  birthday?: Maybe<SortOrder>,
  language?: Maybe<SortOrder>,
  timezone?: Maybe<SortOrder>,
  createdBy?: Maybe<UserSort>,
  avatar?: Maybe<FileSort>,
};

/** Users relation input */
export type UsersRolesManyRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
};

/** Users relation input */
export type UsersRolesRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<Users_RoleCreateInput>>>,
};

/** Users relation input */
export type UsersRolesUpdateRelationInput = {
  connect?: Maybe<Array<RoleKeyFilter>>,
  disconnect?: Maybe<Array<RoleKeyFilter>>,
  reconnect?: Maybe<Array<RoleKeyFilter>>,
  create?: Maybe<Array<Maybe<Users_RoleCreateInput>>>,
  update?: Maybe<Array<Maybe<Users_RoleUpdateInput>>>,
};

/** Users subscription filter */
export type UserSubscriptionFilter = {
  mutation_in?: Maybe<Array<Maybe<MutationType>>>,
  node?: Maybe<UserFilter>,
  updatedFields?: Maybe<UpdatedFieldsFilter>,
};

/** Users update input */
export type UserUpdateByFilterInput = {
  email?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  status?: Maybe<Array<Maybe<UpdateByFilterStringSwitchInput>>>,
  origin?: Maybe<Array<Maybe<UpdateByFilterStringSwitchInput>>>,
  isOwner?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  is8base?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>,
  firstName?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  lastName?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  cellPhone?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  workPhone?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  workPhoneExt?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  gender?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  birthday?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  language?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
  timezone?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>,
};

/** Users update input */
export type UserUpdateInput = {
  id?: Maybe<Scalars['ID']>,
  email?: Maybe<Scalars['String']>,
  status?: Maybe<Scalars['String']>,
  firstName?: Maybe<Scalars['String']>,
  lastName?: Maybe<Scalars['String']>,
  cellPhone?: Maybe<Scalars['String']>,
  workPhone?: Maybe<Scalars['String']>,
  workPhoneExt?: Maybe<Scalars['String']>,
  gender?: Maybe<Scalars['String']>,
  birthday?: Maybe<Scalars['String']>,
  language?: Maybe<Scalars['String']>,
  timezone?: Maybe<Scalars['String']>,
  avatar?: Maybe<UsersAvatarUpdateRelationInput>,
  roles?: Maybe<UsersRolesUpdateRelationInput>,
  channelIdentities?: Maybe<UsersChannelIdentitiesUpdateRelationInput>,
};

/** UUID Field Attributes */
export type UuidFieldTypeAttributes = {
  __typename?: 'UUIDFieldTypeAttributes',
  fieldSize?: Maybe<Scalars['Int']>,
};

/** VerificationEmailResendInput */
export type VerificationEmailResendInput = {
  email: Scalars['String'],
};

/** View Attributes */
export type ViewAttributes = {
  __typename?: 'ViewAttributes',
  query?: Maybe<Scalars['String']>,
};

/** View Create Input */
export type ViewCreateInput = {
  name: Scalars['String'],
  displayName?: Maybe<Scalars['String']>,
  query: Scalars['String'],
  description?: Maybe<Scalars['String']>,
};

/** View Update Input */
export type ViewUpdateInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
  displayName?: Maybe<Scalars['String']>,
  query?: Maybe<Scalars['String']>,
  description?: Maybe<Scalars['String']>,
};

/** WorkspaceCreateMutationInput */
export type WorkspaceCreateMutationInput = {
  name: Scalars['String'],
  billingPlanId?: Maybe<Scalars['ID']>,
};

export type WorkspaceCreateResponse = {
  __typename?: 'WorkspaceCreateResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

/** WorkspaceDeleteMutationInput */
export type WorkspaceDeleteMutationInput = {
  id: Scalars['ID'],
};

/** LoginResponseWorkspace name and id */
export type WorkspaceInfo = {
  __typename?: 'WorkspaceInfo',
  workspace?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};

export type WorkspaceItem = {
  __typename?: 'WorkspaceItem',
  id: Scalars['ID'],
  name: Scalars['String'],
  isOwner: Scalars['Boolean'],
  plan?: Maybe<BillingCurrentPlanResponse>,
  lastAccess?: Maybe<Scalars['DateTime']>,
  createdAt?: Maybe<Scalars['DateTime']>,
  teamMemberCount?: Maybe<Scalars['Int']>,
  owner?: Maybe<SystemUserAccountInfo>,
  image?: Maybe<SystemWorkspaceImage>,
};

/** WorkspaceListResponse output */
export type WorkspaceListResponse = {
  __typename?: 'WorkspaceListResponse',
  /** List items */
  items: Array<WorkspaceItem>,
  /** List items count */
  count: Scalars['Int'],
};

export type WorkspaceStatus = 
  'active' |
  'blocked' |
  'canceled' |
  'suspended' |
  'canceling' |
  'pending';

/** WorkspaceUpdateMutationInput */
export type WorkspaceUpdateMutationInput = {
  id: Scalars['ID'],
  name?: Maybe<Scalars['String']>,
};

export type WorkspaceUpdateResponse = {
  __typename?: 'WorkspaceUpdateResponse',
  id?: Maybe<Scalars['ID']>,
  name?: Maybe<Scalars['String']>,
};
export type ChannelPreviewCommonFragment = ({ __typename?: 'Channel' } & Pick<Channel, 'id' | 'name' | 'public' | 'type'> & { createdBy: Maybe<({ __typename?: 'User' } & Pick<User, 'id'>)>, messages: Maybe<({ __typename?: 'MessageListResponse' } & { items: Array<({ __typename?: 'Message' } & Pick<Message, 'createdAt'> & { createdBy: Maybe<({ __typename?: 'User' } & Pick<User, 'id'>)> })> })> });

export type ChannelPreviewFragment = ({ __typename?: 'Channel' } & { members: Maybe<({ __typename?: 'ChannelMemberListResponse' } & Pick<ChannelMemberListResponse, 'count'>)> } & ChannelPreviewCommonFragment);

export type DmPreviewFragment = ({ __typename?: 'Channel' } & { members: Maybe<({ __typename?: 'ChannelMemberListResponse' } & Pick<ChannelMemberListResponse, 'count'> & { items: Array<({ __typename?: 'ChannelMember' } & { user: Maybe<({ __typename?: 'User' } & UserFullnameFragment)> })> })> } & ChannelPreviewCommonFragment);

export type ChannelMemberFragment = ({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id'> & { user: Maybe<({ __typename?: 'User' } & { avatar: Maybe<({ __typename?: 'File' } & ImageFragment)> } & UserFullnameFragment)> });

export type ChannelIdentityCommonFragment = ({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id' | 'lastReadTS' | 'hasUnreads'> & { user: Maybe<({ __typename?: 'User' } & Pick<User, 'id'>)> });

export type ChannelIdentityFragment = ({ __typename?: 'ChannelMember' } & { channel: Maybe<({ __typename?: 'Channel' } & ChannelPreviewFragment)> } & ChannelIdentityCommonFragment);

export type DmIdentityFragment = ({ __typename?: 'ChannelMember' } & { channel: Maybe<({ __typename?: 'Channel' } & DmPreviewFragment)> } & ChannelIdentityCommonFragment);

export type ChannelMessagesQueryVariables = {
  id: Scalars['ID'],
  filter?: Maybe<MessageFilter>,
  orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>,
  last?: Maybe<Scalars['Int']>,
  before?: Maybe<Scalars['String']>
};


export type ChannelMessagesQuery = ({ __typename?: 'Query' } & { channel: Maybe<({ __typename?: 'Channel' } & Pick<Channel, 'id'> & { messages: Maybe<({ __typename?: 'MessageListResponse' } & Pick<MessageListResponse, 'count'> & { items: Array<({ __typename?: 'Message' } & MessageFragment)> })> })> });

export type ChannelMembersQueryVariables = {
  id: Scalars['ID'],
  first?: Maybe<Scalars['Int']>
};


export type ChannelMembersQuery = ({ __typename?: 'Query' } & { channel: Maybe<({ __typename?: 'Channel' } & Pick<Channel, 'id'> & { members: Maybe<({ __typename?: 'ChannelMemberListResponse' } & Pick<ChannelMemberListResponse, 'count'> & { items: Array<({ __typename?: 'ChannelMember' } & ChannelMemberFragment)> })> })> });

export type ChannelFormQueryVariables = {
  id: Scalars['ID']
};


export type ChannelFormQuery = ({ __typename?: 'Query' } & { channel: Maybe<({ __typename?: 'Channel' } & Pick<Channel, 'id' | 'name' | 'purpose'>)> });

export type ChannelsSearchQueryVariables = {
  first: Scalars['Int'],
  searchText: Scalars['String'],
  userId: Scalars['ID']
};


export type ChannelsSearchQuery = ({ __typename?: 'Query' } & { channelsList: ({ __typename?: 'ChannelListResponse' } & { items: Array<({ __typename?: 'Channel' } & Pick<Channel, 'id' | 'name'> & { members: Maybe<({ __typename?: 'ChannelMemberListResponse' } & Pick<ChannelMemberListResponse, 'count'> & { items: Array<({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id'> & { user: Maybe<({ __typename?: 'User' } & { avatar: Maybe<({ __typename?: 'File' } & ImageFragment)> } & UserFullnameFragment)> })> })> })> }) });

export type ChannelCreateMutationVariables = {
  data: ChannelCreateInput
};


export type ChannelCreateMutation = ({ __typename?: 'Mutation' } & { channelCreate: ({ __typename?: 'Channel' } & Pick<Channel, 'id' | 'name'> & { members: Maybe<({ __typename?: 'ChannelMemberListResponse' } & { items: Array<({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id'> & { user: Maybe<({ __typename?: 'User' } & Pick<User, 'id'>)> })> })> }) });

export type ChannelDeleteMutationVariables = {
  id: Scalars['ID']
};


export type ChannelDeleteMutation = ({ __typename?: 'Mutation' } & { channelDelete: Maybe<({ __typename?: 'SuccessResponse' } & Pick<SuccessResponse, 'success'>)> });

export type FindOrCreateDmMutationVariables = {
  usersIds: Array<Scalars['ID']>
  channelMembersFilter?: ChannelMemberFilter
};


export type FindOrCreateDmMutation = ({ __typename?: 'Mutation' } & { findOrCreateDM: Maybe<({ __typename?: 'FindOrCreateDMResponse' } & Pick<FindOrCreateDmResponse, 'id' | 'name'> & { members: ({ __typename?: 'FindOrCreateDMMemberList' } & { items: Array<({ __typename?: 'FindOrCreateDMMember' } & Pick<FindOrCreateDmMember, 'id'> & { user: ({ __typename?: 'FindOrCreateDMUser' } & Pick<FindOrCreateDmUser, 'id'>) })> }) })> });

export type ChannelMemberUpdateMutationVariables = {
  id: Scalars['ID'],
  lastReadTS: Scalars['DateTime']
};


export type ChannelMemberUpdateMutation = ({ __typename?: 'Mutation' } & { channelMemberUpdate: ({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id' | 'lastReadTS'>) });

export type ChannelMemberDeleteMutationVariables = {
  id: Scalars['ID']
};


export type ChannelMemberDeleteMutation = ({ __typename?: 'Mutation' } & { channelMemberDelete: Maybe<({ __typename?: 'SuccessResponse' } & Pick<SuccessResponse, 'success'>)> });

export type ChannelMemberCreateMutationVariables = {
  data: ChannelMemberCreateInput
};


export type ChannelMemberCreateMutation = ({ __typename?: 'Mutation' } & { channelMemberCreate: ({ __typename?: 'ChannelMember' } & Pick<ChannelMember, 'id'>) });

export type ChannelUpdateMutationVariables = {
  data: ChannelUpdateInput
};


export type ChannelUpdateMutation = ({ __typename?: 'Mutation' } & { channelUpdate: ({ __typename?: 'Channel' } & Pick<Channel, 'id'>) });

export type UserChannelIdentitiesSubSubscriptionVariables = {
  userId: Scalars['ID']
};


export type UserChannelIdentitiesSubSubscription = ({ __typename?: 'Subscription' } & { ChannelMember: Maybe<({ __typename?: 'ChannelMemberPayload' } & { node: Maybe<({ __typename?: 'ChannelMember' } & ChannelIdentityFragment)> })> });

export type ImageFragment = ({ __typename?: 'File' } & Pick<File, 'id' | 'downloadUrl'>);

export type AttachmentFragment = ({ __typename?: 'File' } & Pick<File, 'id' | 'createdAt' | 'fileId' | 'downloadUrl' | 'filename' | 'previewUrl'>);

export type FileDeleteMutationVariables = {
  data: FileDeleteInput
};


export type FileDeleteMutation = ({ __typename?: 'Mutation' } & { fileDelete: Maybe<({ __typename?: 'SuccessResponse' } & Pick<SuccessResponse, 'success'>)> });

export type MessageFragment = ({ __typename?: 'Message' } & Pick<Message, 'id' | 'createdAt' | 'text'> & { createdBy: Maybe<({ __typename?: 'User' } & UserPreviewFragment)>, attachments: Maybe<({ __typename?: 'FileListResponse' } & { items: Array<({ __typename?: 'File' } & AttachmentFragment)> })> });

export type MessageCreateMutationVariables = {
  data: MessageCreateInput
};


export type MessageCreateMutation = ({ __typename?: 'Mutation' } & { messageCreate: ({ __typename?: 'Message' } & MessageFragment) });

export type MessageDeleteMutationVariables = {
  data: MessageDeleteInput
};


export type MessageDeleteMutation = ({ __typename?: 'Mutation' } & { messageDelete: Maybe<({ __typename?: 'SuccessResponse' } & Pick<SuccessResponse, 'success'>)> });

export type MessageUpdateMutationVariables = {
  data: MessageUpdateInput
};


export type MessageUpdateMutation = ({ __typename?: 'Mutation' } & { messageUpdate: ({ __typename?: 'Message' } & Pick<Message, 'id'>) });

export type UserChannelsMessagesSubSubscriptionVariables = {
  userId: Scalars['ID']
};


export type UserChannelsMessagesSubSubscription = ({ __typename?: 'Subscription' } & { Message: Maybe<({ __typename?: 'MessagePayload' } & Pick<MessagePayload, 'mutation'> & { node: Maybe<({ __typename?: 'Message' } & Pick<Message, 'isDeleted'> & { channel: Maybe<({ __typename?: 'Channel' } & Pick<Channel, 'id' | 'type'>)> } & MessageFragment)> })> });

export type UserFullnameFragment = ({ __typename?: 'User' } & Pick<User, 'id' | 'firstName' | 'lastName'>);

export type UserPreviewFragment = ({ __typename?: 'User' } & { avatar: Maybe<({ __typename?: 'File' } & ImageFragment)> } & UserFullnameFragment);

export type UserChannelsPreviewQueryVariables = {
  id?: Maybe<Scalars['ID']>,
  channelMembersFilter?: ChannelMemberFilter
};


export type UserChannelsPreviewQuery = ({ __typename?: 'Query' } & { user: Maybe<({ __typename?: 'User' } & Pick<User, 'id'> & { channelIdentities: Maybe<({ __typename?: 'ChannelMemberListResponse' } & { items: Array<({ __typename?: 'ChannelMember' } & ChannelIdentityFragment)> })> })> });

export type UserDmsPreviewQueryVariables = {
  id?: Maybe<Scalars['ID']>,
  channelMembersFilter?: ChannelMemberFilter
};


export type UserDmsPreviewQuery = ({ __typename?: 'Query' } & { user: Maybe<({ __typename?: 'User' } & Pick<User, 'id'> & { channelIdentities: Maybe<({ __typename?: 'ChannelMemberListResponse' } & { items: Array<({ __typename?: 'ChannelMember' } & DmIdentityFragment)> })> })> });

export type UserContactsPreviewQueryVariables = {
  filter: UserFilter
};


export type UserContactsPreviewQuery = ({ __typename?: 'Query' } & { usersList: ({ __typename?: 'UserListResponse' } & { items: Array<({ __typename?: 'User' } & UserPreviewFragment)> }) });

export type UsersSearchQueryVariables = {
  first: Scalars['Int'],
  searchText: Scalars['String'],
  channelId: Scalars['ID'],
  usersFilter: UserFilter
};


export type UsersSearchQuery = ({ __typename?: 'Query' } & { usersList: ({ __typename?: 'UserListResponse' } & { items: Array<({ __typename?: 'User' } & UserPreviewFragment)> }) });

export type UsersDmSearchQueryVariables = {
  first: Scalars['Int'],
  searchText: Scalars['String'],
  idNotIn?: Maybe<Array<Scalars['ID']>>
};


export type UsersDmSearchQuery = ({ __typename?: 'Query' } & { usersList: ({ __typename?: 'UserListResponse' } & { items: Array<({ __typename?: 'User' } & UserPreviewFragment)> }) });
export const UserFullnameFragmentDoc = gql`
    fragment UserFullname on User {
  id
  firstName
  lastName
}
    `;
export const ImageFragmentDoc = gql`
    fragment Image on File {
  id
  downloadUrl
}
    `;
export const ChannelMemberFragmentDoc = gql`
    fragment ChannelMember on ChannelMember {
  id
  user {
    ...UserFullname
    avatar {
      ...Image
    }
  }
}
    ${UserFullnameFragmentDoc}
${ImageFragmentDoc}`;
export const ChannelIdentityCommonFragmentDoc = gql`
    fragment ChannelIdentityCommon on ChannelMember {
  id
  user {
    id
  }
  lastReadTS
  hasUnreads @client
}
    `;
export const ChannelPreviewCommonFragmentDoc = gql`
    fragment ChannelPreviewCommon on Channel {
  id
  name
  public
  type
  createdBy {
    id
  }
  messages(last: 1) {
    items {
      createdAt
      createdBy {
        id
      }
    }
  }
}
    `;
export const ChannelPreviewFragmentDoc = gql`
    fragment ChannelPreview on Channel {
  ...ChannelPreviewCommon
  members {
    count
  }
}
    ${ChannelPreviewCommonFragmentDoc}`;
export const ChannelIdentityFragmentDoc = gql`
    fragment ChannelIdentity on ChannelMember {
  ...ChannelIdentityCommon
  channel {
    ...ChannelPreview
  }
}
    ${ChannelIdentityCommonFragmentDoc}
${ChannelPreviewFragmentDoc}`;
export const DmPreviewFragmentDoc = gql`
    fragment DmPreview on Channel {
  ...ChannelPreviewCommon
  members {
    count
    items {
      user {
        ...UserFullname
      }
    }
  }
}
    ${ChannelPreviewCommonFragmentDoc}
${UserFullnameFragmentDoc}`;
export const DmIdentityFragmentDoc = gql`
    fragment DmIdentity on ChannelMember {
  ...ChannelIdentityCommon
  channel {
    ...DmPreview
  }
}
    ${ChannelIdentityCommonFragmentDoc}
${DmPreviewFragmentDoc}`;
export const UserPreviewFragmentDoc = gql`
    fragment UserPreview on User {
  ...UserFullname
  avatar {
    ...Image
  }
}
    ${UserFullnameFragmentDoc}
${ImageFragmentDoc}`;
export const AttachmentFragmentDoc = gql`
    fragment Attachment on File {
  id
  createdAt
  fileId
  downloadUrl
  filename
  previewUrl
}
    `;
export const MessageFragmentDoc = gql`
    fragment Message on Message {
  id
  createdAt
  createdBy {
    ...UserPreview
  }
  text
  attachments {
    items {
      ...Attachment
    }
  }
}
    ${UserPreviewFragmentDoc}
${AttachmentFragmentDoc}`;
export const ChannelMessagesDocument = gql`
    query ChannelMessages($id: ID!, $filter: MessageFilter, $orderBy: [MessageOrderBy], $last: Int, $before: String) {
  channel(id: $id) {
    id
    messages(filter: $filter, last: $last, before: $before, orderBy: $orderBy) {
      count
      items {
        ...Message
      }
    }
  }
}
    ${MessageFragmentDoc}`;
export type ChannelMessagesComponentProps = Omit<ReactApollo.QueryProps<ChannelMessagesQuery, ChannelMessagesQueryVariables>, 'query'> & ({ variables: ChannelMessagesQueryVariables; skip?: false; } | { skip: true; });

    export const ChannelMessagesComponent = (props: ChannelMessagesComponentProps) => (
      <ReactApollo.Query<ChannelMessagesQuery, ChannelMessagesQueryVariables> query={ChannelMessagesDocument} {...props} />
    );
    
export type ChannelMessagesProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelMessagesQuery, ChannelMessagesQueryVariables>> & TChildProps;
export function withChannelMessages<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelMessagesQuery,
  ChannelMessagesQueryVariables,
  ChannelMessagesProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, ChannelMessagesQuery, ChannelMessagesQueryVariables, ChannelMessagesProps<TChildProps>>(ChannelMessagesDocument, {
      alias: 'withChannelMessages',
      ...operationOptions
    });
};
export const ChannelMembersDocument = gql`
    query ChannelMembers($id: ID!, $first: Int) {
  channel(id: $id) {
    id
    members(first: $first) {
      count
      items {
        ...ChannelMember
      }
    }
  }
}
    ${ChannelMemberFragmentDoc}`;
export type ChannelMembersComponentProps = Omit<ReactApollo.QueryProps<ChannelMembersQuery, ChannelMembersQueryVariables>, 'query'> & ({ variables: ChannelMembersQueryVariables; skip?: false; } | { skip: true; });

    export const ChannelMembersComponent = (props: ChannelMembersComponentProps) => (
      <ReactApollo.Query<ChannelMembersQuery, ChannelMembersQueryVariables> query={ChannelMembersDocument} {...props} />
    );
    
export type ChannelMembersProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelMembersQuery, ChannelMembersQueryVariables>> & TChildProps;
export function withChannelMembers<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelMembersQuery,
  ChannelMembersQueryVariables,
  ChannelMembersProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, ChannelMembersQuery, ChannelMembersQueryVariables, ChannelMembersProps<TChildProps>>(ChannelMembersDocument, {
      alias: 'withChannelMembers',
      ...operationOptions
    });
};
export const ChannelFormDocument = gql`
    query ChannelForm($id: ID!) {
  channel(id: $id) {
    id
    name
    purpose
  }
}
    `;
export type ChannelFormComponentProps = Omit<ReactApollo.QueryProps<ChannelFormQuery, ChannelFormQueryVariables>, 'query'> & ({ variables: ChannelFormQueryVariables; skip?: false; } | { skip: true; });

    export const ChannelFormComponent = (props: ChannelFormComponentProps) => (
      <ReactApollo.Query<ChannelFormQuery, ChannelFormQueryVariables> query={ChannelFormDocument} {...props} />
    );
    
export type ChannelFormProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelFormQuery, ChannelFormQueryVariables>> & TChildProps;
export function withChannelForm<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelFormQuery,
  ChannelFormQueryVariables,
  ChannelFormProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, ChannelFormQuery, ChannelFormQueryVariables, ChannelFormProps<TChildProps>>(ChannelFormDocument, {
      alias: 'withChannelForm',
      ...operationOptions
    });
};
export const ChannelsSearchDocument = gql`
    query ChannelsSearch($first: Int!, $searchText: String!, $userId: ID!) {
  channelsList(first: $first, filter: {name: {contains: $searchText}, members: {none: {user: {id: {equals: $userId}}}}, public: {equals: true}, type: {equals: "channel"}}) {
    items {
      id
      name
      members(first: 3) {
        count
        items {
          id
          user {
            ...UserFullname
            avatar {
              ...Image
            }
          }
        }
      }
    }
  }
}
    ${UserFullnameFragmentDoc}
${ImageFragmentDoc}`;
export type ChannelsSearchComponentProps = Omit<ReactApollo.QueryProps<ChannelsSearchQuery, ChannelsSearchQueryVariables>, 'query'> & ({ variables: ChannelsSearchQueryVariables; skip?: false; } | { skip: true; });

    export const ChannelsSearchComponent = (props: ChannelsSearchComponentProps) => (
      <ReactApollo.Query<ChannelsSearchQuery, ChannelsSearchQueryVariables> query={ChannelsSearchDocument} {...props} />
    );
    
export type ChannelsSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelsSearchQuery, ChannelsSearchQueryVariables>> & TChildProps;
export function withChannelsSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelsSearchQuery,
  ChannelsSearchQueryVariables,
  ChannelsSearchProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, ChannelsSearchQuery, ChannelsSearchQueryVariables, ChannelsSearchProps<TChildProps>>(ChannelsSearchDocument, {
      alias: 'withChannelsSearch',
      ...operationOptions
    });
};
export const ChannelCreateDocument = gql`
    mutation ChannelCreate($data: ChannelCreateInput!) {
  channelCreate(data: $data) {
    id
    name
    members {
      items {
        id
        user {
          id
        }
      }
    }
  }
}
    `;
export type ChannelCreateMutationFn = ReactApollo.MutationFn<ChannelCreateMutation, ChannelCreateMutationVariables>;
export type ChannelCreateComponentProps = Omit<ReactApollo.MutationProps<ChannelCreateMutation, ChannelCreateMutationVariables>, 'mutation'>;

    export const ChannelCreateComponent = (props: ChannelCreateComponentProps) => (
      <ReactApollo.Mutation<ChannelCreateMutation, ChannelCreateMutationVariables> mutation={ChannelCreateDocument} {...props} />
    );
    
export type ChannelCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelCreateMutation, ChannelCreateMutationVariables>> & TChildProps;
export function withChannelCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelCreateMutation,
  ChannelCreateMutationVariables,
  ChannelCreateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelCreateMutation, ChannelCreateMutationVariables, ChannelCreateProps<TChildProps>>(ChannelCreateDocument, {
      alias: 'withChannelCreate',
      ...operationOptions
    });
};
export const ChannelDeleteDocument = gql`
    mutation ChannelDelete($id: ID!) {
  channelDelete(data: {id: $id}, force: true) {
    success
  }
}
    `;
export type ChannelDeleteMutationFn = ReactApollo.MutationFn<ChannelDeleteMutation, ChannelDeleteMutationVariables>;
export type ChannelDeleteComponentProps = Omit<ReactApollo.MutationProps<ChannelDeleteMutation, ChannelDeleteMutationVariables>, 'mutation'>;

    export const ChannelDeleteComponent = (props: ChannelDeleteComponentProps) => (
      <ReactApollo.Mutation<ChannelDeleteMutation, ChannelDeleteMutationVariables> mutation={ChannelDeleteDocument} {...props} />
    );
    
export type ChannelDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelDeleteMutation, ChannelDeleteMutationVariables>> & TChildProps;
export function withChannelDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelDeleteMutation,
  ChannelDeleteMutationVariables,
  ChannelDeleteProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelDeleteMutation, ChannelDeleteMutationVariables, ChannelDeleteProps<TChildProps>>(ChannelDeleteDocument, {
      alias: 'withChannelDelete',
      ...operationOptions
    });
};
export const FindOrCreateDmDocument = gql`
mutation($usersIds: [ID!]!, $channelMembersFilter: ChannelMemberFilter){
  findOrCreateDM(data:{ usersIds: $usersIds, channelMembersFilter: $channelMembersFilter }){
    id
    name
    members {
      items {
        id
        user {
          id
        }
      }
    }
  }
}
    `;
export type FindOrCreateDmMutationFn = ReactApollo.MutationFn<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>;
export type FindOrCreateDmComponentProps = Omit<ReactApollo.MutationProps<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>, 'mutation'>;

    export const FindOrCreateDmComponent = (props: FindOrCreateDmComponentProps) => (
      <ReactApollo.Mutation<FindOrCreateDmMutation, FindOrCreateDmMutationVariables> mutation={FindOrCreateDmDocument} {...props} />
    );
    
export type FindOrCreateDmProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>> & TChildProps;
export function withFindOrCreateDm<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  FindOrCreateDmMutation,
  FindOrCreateDmMutationVariables,
  FindOrCreateDmProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, FindOrCreateDmMutation, FindOrCreateDmMutationVariables, FindOrCreateDmProps<TChildProps>>(FindOrCreateDmDocument, {
      alias: 'withFindOrCreateDm',
      ...operationOptions
    });
};
export const ChannelMemberUpdateDocument = gql`
    mutation ChannelMemberUpdate($id: ID!, $lastReadTS: DateTime!) {
  channelMemberUpdate(data: {id: $id, lastReadTS: $lastReadTS}) {
    id
    lastReadTS
  }
}
    `;
export type ChannelMemberUpdateMutationFn = ReactApollo.MutationFn<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>;
export type ChannelMemberUpdateComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>, 'mutation'>;

    export const ChannelMemberUpdateComponent = (props: ChannelMemberUpdateComponentProps) => (
      <ReactApollo.Mutation<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables> mutation={ChannelMemberUpdateDocument} {...props} />
    );
    
export type ChannelMemberUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>> & TChildProps;
export function withChannelMemberUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelMemberUpdateMutation,
  ChannelMemberUpdateMutationVariables,
  ChannelMemberUpdateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables, ChannelMemberUpdateProps<TChildProps>>(ChannelMemberUpdateDocument, {
      alias: 'withChannelMemberUpdate',
      ...operationOptions
    });
};
export const ChannelMemberDeleteDocument = gql`
    mutation ChannelMemberDelete($id: ID!) {
  channelMemberDelete(data: {id: $id}) {
    success
  }
}
    `;
export type ChannelMemberDeleteMutationFn = ReactApollo.MutationFn<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>;
export type ChannelMemberDeleteComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>, 'mutation'>;

    export const ChannelMemberDeleteComponent = (props: ChannelMemberDeleteComponentProps) => (
      <ReactApollo.Mutation<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables> mutation={ChannelMemberDeleteDocument} {...props} />
    );
    
export type ChannelMemberDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>> & TChildProps;
export function withChannelMemberDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelMemberDeleteMutation,
  ChannelMemberDeleteMutationVariables,
  ChannelMemberDeleteProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables, ChannelMemberDeleteProps<TChildProps>>(ChannelMemberDeleteDocument, {
      alias: 'withChannelMemberDelete',
      ...operationOptions
    });
};
export const ChannelMemberCreateDocument = gql`
    mutation ChannelMemberCreate($data: ChannelMemberCreateInput!) {
  channelMemberCreate(data: $data) {
    id
  }
}
    `;
export type ChannelMemberCreateMutationFn = ReactApollo.MutationFn<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>;
export type ChannelMemberCreateComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>, 'mutation'>;

    export const ChannelMemberCreateComponent = (props: ChannelMemberCreateComponentProps) => (
      <ReactApollo.Mutation<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables> mutation={ChannelMemberCreateDocument} {...props} />
    );
    
export type ChannelMemberCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>> & TChildProps;
export function withChannelMemberCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelMemberCreateMutation,
  ChannelMemberCreateMutationVariables,
  ChannelMemberCreateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables, ChannelMemberCreateProps<TChildProps>>(ChannelMemberCreateDocument, {
      alias: 'withChannelMemberCreate',
      ...operationOptions
    });
};
export const ChannelUpdateDocument = gql`
    mutation ChannelUpdate($data: ChannelUpdateInput!) {
  channelUpdate(data: $data) {
    id
  }
}
    `;
export type ChannelUpdateMutationFn = ReactApollo.MutationFn<ChannelUpdateMutation, ChannelUpdateMutationVariables>;
export type ChannelUpdateComponentProps = Omit<ReactApollo.MutationProps<ChannelUpdateMutation, ChannelUpdateMutationVariables>, 'mutation'>;

    export const ChannelUpdateComponent = (props: ChannelUpdateComponentProps) => (
      <ReactApollo.Mutation<ChannelUpdateMutation, ChannelUpdateMutationVariables> mutation={ChannelUpdateDocument} {...props} />
    );
    
export type ChannelUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelUpdateMutation, ChannelUpdateMutationVariables>> & TChildProps;
export function withChannelUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  ChannelUpdateMutation,
  ChannelUpdateMutationVariables,
  ChannelUpdateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, ChannelUpdateMutation, ChannelUpdateMutationVariables, ChannelUpdateProps<TChildProps>>(ChannelUpdateDocument, {
      alias: 'withChannelUpdate',
      ...operationOptions
    });
};
export const UserChannelIdentitiesSubDocument = gql`
    subscription UserChannelIdentitiesSub($userId: ID!) {
  ChannelMember(filter: {mutation_in: [create], node: {channel: {members: {some: {user: {id: {equals: $userId}}}}}}}) {
    node {
      ...ChannelIdentity
    }
  }
}
    ${ChannelIdentityFragmentDoc}`;
export type UserChannelIdentitiesSubComponentProps = Omit<ReactApollo.SubscriptionProps<UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables>, 'subscription'>;

    export const UserChannelIdentitiesSubComponent = (props: UserChannelIdentitiesSubComponentProps) => (
      <ReactApollo.Subscription<UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables> subscription={UserChannelIdentitiesSubDocument} {...props} />
    );
    
export type UserChannelIdentitiesSubProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables>> & TChildProps;
export function withUserChannelIdentitiesSub<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UserChannelIdentitiesSubSubscription,
  UserChannelIdentitiesSubSubscriptionVariables,
  UserChannelIdentitiesSubProps<TChildProps>>) {
    return ReactApollo.withSubscription<TProps, UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables, UserChannelIdentitiesSubProps<TChildProps>>(UserChannelIdentitiesSubDocument, {
      alias: 'withUserChannelIdentitiesSub',
      ...operationOptions
    });
};
export const FileDeleteDocument = gql`
    mutation FileDelete($data: FileDeleteInput!) {
  fileDelete(data: $data) {
    success
  }
}
    `;
export type FileDeleteMutationFn = ReactApollo.MutationFn<FileDeleteMutation, FileDeleteMutationVariables>;
export type FileDeleteComponentProps = Omit<ReactApollo.MutationProps<FileDeleteMutation, FileDeleteMutationVariables>, 'mutation'>;

    export const FileDeleteComponent = (props: FileDeleteComponentProps) => (
      <ReactApollo.Mutation<FileDeleteMutation, FileDeleteMutationVariables> mutation={FileDeleteDocument} {...props} />
    );
    
export type FileDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<FileDeleteMutation, FileDeleteMutationVariables>> & TChildProps;
export function withFileDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  FileDeleteMutation,
  FileDeleteMutationVariables,
  FileDeleteProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, FileDeleteMutation, FileDeleteMutationVariables, FileDeleteProps<TChildProps>>(FileDeleteDocument, {
      alias: 'withFileDelete',
      ...operationOptions
    });
};
export const MessageCreateDocument = gql`
    mutation MessageCreate($data: MessageCreateInput!) {
  messageCreate(data: $data) {
    ...Message
  }
}
    ${MessageFragmentDoc}`;
export type MessageCreateMutationFn = ReactApollo.MutationFn<MessageCreateMutation, MessageCreateMutationVariables>;
export type MessageCreateComponentProps = Omit<ReactApollo.MutationProps<MessageCreateMutation, MessageCreateMutationVariables>, 'mutation'>;

    export const MessageCreateComponent = (props: MessageCreateComponentProps) => (
      <ReactApollo.Mutation<MessageCreateMutation, MessageCreateMutationVariables> mutation={MessageCreateDocument} {...props} />
    );
    
export type MessageCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageCreateMutation, MessageCreateMutationVariables>> & TChildProps;
export function withMessageCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  MessageCreateMutation,
  MessageCreateMutationVariables,
  MessageCreateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, MessageCreateMutation, MessageCreateMutationVariables, MessageCreateProps<TChildProps>>(MessageCreateDocument, {
      alias: 'withMessageCreate',
      ...operationOptions
    });
};
export const MessageDeleteDocument = gql`
    mutation MessageDelete($data: MessageDeleteInput!) {
  messageDelete(data: $data) {
    success
  }
}
    `;
export type MessageDeleteMutationFn = ReactApollo.MutationFn<MessageDeleteMutation, MessageDeleteMutationVariables>;
export type MessageDeleteComponentProps = Omit<ReactApollo.MutationProps<MessageDeleteMutation, MessageDeleteMutationVariables>, 'mutation'>;

    export const MessageDeleteComponent = (props: MessageDeleteComponentProps) => (
      <ReactApollo.Mutation<MessageDeleteMutation, MessageDeleteMutationVariables> mutation={MessageDeleteDocument} {...props} />
    );
    
export type MessageDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageDeleteMutation, MessageDeleteMutationVariables>> & TChildProps;
export function withMessageDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  MessageDeleteMutation,
  MessageDeleteMutationVariables,
  MessageDeleteProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, MessageDeleteMutation, MessageDeleteMutationVariables, MessageDeleteProps<TChildProps>>(MessageDeleteDocument, {
      alias: 'withMessageDelete',
      ...operationOptions
    });
};
export const MessageUpdateDocument = gql`
    mutation MessageUpdate($data: MessageUpdateInput!) {
  messageUpdate(data: $data) {
    id
  }
}
    `;
export type MessageUpdateMutationFn = ReactApollo.MutationFn<MessageUpdateMutation, MessageUpdateMutationVariables>;
export type MessageUpdateComponentProps = Omit<ReactApollo.MutationProps<MessageUpdateMutation, MessageUpdateMutationVariables>, 'mutation'>;

    export const MessageUpdateComponent = (props: MessageUpdateComponentProps) => (
      <ReactApollo.Mutation<MessageUpdateMutation, MessageUpdateMutationVariables> mutation={MessageUpdateDocument} {...props} />
    );
    
export type MessageUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageUpdateMutation, MessageUpdateMutationVariables>> & TChildProps;
export function withMessageUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  MessageUpdateMutation,
  MessageUpdateMutationVariables,
  MessageUpdateProps<TChildProps>>) {
    return ReactApollo.withMutation<TProps, MessageUpdateMutation, MessageUpdateMutationVariables, MessageUpdateProps<TChildProps>>(MessageUpdateDocument, {
      alias: 'withMessageUpdate',
      ...operationOptions
    });
};
export const UserChannelsMessagesSubDocument = gql`
    subscription UserChannelsMessagesSub($userId: ID!) {
  Message(filter: {mutation_in: [create, update], node: {channel: {members: {some: {user: {id: {equals: $userId}}}}}}}) {
    mutation
    node {
      ...Message
      isDeleted
      channel {
        id
        type
      }
    }
  }
}
    ${MessageFragmentDoc}`;
export type UserChannelsMessagesSubComponentProps = Omit<ReactApollo.SubscriptionProps<UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables>, 'subscription'>;

    export const UserChannelsMessagesSubComponent = (props: UserChannelsMessagesSubComponentProps) => (
      <ReactApollo.Subscription<UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables> subscription={UserChannelsMessagesSubDocument} {...props} />
    );
    
export type UserChannelsMessagesSubProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables>> & TChildProps;
export function withUserChannelsMessagesSub<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UserChannelsMessagesSubSubscription,
  UserChannelsMessagesSubSubscriptionVariables,
  UserChannelsMessagesSubProps<TChildProps>>) {
    return ReactApollo.withSubscription<TProps, UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables, UserChannelsMessagesSubProps<TChildProps>>(UserChannelsMessagesSubDocument, {
      alias: 'withUserChannelsMessagesSub',
      ...operationOptions
    });
};
export const UserChannelsPreviewDocument = gql`
    query UserChannelsPreview($id: ID, $channelMembersFilter: ChannelMemberFilter! = {}) {
  user(id: $id) {
    id
    channelIdentities(filter: {AND: [{channel: {type: {equals: "channel"}}}, $channelMembersFilter]}) {
      items {
        ...ChannelIdentity
      }
    }
  }
}
    ${ChannelIdentityFragmentDoc}`;
export type UserChannelsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables>, 'query'> & ({ variables: UserChannelsPreviewQueryVariables; skip?: false; } | { skip: true; });

    export const UserChannelsPreviewComponent = (props: UserChannelsPreviewComponentProps) => (
      <ReactApollo.Query<UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables> query={UserChannelsPreviewDocument} {...props} />
    );
    
export type UserChannelsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables>> & TChildProps;
export function withUserChannelsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UserChannelsPreviewQuery,
  UserChannelsPreviewQueryVariables,
  UserChannelsPreviewProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables, UserChannelsPreviewProps<TChildProps>>(UserChannelsPreviewDocument, {
      alias: 'withUserChannelsPreview',
      ...operationOptions
    });
};
export const UserDmsPreviewDocument = gql`
    query UserDmsPreview($id: ID, $channelMembersFilter: ChannelMemberFilter! = {}) {
  user(id: $id) {
    id
    channelIdentities(filter: {AND: [{channel: {type: {in: ["im", "group"]}}}, $channelMembersFilter]}) {
      items {
        ...DmIdentity
      }
    }
  }
}
    ${DmIdentityFragmentDoc}`;
export type UserDmsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserDmsPreviewQuery, UserDmsPreviewQueryVariables>, 'query'> & ({ variables: UserDmsPreviewQueryVariables; skip?: false; } | { skip: true; });

    export const UserDmsPreviewComponent = (props: UserDmsPreviewComponentProps) => (
      <ReactApollo.Query<UserDmsPreviewQuery, UserDmsPreviewQueryVariables> query={UserDmsPreviewDocument} {...props} />
    );
    
export type UserDmsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserDmsPreviewQuery, UserDmsPreviewQueryVariables>> & TChildProps;
export function withUserDmsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UserDmsPreviewQuery,
  UserDmsPreviewQueryVariables,
  UserDmsPreviewProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, UserDmsPreviewQuery, UserDmsPreviewQueryVariables, UserDmsPreviewProps<TChildProps>>(UserDmsPreviewDocument, {
      alias: 'withUserDmsPreview',
      ...operationOptions
    });
};
export const UserContactsPreviewDocument = gql`
    query UserContactsPreview($filter: UserFilter!) {
  usersList(filter: $filter) {
    items {
      ...UserPreview
    }
  }
}
    ${UserPreviewFragmentDoc}`;
export type UserContactsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserContactsPreviewQuery, UserContactsPreviewQueryVariables>, 'query'> & ({ variables: UserContactsPreviewQueryVariables; skip?: false; } | { skip: true; });

    export const UserContactsPreviewComponent = (props: UserContactsPreviewComponentProps) => (
      <ReactApollo.Query<UserContactsPreviewQuery, UserContactsPreviewQueryVariables> query={UserContactsPreviewDocument} {...props} />
    );
    
export type UserContactsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserContactsPreviewQuery, UserContactsPreviewQueryVariables>> & TChildProps;
export function withUserContactsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UserContactsPreviewQuery,
  UserContactsPreviewQueryVariables,
  UserContactsPreviewProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, UserContactsPreviewQuery, UserContactsPreviewQueryVariables, UserContactsPreviewProps<TChildProps>>(UserContactsPreviewDocument, {
      alias: 'withUserContactsPreview',
      ...operationOptions
    });
};
export const UsersSearchDocument = gql`
    query UsersSearch($first: Int!, $searchText: String!, $channelId: ID!, $usersFilter: UserFilter!) {
  usersList(first: $first, filter: {AND: [{channelIdentities: {none: {channel: {id: {equals: $channelId}}}}, OR: [{firstName: {contains: $searchText}}, {lastName: {contains: $searchText}}]}, $usersFilter]}) {
    items {
      ...UserPreview
    }
  }
}
    ${UserPreviewFragmentDoc}`;
export type UsersSearchComponentProps = Omit<ReactApollo.QueryProps<UsersSearchQuery, UsersSearchQueryVariables>, 'query'> & ({ variables: UsersSearchQueryVariables; skip?: false; } | { skip: true; });

    export const UsersSearchComponent = (props: UsersSearchComponentProps) => (
      <ReactApollo.Query<UsersSearchQuery, UsersSearchQueryVariables> query={UsersSearchDocument} {...props} />
    );
    
export type UsersSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UsersSearchQuery, UsersSearchQueryVariables>> & TChildProps;
export function withUsersSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UsersSearchQuery,
  UsersSearchQueryVariables,
  UsersSearchProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, UsersSearchQuery, UsersSearchQueryVariables, UsersSearchProps<TChildProps>>(UsersSearchDocument, {
      alias: 'withUsersSearch',
      ...operationOptions
    });
};
export const UsersDmSearchDocument = gql`
    query UsersDmSearch($first: Int!, $searchText: String!, $idNotIn: [ID!]) {
  usersList(first: $first, filter: {id: {not_in: $idNotIn}, OR: [{firstName: {contains: $searchText}}, {lastName: {contains: $searchText}}]}) {
    items {
      ...UserPreview
    }
  }
}
    ${UserPreviewFragmentDoc}`;
export type UsersDmSearchComponentProps = Omit<ReactApollo.QueryProps<UsersDmSearchQuery, UsersDmSearchQueryVariables>, 'query'> & ({ variables: UsersDmSearchQueryVariables; skip?: false; } | { skip: true; });

    export const UsersDmSearchComponent = (props: UsersDmSearchComponentProps) => (
      <ReactApollo.Query<UsersDmSearchQuery, UsersDmSearchQueryVariables> query={UsersDmSearchDocument} {...props} />
    );
    
export type UsersDmSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UsersDmSearchQuery, UsersDmSearchQueryVariables>> & TChildProps;
export function withUsersDmSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<
  TProps,
  UsersDmSearchQuery,
  UsersDmSearchQueryVariables,
  UsersDmSearchProps<TChildProps>>) {
    return ReactApollo.withQuery<TProps, UsersDmSearchQuery, UsersDmSearchQueryVariables, UsersDmSearchProps<TChildProps>>(UsersDmSearchDocument, {
      alias: 'withUsersDmSearch',
      ...operationOptions
    });
};