import * as React from 'react';
import * as ReactApollo from 'react-apollo';
export declare type Maybe<T> = T | null;
export declare 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 declare 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 declare type AggregationFunctionType = 'AVG' | 'SUM' | 'COUNT' | 'MIN' | 'MAX' | 'GROUP_CONCAT' | 'ANY_VALUE' | 'STDDEV_POP' | 'STDDEV_SAMP' | 'VAR_POP' | 'VAR_SAMP';
export declare 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 declare 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 declare type ApiTokenCreateInput = {
    name: Scalars['String'];
    roles?: Maybe<ApiTokensRolesRelationInput>;
};
/** ApiTokens delete input */
export declare type ApiTokenDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type ApiTokenGroupBy = {
    query: ApiTokenGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type ApiTokenKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** ApiTokenListResponse output */
export declare type ApiTokenListResponse = {
    __typename?: 'ApiTokenListResponse';
    /** List items */
    items: Array<ApiToken>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** ApiTokenManyResponse output */
export declare type ApiTokenManyResponse = {
    __typename?: 'ApiTokenManyResponse';
    /** List items */
    items: Array<ApiToken>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type ApiTokenPayload = {
    __typename?: 'ApiTokenPayload';
    mutation: MutationType;
    node?: Maybe<ApiToken>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<ApiToken>;
};
export declare 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 declare type ApiTokenPermissionRelationFilter = {
    some?: Maybe<ApiTokenPermissionFilter>;
    every?: Maybe<ApiTokenPermissionFilter>;
    none?: Maybe<ApiTokenPermissionFilter>;
};
export declare type ApiTokenRelationFilter = {
    some?: Maybe<ApiTokenFilter>;
    every?: Maybe<ApiTokenFilter>;
    none?: Maybe<ApiTokenFilter>;
};
/** API Token Response */
export declare 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 declare 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 declare 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 declare type ApiTokens_RoleUpdateInput = {
    filter?: Maybe<RoleKeyFilter>;
    data: RoleUpdateInput;
};
export declare type ApiTokenSort = {
    id?: Maybe<SortOrder>;
    createdAt?: Maybe<SortOrder>;
    updatedAt?: Maybe<SortOrder>;
    deletedAt?: Maybe<SortOrder>;
    name?: Maybe<SortOrder>;
    createdBy?: Maybe<UserSort>;
};
/** ApiTokens relation input */
export declare type ApiTokensRolesRelationInput = {
    connect?: Maybe<Array<RoleKeyFilter>>;
    create?: Maybe<Array<Maybe<ApiTokens_RoleCreateInput>>>;
};
/** ApiTokens relation input */
export declare 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 declare type ApiTokenSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<ApiTokenFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** ApiTokens update input */
export declare type ApiTokenUpdateByFilterInput = {
    name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    token?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
};
/** ApiTokens update input */
export declare type ApiTokenUpdateInput = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    roles?: Maybe<ApiTokensRolesUpdateRelationInput>;
};
/** Application */
export declare 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 declare type ApplicationDeleteMutationInput = {
    id: Scalars['String'];
    force?: Maybe<Scalars['Boolean']>;
};
/** Application install input */
export declare type ApplicationInstallInput = {
    appType: Scalars['String'];
    name: Scalars['String'];
    status?: Maybe<ApplicationStatusEnum>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** ApplicationListResponse output */
export declare type ApplicationListResponse = {
    __typename?: 'ApplicationListResponse';
    /** List items */
    items: Array<Application>;
    /** List items count */
    count: Scalars['Int'];
};
/** Application Status Enum */
export declare type ApplicationStatusEnum = 'ACTIVE' | 'INACTIVE';
/** Application update input */
export declare type ApplicationUpdateInput = {
    id: Scalars['String'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    status?: Maybe<ApplicationStatusEnum>;
};
/** Async Session */
export declare type AsyncSession = {
    __typename?: 'AsyncSession';
    sessionId: Scalars['String'];
};
export declare type AsyncSessionStatusResponse = {
    __typename?: 'AsyncSessionStatusResponse';
    status: Scalars['String'];
    message?: Maybe<Scalars['String']>;
};
/** Message create input from attachments */
export declare 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 declare type Attachments_MessageUpdateInput = {
    filter?: Maybe<MessageKeyFilter>;
    data: MessageUpdateInput;
};
/** Auth response */
export declare type Auth = {
    __typename?: 'Auth';
    refreshToken?: Maybe<Scalars['String']>;
    idToken?: Maybe<Scalars['String']>;
};
export declare 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 declare 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 declare type AuthenticationProfileAttributes = CognitoAuthProfileAttributes;
/** Authentication profile connection options */
export declare type AuthenticationProfileConnectionOptions = {
    __typename?: 'AuthenticationProfileConnectionOptions';
    google?: Maybe<GoogleOptions>;
    facebook?: Maybe<FacebookOptions>;
    github?: Maybe<GithubOptions>;
};
/** Authentication profile connection options input */
export declare type AuthenticationProfileConnectionsOptionsInput = {
    google?: Maybe<GoogleOptionsInput>;
    facebook?: Maybe<FacebookOptionsInput>;
    github?: Maybe<GithubOptionsInput>;
};
/** AuthenticationProfiles create input */
export declare 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 declare 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 declare type AuthenticationProfileDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type AuthenticationProfileGroupBy = {
    query: AuthenticationProfileGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type AuthenticationProfileKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** AuthenticationProfileListResponse output */
export declare type AuthenticationProfileListResponse = {
    __typename?: 'AuthenticationProfileListResponse';
    /** List items */
    items: Array<AuthenticationProfile>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** AuthenticationProfileManyResponse output */
export declare type AuthenticationProfileManyResponse = {
    __typename?: 'AuthenticationProfileManyResponse';
    /** List items */
    items: Array<AuthenticationProfile>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type AuthenticationProfilePayload = {
    __typename?: 'AuthenticationProfilePayload';
    mutation: MutationType;
    node?: Maybe<AuthenticationProfile>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<AuthenticationProfile>;
};
export declare 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 declare type AuthenticationProfilePermissionRelationFilter = {
    some?: Maybe<AuthenticationProfilePermissionFilter>;
    every?: Maybe<AuthenticationProfilePermissionFilter>;
    none?: Maybe<AuthenticationProfilePermissionFilter>;
};
export declare type AuthenticationProfileRelationFilter = {
    some?: Maybe<AuthenticationProfileFilter>;
    every?: Maybe<AuthenticationProfileFilter>;
    none?: Maybe<AuthenticationProfileFilter>;
};
/** Roles create input from authenticationProfiles */
export declare 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 declare type AuthenticationProfiles_RoleUpdateInput = {
    filter?: Maybe<RoleKeyFilter>;
    data: RoleUpdateInput;
};
export declare 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 declare type AuthenticationProfilesRolesManyRelationInput = {
    connect?: Maybe<Array<RoleKeyFilter>>;
};
/** AuthenticationProfiles relation input */
export declare type AuthenticationProfilesRolesRelationInput = {
    connect?: Maybe<Array<RoleKeyFilter>>;
    create?: Maybe<Array<Maybe<AuthenticationProfiles_RoleCreateInput>>>;
};
/** AuthenticationProfiles relation input */
export declare 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 declare type AuthenticationProfileSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<AuthenticationProfileFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** AuthenticationProfiles update input */
export declare 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 declare 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 declare 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 declare 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 declare type AuthenticationSettingPayload = {
    __typename?: 'AuthenticationSettingPayload';
    mutation: MutationType;
    node?: Maybe<AuthenticationSetting>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<AuthenticationSetting>;
};
/** AuthenticationSettings subscription filter */
export declare type AuthenticationSettingSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<AuthenticationSettingFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** AuthenticationSettings update input */
export declare 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 declare type Avatar_TeamMemberUpdateInput = {
    filter?: Maybe<TeamMemberKeyFilter>;
    data: TeamMemberUpdateInput;
};
/** Users create input from avatar */
export declare 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 declare type Avatar_UserUpdateInput = {
    filter?: Maybe<UserKeyFilter>;
    data: UserUpdateInput;
};
export declare 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 declare 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 declare type BillingDetailsResponse = {
    __typename?: 'BillingDetailsResponse';
    last4?: Maybe<Scalars['String']>;
    expMonth?: Maybe<Scalars['Int']>;
    expYear?: Maybe<Scalars['Int']>;
    brand?: Maybe<Scalars['String']>;
};
/** BillingDetailsUpdateMutationInput */
export declare type BillingDetailsUpdateMutationInput = {
    cardToken: Scalars['String'];
};
export declare 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 declare type BillingInvoicesListFilterType = 'WORKSPACE' | 'CUSTOMER';
/** BillingInvoicesListResponse output */
export declare type BillingInvoicesListResponse = {
    __typename?: 'BillingInvoicesListResponse';
    /** List items */
    items: Array<BillingInvoiceItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type BillingLimitMetricItem = {
    __typename?: 'BillingLimitMetricItem';
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    showPriority?: Maybe<Scalars['Int']>;
    unit?: Maybe<Scalars['String']>;
};
export declare type BillingMetricUsageItem = {
    __typename?: 'BillingMetricUsageItem';
    limitMetric?: Maybe<BillingLimitMetricItem>;
    value?: Maybe<Scalars['Float']>;
};
export declare type BillingMetricUsageQuotaItem = {
    __typename?: 'BillingMetricUsageQuotaItem';
    limitMetric?: Maybe<BillingLimitMetricItem>;
    value?: Maybe<Scalars['Float']>;
};
/** BillingMetricUsageQuotasListResponse output */
export declare type BillingMetricUsageQuotasListResponse = {
    __typename?: 'BillingMetricUsageQuotasListResponse';
    /** List items */
    items: Array<BillingMetricUsageQuotaItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type BillingMetricUsagesListFilter = {
    entryDate: DateTimePredicate;
};
/** BillingMetricUsagesListResponse output */
export declare type BillingMetricUsagesListResponse = {
    __typename?: 'BillingMetricUsagesListResponse';
    /** List items */
    items: Array<BillingMetricUsageItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type BillingNextPlanResponse = {
    __typename?: 'BillingNextPlanResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    price?: Maybe<Scalars['Int']>;
    displayName?: Maybe<Scalars['String']>;
};
export declare 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 declare 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 declare type BillingPlanUpdateMutationInput = {
    planId: Scalars['ID'];
};
export declare type BoolPredicate = {
    equals?: Maybe<Scalars['Boolean']>;
    not_equals?: Maybe<Scalars['Boolean']>;
    is_empty?: Maybe<Scalars['Boolean']>;
    is_not_empty?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type ChangePasswordInput = {
    refreshToken: Scalars['String'];
    email: Scalars['String'];
    oldPassword: Scalars['String'];
    newPassword: Scalars['String'];
    authProfileId: Scalars['ID'];
};
export declare 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 declare 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 declare 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 declare type Channel_ChannelMemberCreateInput = {
    channel?: Maybe<ChannelMemberChannelRelationInput>;
    user?: Maybe<ChannelMemberUserRelationInput>;
    lastReadTS?: Maybe<Scalars['DateTime']>;
};
/** ChannelMember update input from channel */
export declare type Channel_ChannelMemberUpdateInput = {
    filter?: Maybe<ChannelMemberKeyFilter>;
    data: ChannelMemberUpdateInput;
};
/** Message create input from channel */
export declare 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 declare type Channel_MessageUpdateInput = {
    filter?: Maybe<MessageKeyFilter>;
    data: MessageUpdateInput;
};
/** Channel create input */
export declare 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 declare 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 declare type ChannelDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** ChannelFieldsPermissions create input */
export declare 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 declare 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 declare type ChannelGroupBy = {
    query: ChannelGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare 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 declare 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 declare type ChannelKeyFilter = {
    id?: Maybe<Scalars['ID']>;
};
/** ChannelListResponse output */
export declare type ChannelListResponse = {
    __typename?: 'ChannelListResponse';
    /** List items */
    items: Array<Channel>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** ChannelManyResponse output */
export declare type ChannelManyResponse = {
    __typename?: 'ChannelManyResponse';
    /** List items */
    items: Array<Channel>;
    /** List items count */
    count: Scalars['Int'];
};
export declare 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 declare type ChannelMemberChannelManyRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
};
/** ChannelMember relation input */
export declare type ChannelMemberChannelRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
    create?: Maybe<Members_ChannelCreateInput>;
};
/** ChannelMember relation input */
export declare type ChannelMemberChannelUpdateRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
    disconnect?: Maybe<ChannelKeyFilter>;
    reconnect?: Maybe<ChannelKeyFilter>;
    create?: Maybe<Members_ChannelCreateInput>;
    update?: Maybe<Members_ChannelUpdateInput>;
};
/** ChannelMember create input */
export declare type ChannelMemberCreateInput = {
    channel?: Maybe<ChannelMemberChannelRelationInput>;
    user?: Maybe<ChannelMemberUserRelationInput>;
    lastReadTS?: Maybe<Scalars['DateTime']>;
};
/** ChannelMember create many input */
export declare type ChannelMemberCreateManyInput = {
    channel: ChannelMemberChannelManyRelationInput;
    user: ChannelMemberUserManyRelationInput;
    lastReadTS?: Maybe<Scalars['DateTime']>;
};
/** ChannelMember delete input */
export declare type ChannelMemberDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** ChannelMemberFieldsPermissions create input */
export declare type ChannelMemberFieldsPermissions = {
    createdAt?: Maybe<Scalars['Boolean']>;
    updatedAt?: Maybe<Scalars['Boolean']>;
    lastReadTS?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type ChannelMemberGroupBy = {
    query: ChannelMemberGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type ChannelMemberKeyFilter = {
    id?: Maybe<Scalars['ID']>;
};
/** ChannelMemberListResponse output */
export declare type ChannelMemberListResponse = {
    __typename?: 'ChannelMemberListResponse';
    /** List items */
    items: Array<ChannelMember>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** ChannelMemberManyResponse output */
export declare type ChannelMemberManyResponse = {
    __typename?: 'ChannelMemberManyResponse';
    /** List items */
    items: Array<ChannelMember>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type ChannelMemberPayload = {
    __typename?: 'ChannelMemberPayload';
    mutation: MutationType;
    node?: Maybe<ChannelMember>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<ChannelMember>;
};
export declare 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 declare type ChannelMemberPermissionRelationFilter = {
    some?: Maybe<ChannelMemberPermissionFilter>;
    every?: Maybe<ChannelMemberPermissionFilter>;
    none?: Maybe<ChannelMemberPermissionFilter>;
};
export declare type ChannelMemberRelationFilter = {
    some?: Maybe<ChannelMemberFilter>;
    every?: Maybe<ChannelMemberFilter>;
    none?: Maybe<ChannelMemberFilter>;
};
/** Channel relation input */
export declare type ChannelMembersManyRelationInput = {
    connect?: Maybe<Array<ChannelMemberKeyFilter>>;
};
export declare 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 declare type ChannelMembersRelationInput = {
    connect?: Maybe<Array<ChannelMemberKeyFilter>>;
    create?: Maybe<Array<Maybe<Channel_ChannelMemberCreateInput>>>;
};
/** ChannelMember subscription filter */
export declare type ChannelMemberSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<ChannelMemberFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Channel relation input */
export declare 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 declare type ChannelMemberUpdateByFilterInput = {
    lastReadTS?: Maybe<Array<Maybe<UpdateByFilterDateTimeInput>>>;
};
/** ChannelMember update input */
export declare type ChannelMemberUpdateInput = {
    id?: Maybe<Scalars['ID']>;
    channel?: Maybe<ChannelMemberChannelUpdateRelationInput>;
    user?: Maybe<ChannelMemberUserUpdateRelationInput>;
    lastReadTS?: Maybe<Scalars['DateTime']>;
};
/** ChannelMember relation input */
export declare type ChannelMemberUserManyRelationInput = {
    connect?: Maybe<UserKeyFilter>;
};
/** ChannelMember relation input */
export declare type ChannelMemberUserRelationInput = {
    connect?: Maybe<UserKeyFilter>;
    create?: Maybe<ChannelIdentities_UserCreateInput>;
};
/** ChannelMember relation input */
export declare type ChannelMemberUserUpdateRelationInput = {
    connect?: Maybe<UserKeyFilter>;
    disconnect?: Maybe<UserKeyFilter>;
    reconnect?: Maybe<UserKeyFilter>;
    create?: Maybe<ChannelIdentities_UserCreateInput>;
    update?: Maybe<ChannelIdentities_UserUpdateInput>;
};
/** Channel relation input */
export declare type ChannelMessagesManyRelationInput = {
    connect?: Maybe<Array<MessageKeyFilter>>;
};
/** Channel relation input */
export declare type ChannelMessagesRelationInput = {
    connect?: Maybe<Array<MessageKeyFilter>>;
    create?: Maybe<Array<Maybe<Channel_MessageCreateInput>>>;
};
/** Channel relation input */
export declare 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 declare 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 declare type ChannelPayload = {
    __typename?: 'ChannelPayload';
    mutation: MutationType;
    node?: Maybe<Channel>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<Channel>;
};
export declare 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 declare 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 declare type ChannelSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<ChannelFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Channel update input */
export declare 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 declare 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 declare type CognitoAuthProfileAttributes = {
    __typename?: 'CognitoAuthProfileAttributes';
    clientAuthDomain?: Maybe<Scalars['String']>;
};
/** Computed field mode */
export declare type ComputedFieldMode = 'VIRTUAL' | 'STORED';
/** Custom Table Field Type */
export declare 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 declare type DateFieldTypeAttributes = {
    __typename?: 'DateFieldTypeAttributes';
    format: Scalars['String'];
};
export declare 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 declare 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 declare 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 declare 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 declare type DateTypeFormatEnum = 'DATE' | 'DATETIME';
/** DeployDataResponse */
export declare type DeployDataResponse = {
    __typename?: 'DeployDataResponse';
    uploadBuildUrl: Scalars['String'];
    uploadMetaDataUrl: Scalars['String'];
    buildName: Scalars['String'];
};
/** DeployingBuildInput */
export declare type DeployingBuildInput = {
    buildName: Scalars['String'];
    options?: Maybe<DeployOptions>;
};
export declare type DeployModeEnum = 'FULL' | 'ONLY_PLUGINS' | 'ONLY_PROJECT' | 'FUNCTIONS' | 'MIGRATIONS';
/** DeployOptions */
export declare type DeployOptions = {
    mode?: Maybe<DeployModeEnum>;
    pluginNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    extensionNames?: Maybe<Array<Maybe<Scalars['String']>>>;
};
export declare type DeployStatusEnum = 'deploying' | 'complete_error' | 'complete_success' | 'compiling' | 'preparing' | 'initialize';
/** DeployStatusResult */
export declare type DeployStatusResult = {
    __typename?: 'DeployStatusResult';
    status: DeployStatusEnum;
    message?: Maybe<Scalars['String']>;
};
export declare type EnvironmentBackupItem = {
    __typename?: 'EnvironmentBackupItem';
    name: Scalars['String'];
    size: Scalars['Float'];
};
export declare type EnvironmentItem = {
    __typename?: 'EnvironmentItem';
    id: Scalars['ID'];
    name: Scalars['String'];
};
export declare 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 declare type EnvironmentVariableCreateInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};
/** EnvironmentVariables create many input */
export declare type EnvironmentVariableCreateManyInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};
/** EnvironmentVariables delete input */
export declare type EnvironmentVariableDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type EnvironmentVariableGroupBy = {
    query: EnvironmentVariableGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type EnvironmentVariableKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** EnvironmentVariableListResponse output */
export declare type EnvironmentVariableListResponse = {
    __typename?: 'EnvironmentVariableListResponse';
    /** List items */
    items: Array<EnvironmentVariable>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** EnvironmentVariableManyResponse output */
export declare type EnvironmentVariableManyResponse = {
    __typename?: 'EnvironmentVariableManyResponse';
    /** List items */
    items: Array<EnvironmentVariable>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type EnvironmentVariablePayload = {
    __typename?: 'EnvironmentVariablePayload';
    mutation: MutationType;
    node?: Maybe<EnvironmentVariable>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<EnvironmentVariable>;
};
export declare 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 declare type EnvironmentVariableSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<EnvironmentVariableFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** EnvironmentVariables update input */
export declare type EnvironmentVariableUpdateByFilterInput = {
    name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    value?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
};
/** EnvironmentVariables update input */
export declare type EnvironmentVariableUpdateInput = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};
/** Facebook connection params */
export declare type FacebookOptions = {
    __typename?: 'FacebookOptions';
    enabled: Scalars['Boolean'];
    app_id: Scalars['String'];
    app_secret: Scalars['String'];
};
/** Facebook connection params input */
export declare type FacebookOptionsInput = {
    enabled: Scalars['Boolean'];
    app_id: Scalars['String'];
    app_secret: Scalars['String'];
};
/** Field Data Features */
export declare type FieldDataFeatures = {
    __typename?: 'FieldDataFeatures';
    create: Scalars['Boolean'];
    update: Scalars['Boolean'];
    sort: Scalars['Boolean'];
};
/** Field Schema Features */
export declare type FieldSchemaFeatures = {
    __typename?: 'FieldSchemaFeatures';
    update: Scalars['Boolean'];
    delete: Scalars['Boolean'];
};
/** Field types */
export declare type FieldType = 'ID' | 'UUID' | 'JSON' | 'NUMBER' | 'TEXT' | 'DATE' | 'SWITCH' | 'RELATION' | 'FILE' | 'SMART' | 'GEO' | 'ONE_WAY_RELATION' | 'MISSING_RELATION';
/** Field Type Attributes */
export declare type FieldTypeAttributes = DateFieldTypeAttributes | FileFieldTypeAttributes | MissingRelationFieldTypeAttributes | NumberFieldTypeAttributes | SmartFieldTypeAttributes | SwitchFieldTypeAttributes | TextFieldTypeAttributes | UuidFieldTypeAttributes | GeoFieldTypeAttributes;
/** Field Type Attributes Input */
export declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare type FileDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** FileFieldsPermissions create input */
export declare 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 declare 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 declare 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 declare type FileGroupBy = {
    query: FileGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type FileKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    fileId?: Maybe<Scalars['String']>;
};
/** FileListResponse output */
export declare type FileListResponse = {
    __typename?: 'FileListResponse';
    /** List items */
    items: Array<File>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** FileManyResponse output */
export declare type FileManyResponse = {
    __typename?: 'FileManyResponse';
    /** List items */
    items: Array<File>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type FilePayload = {
    __typename?: 'FilePayload';
    mutation: MutationType;
    node?: Maybe<File>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<File>;
};
export declare 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 declare type FilePermissionRelationFilter = {
    some?: Maybe<FilePermissionFilter>;
    every?: Maybe<FilePermissionFilter>;
    none?: Maybe<FilePermissionFilter>;
};
export declare type FileRelationFilter = {
    some?: Maybe<FileFilter>;
    every?: Maybe<FileFilter>;
    none?: Maybe<FileFilter>;
};
/** Files relation input */
export declare type FilesMessage_AttachmentsManyRelationInput = {
    connect?: Maybe<Array<MessageKeyFilter>>;
};
/** Files relation input */
export declare type FilesMessage_AttachmentsRelationInput = {
    connect?: Maybe<Array<MessageKeyFilter>>;
    create?: Maybe<Array<Maybe<Attachments_MessageCreateInput>>>;
};
/** Files relation input */
export declare 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 declare 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 declare type FilesTeamMembers_AvatarManyRelationInput = {
    connect?: Maybe<Array<TeamMemberKeyFilter>>;
};
/** Files relation input */
export declare type FilesTeamMembers_AvatarRelationInput = {
    connect?: Maybe<Array<TeamMemberKeyFilter>>;
};
/** Files relation input */
export declare 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 declare type FileSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<FileFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Files relation input */
export declare type FilesUsers_AvatarManyRelationInput = {
    connect?: Maybe<Array<UserKeyFilter>>;
};
/** Files relation input */
export declare type FilesUsers_AvatarRelationInput = {
    connect?: Maybe<Array<UserKeyFilter>>;
    create?: Maybe<Array<Maybe<Avatar_UserCreateInput>>>;
};
/** Files relation input */
export declare 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 declare type FileTypeFormatEnum = 'FILE' | 'IMAGE';
/** Files update input */
export declare 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 declare 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 declare type FileUploadInfoResponse = {
    __typename?: 'FileUploadInfoResponse';
    policy: Scalars['String'];
    signature: Scalars['String'];
    apiKey: Scalars['String'];
    path: Scalars['String'];
};
export declare type FindOrCreateDmInput = {
    usersIds: Array<Scalars['ID']>;
};
export declare type FindOrCreateDmMember = {
    __typename?: 'FindOrCreateDMMember';
    id: Scalars['ID'];
    user: FindOrCreateDmUser;
};
export declare type FindOrCreateDmMemberList = {
    __typename?: 'FindOrCreateDMMemberList';
    count: Scalars['Int'];
    items: Array<FindOrCreateDmMember>;
};
export declare type FindOrCreateDmResponse = {
    __typename?: 'FindOrCreateDMResponse';
    id: Scalars['ID'];
    name: Scalars['String'];
    members: FindOrCreateDmMemberList;
};
export declare type FindOrCreateDmUser = {
    __typename?: 'FindOrCreateDMUser';
    id: Scalars['ID'];
};
export declare 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 declare type FunctionInfo = {
    name: Scalars['String'];
    functionType: FunctionType;
    description?: Maybe<Scalars['String']>;
    application?: Maybe<Application>;
};
/** FunctionInfoFilter */
export declare type FunctionInfoFilter = {
    name?: Maybe<Scalars['String']>;
    functionType?: Maybe<FunctionType>;
    description?: Maybe<Scalars['String']>;
};
/** FunctionInfoOrderBy */
export declare type FunctionInfoOrderBy = 'name_ASC' | 'name_DESC' | 'functionType_ASC' | 'functionType_DESC' | 'description_ASC' | 'description_DESC';
/** FunctionListResponse output */
export declare type FunctionListResponse = {
    __typename?: 'FunctionListResponse';
    /** List items */
    items: Array<FunctionInfo>;
    /** List items count */
    count: Scalars['Int'];
};
/** FunctionResolverInfo */
export declare type FunctionResolverInfo = FunctionInfo & {
    __typename?: 'FunctionResolverInfo';
    name: Scalars['String'];
    functionType: FunctionType;
    description?: Maybe<Scalars['String']>;
    gqlType: Scalars['String'];
    application?: Maybe<Application>;
};
/** FunctionTaskInfo */
export declare type FunctionTaskInfo = FunctionInfo & {
    __typename?: 'FunctionTaskInfo';
    name: Scalars['String'];
    functionType: FunctionType;
    description?: Maybe<Scalars['String']>;
    scheduleExpression?: Maybe<Scalars['String']>;
    application?: Maybe<Application>;
};
/** FunctionTriggerInfo */
export declare 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 declare type FunctionType = 'resolver' | 'trigger' | 'webhook' | 'task' | 'schedule';
/** FunctionWebhookInfo */
export declare 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 declare type GeoFieldTypeAttributes = {
    __typename?: 'GeoFieldTypeAttributes';
    format: Scalars['String'];
    srid?: Maybe<Scalars['Int']>;
};
/** Github connection params */
export declare type GithubOptions = {
    __typename?: 'GithubOptions';
    enabled: Scalars['Boolean'];
    client_id: Scalars['String'];
    client_secret: Scalars['String'];
};
/** Github connection params input */
export declare type GithubOptionsInput = {
    enabled: Scalars['Boolean'];
    client_id: Scalars['String'];
    client_secret: Scalars['String'];
};
/** Google connection params */
export declare type GoogleOptions = {
    __typename?: 'GoogleOptions';
    enabled: Scalars['Boolean'];
    client_id: Scalars['String'];
    client_secret: Scalars['String'];
};
/** Google connection params input */
export declare type GoogleOptionsInput = {
    enabled: Scalars['Boolean'];
    client_id: Scalars['String'];
    client_secret: Scalars['String'];
};
export declare type GroupByField = {
    as?: Maybe<Scalars['String']>;
    fn?: Maybe<Array<Maybe<GroupByFieldFunction>>>;
};
export declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare 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 declare type GroupBySort = {
    alias: Scalars['String'];
    direction: SortOrder;
};
export declare type GroupIdentifiersGroupByField = {
    as: Scalars['String'];
};
export declare 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 declare 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 declare 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 declare type ImportedTable = {
    __typename?: 'ImportedTable';
    id: Scalars['ID'];
    name: Scalars['String'];
};
/** Table Create Index Input */
export declare type IndexCreateInput = {
    tableId: Scalars['ID'];
    type: TableIndexType;
    columns: Array<TableIndexColumnInput>;
    force?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
};
/** Table Delete Index Input */
export declare type IndexDeleteInput = {
    id: Scalars['ID'];
};
/** Table Update Index Input */
export declare type IndexUpdateInput = {
    id: Scalars['ID'];
    type?: Maybe<TableIndexType>;
    columns?: Maybe<Array<TableIndexColumnInput>>;
    force?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
};
export declare 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 declare 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 declare type IntrospectionQueryResponse = {
    __typename?: 'IntrospectionQueryResponse';
    url: Scalars['String'];
};
/** Invited By Name */
export declare type InvitedByName = {
    __typename?: 'InvitedByName';
    firstName?: Maybe<Scalars['String']>;
    lastName?: Maybe<Scalars['String']>;
    workspaceName?: Maybe<Scalars['String']>;
    email?: Maybe<Scalars['String']>;
};
/** InviteMembersInput */
export declare type InviteMembersInput = {
    recipients: Array<InviteRecipientInput>;
};
/** InviteRecipientInput */
export declare type InviteRecipientInput = {
    email: Scalars['String'];
    firstName?: Maybe<Scalars['String']>;
    lastName?: Maybe<Scalars['String']>;
    roles?: Maybe<Array<Scalars['ID']>>;
};
/** InvokeData */
export declare type InvokeData = {
    functionName: Scalars['String'];
    inputArgs?: Maybe<Scalars['String']>;
};
/** InvokeFunctionResponse */
export declare type InvokeFunctionResponse = {
    __typename?: 'InvokeFunctionResponse';
    responseData: Scalars['String'];
};
export declare type LocateFunctionArguments = {
    str: Scalars['String'];
    pos?: Maybe<Scalars['Int']>;
};
/** LoginResponse */
export declare type LoginResponse = {
    __typename?: 'LoginResponse';
    success?: Maybe<Scalars['Boolean']>;
    auth?: Maybe<Auth>;
    workspaces?: Maybe<Array<WorkspaceInfo>>;
};
/** Channel create input from members */
export declare 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 declare 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 declare 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 declare 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 declare 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 declare type Message_Attachments_FileUpdateInput = {
    filter?: Maybe<FileKeyFilter>;
    data: FileUpdateInput;
};
/** Message relation input */
export declare type MessageAttachmentsManyRelationInput = {
    connect?: Maybe<Array<FileKeyFilter>>;
};
/** Message relation input */
export declare type MessageAttachmentsRelationInput = {
    connect?: Maybe<Array<FileKeyFilter>>;
    create?: Maybe<Array<Maybe<Message_Attachments_FileCreateInput>>>;
};
/** Message relation input */
export declare 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 declare type MessageChannelManyRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
};
/** Message relation input */
export declare type MessageChannelRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
    create?: Maybe<Messages_ChannelCreateInput>;
};
/** Message relation input */
export declare type MessageChannelUpdateRelationInput = {
    connect?: Maybe<ChannelKeyFilter>;
    disconnect?: Maybe<ChannelKeyFilter>;
    reconnect?: Maybe<ChannelKeyFilter>;
    create?: Maybe<Messages_ChannelCreateInput>;
    update?: Maybe<Messages_ChannelUpdateInput>;
};
/** Message create input */
export declare 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 declare 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 declare type MessageDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** MessageFieldsPermissions create input */
export declare type MessageFieldsPermissions = {
    createdAt?: Maybe<Scalars['Boolean']>;
    updatedAt?: Maybe<Scalars['Boolean']>;
    text?: Maybe<Scalars['Boolean']>;
    parentID?: Maybe<Scalars['Boolean']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type MessageGroupBy = {
    query: MessageGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type MessageKeyFilter = {
    id?: Maybe<Scalars['ID']>;
};
/** MessageListResponse output */
export declare type MessageListResponse = {
    __typename?: 'MessageListResponse';
    /** List items */
    items: Array<Message>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** MessageManyResponse output */
export declare type MessageManyResponse = {
    __typename?: 'MessageManyResponse';
    /** List items */
    items: Array<Message>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type MessagePayload = {
    __typename?: 'MessagePayload';
    mutation: MutationType;
    node?: Maybe<Message>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<Message>;
};
export declare 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 declare type MessagePermissionRelationFilter = {
    some?: Maybe<MessagePermissionFilter>;
    every?: Maybe<MessagePermissionFilter>;
    none?: Maybe<MessagePermissionFilter>;
};
export declare type MessageRelationFilter = {
    some?: Maybe<MessageFilter>;
    every?: Maybe<MessageFilter>;
    none?: Maybe<MessageFilter>;
};
/** Channel create input from messages */
export declare 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 declare 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 declare 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 declare type MessageSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<MessageFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Message update input */
export declare type MessageUpdateByFilterInput = {
    text?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    parentID?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    isDeleted?: Maybe<Array<Maybe<UpdateByFilterBooleanSwitchInput>>>;
};
/** Message update input */
export declare 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 declare type MissingRelation = {
    __typename?: 'MissingRelation';
    table: Scalars['String'];
};
/** MissingRelation Field Attributes */
export declare type MissingRelationFieldTypeAttributes = {
    __typename?: 'MissingRelationFieldTypeAttributes';
    missingTable: Scalars['String'];
};
export declare 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 declare type MutationApiTokenCreateArgs = {
    data: ApiTokenCreateInput;
};
export declare type MutationApiTokenDeleteArgs = {
    data?: Maybe<ApiTokenDeleteInput>;
    filter?: Maybe<ApiTokenKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationApiTokenDestroyArgs = {
    filter?: Maybe<ApiTokenKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationApiTokenRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationApiTokenUpdateArgs = {
    data: ApiTokenUpdateInput;
    filter?: Maybe<ApiTokenKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationApiTokenUpdateByFilterArgs = {
    data: ApiTokenUpdateByFilterInput;
    filter?: Maybe<ApiTokenFilter>;
};
export declare type MutationApplicationDeleteArgs = {
    data: ApplicationDeleteMutationInput;
};
export declare type MutationApplicationInstallArgs = {
    data: ApplicationInstallInput;
};
export declare type MutationApplicationUpdateArgs = {
    data: ApplicationUpdateInput;
};
export declare type MutationAuthenticationProfileCreateArgs = {
    data: AuthenticationProfileCreateInput;
};
export declare type MutationAuthenticationProfileCreateManyArgs = {
    data: Array<Maybe<AuthenticationProfileCreateManyInput>>;
};
export declare type MutationAuthenticationProfileDeleteArgs = {
    data?: Maybe<AuthenticationProfileDeleteInput>;
    filter?: Maybe<AuthenticationProfileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationAuthenticationProfileDestroyArgs = {
    filter?: Maybe<AuthenticationProfileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationAuthenticationProfileRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationAuthenticationProfileUpdateArgs = {
    data: AuthenticationProfileUpdateInput;
    filter?: Maybe<AuthenticationProfileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationAuthenticationProfileUpdateByFilterArgs = {
    data: AuthenticationProfileUpdateByFilterInput;
    filter?: Maybe<AuthenticationProfileFilter>;
};
export declare type MutationAuthenticationSettingsUpdateArgs = {
    data: AuthenticationSettingUpdateInput;
};
export declare type MutationBillingDetailsUpdateArgs = {
    data: BillingDetailsUpdateMutationInput;
};
export declare type MutationBillingPlanUpdateArgs = {
    data: BillingPlanUpdateMutationInput;
};
export declare type MutationChannelCreateArgs = {
    data: ChannelCreateInput;
};
export declare type MutationChannelCreateManyArgs = {
    data: Array<Maybe<ChannelCreateManyInput>>;
};
export declare type MutationChannelDeleteArgs = {
    data?: Maybe<ChannelDeleteInput>;
    filter?: Maybe<ChannelKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelDestroyArgs = {
    filter?: Maybe<ChannelKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelMemberCreateArgs = {
    data: ChannelMemberCreateInput;
};
export declare type MutationChannelMemberCreateManyArgs = {
    data: Array<Maybe<ChannelMemberCreateManyInput>>;
};
export declare type MutationChannelMemberDeleteArgs = {
    data?: Maybe<ChannelMemberDeleteInput>;
    filter?: Maybe<ChannelMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelMemberDestroyArgs = {
    filter?: Maybe<ChannelMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelMemberRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationChannelMemberUpdateArgs = {
    data: ChannelMemberUpdateInput;
    filter?: Maybe<ChannelMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelMemberUpdateByFilterArgs = {
    data: ChannelMemberUpdateByFilterInput;
    filter?: Maybe<ChannelMemberFilter>;
};
export declare type MutationChannelRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationChannelUpdateArgs = {
    data: ChannelUpdateInput;
    filter?: Maybe<ChannelKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationChannelUpdateByFilterArgs = {
    data: ChannelUpdateByFilterInput;
    filter?: Maybe<ChannelFilter>;
};
export declare type MutationDeployArgs = {
    data?: Maybe<DeployingBuildInput>;
};
export declare type MutationEnvironmentVariableCreateArgs = {
    data: EnvironmentVariableCreateInput;
};
export declare type MutationEnvironmentVariableCreateManyArgs = {
    data: Array<Maybe<EnvironmentVariableCreateManyInput>>;
};
export declare type MutationEnvironmentVariableDeleteArgs = {
    data?: Maybe<EnvironmentVariableDeleteInput>;
    filter?: Maybe<EnvironmentVariableKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationEnvironmentVariableDestroyArgs = {
    filter?: Maybe<EnvironmentVariableKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationEnvironmentVariableRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationEnvironmentVariableUpdateArgs = {
    data: EnvironmentVariableUpdateInput;
    filter?: Maybe<EnvironmentVariableKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationEnvironmentVariableUpdateByFilterArgs = {
    data: EnvironmentVariableUpdateByFilterInput;
    filter?: Maybe<EnvironmentVariableFilter>;
};
export declare type MutationFieldCreateArgs = {
    data: TableFieldCreateInput;
};
export declare type MutationFieldDeleteArgs = {
    data: TableFieldDeleteInput;
};
export declare type MutationFieldUpdateArgs = {
    data: TableFieldUpdateInput;
};
export declare type MutationFieldUpdatePositionArgs = {
    data: TableFieldPositionUpdateInput;
};
export declare type MutationFileCreateArgs = {
    data: FileCreateInput;
};
export declare type MutationFileCreateManyArgs = {
    data: Array<Maybe<FileCreateManyInput>>;
};
export declare type MutationFileDeleteArgs = {
    data?: Maybe<FileDeleteInput>;
    filter?: Maybe<FileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationFileDestroyArgs = {
    filter?: Maybe<FileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationFileRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationFileUpdateArgs = {
    data: FileUpdateInput;
    filter?: Maybe<FileKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationFileUpdateByFilterArgs = {
    data: FileUpdateByFilterInput;
    filter?: Maybe<FileFilter>;
};
export declare type MutationIndexCreateArgs = {
    data: IndexCreateInput;
};
export declare type MutationIndexDeleteArgs = {
    data: IndexDeleteInput;
};
export declare type MutationIndexUpdateArgs = {
    data: IndexUpdateInput;
};
export declare type MutationInviteMembersArgs = {
    data: InviteMembersInput;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationInvokeArgs = {
    data?: Maybe<InvokeData>;
};
export declare type MutationMessageCreateArgs = {
    data: MessageCreateInput;
};
export declare type MutationMessageCreateManyArgs = {
    data: Array<Maybe<MessageCreateManyInput>>;
};
export declare type MutationMessageDeleteArgs = {
    data?: Maybe<MessageDeleteInput>;
    filter?: Maybe<MessageKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationMessageDestroyArgs = {
    filter?: Maybe<MessageKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationMessageRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationMessageUpdateArgs = {
    data: MessageUpdateInput;
    filter?: Maybe<MessageKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationMessageUpdateByFilterArgs = {
    data: MessageUpdateByFilterInput;
    filter?: Maybe<MessageFilter>;
};
export declare type MutationRoleCreateArgs = {
    data: RoleCreateInput;
};
export declare type MutationRoleCreateManyArgs = {
    data: Array<Maybe<RoleCreateManyInput>>;
};
export declare type MutationRoleDeleteArgs = {
    data?: Maybe<RoleDeleteInput>;
    filter?: Maybe<RoleKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationRoleDestroyArgs = {
    filter?: Maybe<RoleKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationRoleRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationRoleUpdateArgs = {
    data: RoleUpdateInput;
    filter?: Maybe<RoleKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationRoleUpdateByFilterArgs = {
    data: RoleUpdateByFilterInput;
    filter?: Maybe<RoleFilter>;
};
export declare type MutationSendInvitationTo8baseArgs = {
    inviteEmail: Scalars['String'];
};
export declare type MutationSettingsUpdateArgs = {
    data: SettingUpdateInput;
};
export declare type MutationTableCreateArgs = {
    data: TableCreateInput;
};
export declare type MutationTableDeleteArgs = {
    data: TableDeleteInput;
};
export declare type MutationTableUpdateArgs = {
    data: TableUpdateInput;
};
export declare type MutationTeamInvitationAcceptArgs = {
    data: TeamInvitationAcceptInput;
};
export declare type MutationTeamInvitationCancelArgs = {
    data: TeamInvitationCancelInput;
};
export declare type MutationTeamInvitationDeleteArgs = {
    data?: Maybe<TeamInvitationDeleteInput>;
    filter?: Maybe<TeamInvitationKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationTeamInvitationDestroyArgs = {
    filter?: Maybe<TeamInvitationKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationTeamInvitationResendArgs = {
    data: TeamInvitationResendInput;
};
export declare type MutationTeamInvitationRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationTeamMemberDeleteArgs = {
    data?: Maybe<TeamMemberDeleteInput>;
    filter?: Maybe<TeamMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationTeamMemberDestroyArgs = {
    filter?: Maybe<TeamMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationTeamMemberRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationTeamMemberUpdateArgs = {
    data: TeamMemberUpdateInput;
    filter?: Maybe<TeamMemberKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationTeamMemberUpdateByFilterArgs = {
    data: TeamMemberUpdateByFilterInput;
    filter?: Maybe<TeamMemberFilter>;
};
export declare type MutationUserChangePasswordArgs = {
    data: ChangePasswordInput;
};
export declare type MutationUserCreateArgs = {
    data: UserCreateInput;
};
export declare type MutationUserCreateManyArgs = {
    data: Array<Maybe<UserCreateManyInput>>;
};
export declare type MutationUserDeleteArgs = {
    data?: Maybe<UserDeleteInput>;
    filter?: Maybe<UserKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationUserDestroyArgs = {
    filter?: Maybe<UserKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationUserLoginArgs = {
    data: UserLoginInput;
};
export declare type MutationUserPasswordForgotArgs = {
    data: PasswordForgotInput;
};
export declare type MutationUserPasswordForgotConfirmArgs = {
    data: PasswordForgotConfirmInput;
};
export declare type MutationUserRefreshTokenArgs = {
    data: RefreshTokenInput;
};
export declare type MutationUserRestoreArgs = {
    id: Scalars['String'];
};
export declare type MutationUserSignUpArgs = {
    user: UserCreateInput;
    authProfileId?: Maybe<Scalars['ID']>;
};
export declare type MutationUserSignUpResendArgs = {
    data: SignUpResendInput;
};
export declare type MutationUserSignUpWithPasswordArgs = {
    user: UserCreateInput;
    password: Scalars['String'];
    authProfileId?: Maybe<Scalars['ID']>;
};
export declare type MutationUserSignUpWithTokenArgs = {
    user: UserCreateInput;
    authProfileId?: Maybe<Scalars['ID']>;
};
export declare type MutationUserUpdateArgs = {
    data: UserUpdateInput;
    filter?: Maybe<UserKeyFilter>;
    force?: Maybe<Scalars['Boolean']>;
    destroyDetached?: Maybe<Scalars['Boolean']>;
};
export declare type MutationUserUpdateByFilterArgs = {
    data: UserUpdateByFilterInput;
    filter?: Maybe<UserFilter>;
};
export declare type MutationUserVerificationEmailResendArgs = {
    data: VerificationEmailResendInput;
    authProfileId?: Maybe<Scalars['ID']>;
};
export declare type MutationViewCreateArgs = {
    data: ViewCreateInput;
};
export declare type MutationViewUpdateArgs = {
    data: ViewUpdateInput;
};
export declare type MutationWorkspaceCreateArgs = {
    data: WorkspaceCreateMutationInput;
};
export declare type MutationWorkspaceCreateAsyncArgs = {
    data: WorkspaceCreateMutationInput;
};
export declare type MutationWorkspaceDeleteArgs = {
    data: WorkspaceDeleteMutationInput;
};
export declare type MutationWorkspaceLeaveArgs = {
    force?: Maybe<Scalars['Boolean']>;
};
export declare type MutationWorkspaceUpdateArgs = {
    data: WorkspaceUpdateMutationInput;
};
export declare type MutationFindOrCreateDmArgs = {
    data: FindOrCreateDmInput;
};
export declare type MutationType = 'create' | 'update' | 'delete' | 'destroy';
/** Number Field Attributes */
export declare 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 declare type NumberTypeFormatEnum = 'NUMBER' | 'CURRENCY' | 'PERCENTAGE' | 'FRACTION' | 'SCIENTIFIC';
/** PasswordForgotConfirmInput */
export declare type PasswordForgotConfirmInput = {
    email: Scalars['String'];
    code: Scalars['String'];
    newPassword: Scalars['String'];
    authProfileId: Scalars['ID'];
};
/** PasswordForgotInput */
export declare type PasswordForgotInput = {
    email: Scalars['String'];
    authProfileId: Scalars['ID'];
};
export declare type PatternFunctionArguments = {
    pattern: Scalars['String'];
    escape?: Maybe<Scalars['String']>;
};
export declare 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 declare 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 declare 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 declare type PermissionInputFilter = {
    resourceType?: Maybe<PermissionResourceTypeEnum>;
    action?: Maybe<Scalars['String']>;
    resource?: Maybe<Scalars['String']>;
    applicationName?: Maybe<Scalars['String']>;
};
/** PermissionListResponse output */
export declare type PermissionListResponse = {
    __typename?: 'PermissionListResponse';
    /** List items */
    items: Array<Permission>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** Permissions subscription payload */
export declare type PermissionPayload = {
    __typename?: 'PermissionPayload';
    mutation: MutationType;
    node?: Maybe<Permission>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<Permission>;
};
export declare 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 declare type PermissionPermissionRelationFilter = {
    some?: Maybe<PermissionPermissionFilter>;
    every?: Maybe<PermissionPermissionFilter>;
    none?: Maybe<PermissionPermissionFilter>;
};
export declare type PermissionRelationFilter = {
    some?: Maybe<PermissionFilter>;
    every?: Maybe<PermissionFilter>;
    none?: Maybe<PermissionFilter>;
};
export declare type PermissionResourceTypeEnum = 'data' | 'custom';
/** custom permissions input */
export declare type PermissionsCustom = {
    data?: Maybe<PermissionsCustomData>;
    logic?: Maybe<PermissionsCustomLogic>;
    api?: Maybe<PermissionsCustomApi>;
    users?: Maybe<PermissionsCustomUsers>;
    settings?: Maybe<PermissionsCustomSettings>;
};
export declare type PermissionsCustomApi = {
    findOrCreateDM?: Maybe<PermissionsCustomApiResolver>;
};
export declare type PermissionsCustomApiResolver = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomData = {
    schemaManagement?: Maybe<PermissionsCustomDataSchemaManagement>;
    viewerAccess?: Maybe<PermissionsCustomDataViewerAccess>;
};
export declare type PermissionsCustomDataSchemaManagement = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomDataViewerAccess = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomLogic = {
    view?: Maybe<PermissionsCustomLogicView>;
    deploy?: Maybe<PermissionsCustomLogicDeploy>;
    invoke?: Maybe<PermissionsCustomLogicInvoke>;
    logs?: Maybe<PermissionsCustomLogicLogs>;
};
export declare type PermissionsCustomLogicDeploy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomLogicInvoke = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomLogicLogs = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomLogicView = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomSettings = {
    workspaceAdministration?: Maybe<PermissionsCustomSettingsWorkspaceAdministration>;
};
export declare type PermissionsCustomSettingsWorkspaceAdministration = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsCustomUsers = {
    teamAdministration?: Maybe<PermissionsCustomUsersTeamAdministration>;
};
export declare type PermissionsCustomUsersTeamAdministration = {
    allow: Scalars['Boolean'];
};
/** Schema tables permissions input */
export declare type PermissionsData = {
    Users?: Maybe<PermissionsDataUsers>;
    Files?: Maybe<PermissionsDataFiles>;
    Roles?: Maybe<PermissionsDataRoles>;
    Message?: Maybe<PermissionsDataMessage>;
    Channel?: Maybe<PermissionsDataChannel>;
    ChannelMember?: Maybe<PermissionsDataChannelMember>;
};
export declare type PermissionsDataChannel = {
    create?: Maybe<PermissionsDataChannelCreate>;
    read?: Maybe<PermissionsDataChannelRead>;
    update?: Maybe<PermissionsDataChannelUpdate>;
    delete?: Maybe<PermissionsDataChannelDelete>;
    destroy?: Maybe<PermissionsDataChannelDestroy>;
};
export declare type PermissionsDataChannelCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataChannelDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataChannelDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataChannelMember = {
    create?: Maybe<PermissionsDataChannelMemberCreate>;
    read?: Maybe<PermissionsDataChannelMemberRead>;
    update?: Maybe<PermissionsDataChannelMemberUpdate>;
    delete?: Maybe<PermissionsDataChannelMemberDelete>;
    destroy?: Maybe<PermissionsDataChannelMemberDestroy>;
};
export declare type PermissionsDataChannelMemberCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataChannelMemberDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataChannelMemberDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataChannelMemberRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<ChannelMemberPermissionFilter>;
    fields?: Maybe<ChannelMemberFieldsPermissions>;
};
export declare type PermissionsDataChannelMemberUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<ChannelMemberPermissionFilter>;
    fields?: Maybe<ChannelMemberFieldsPermissions>;
};
export declare type PermissionsDataChannelRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<ChannelPermissionFilter>;
    fields?: Maybe<ChannelFieldsPermissions>;
};
export declare type PermissionsDataChannelUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<ChannelPermissionFilter>;
    fields?: Maybe<ChannelFieldsPermissions>;
};
export declare type PermissionsDataFiles = {
    create?: Maybe<PermissionsDataFilesCreate>;
    read?: Maybe<PermissionsDataFilesRead>;
    update?: Maybe<PermissionsDataFilesUpdate>;
    delete?: Maybe<PermissionsDataFilesDelete>;
    destroy?: Maybe<PermissionsDataFilesDestroy>;
};
export declare type PermissionsDataFilesCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataFilesDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataFilesDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataFilesRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<FilePermissionFilter>;
    fields?: Maybe<FileFieldsPermissions>;
};
export declare type PermissionsDataFilesUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<FilePermissionFilter>;
    fields?: Maybe<FileFieldsPermissions>;
};
export declare type PermissionsDataMessage = {
    create?: Maybe<PermissionsDataMessageCreate>;
    read?: Maybe<PermissionsDataMessageRead>;
    update?: Maybe<PermissionsDataMessageUpdate>;
    delete?: Maybe<PermissionsDataMessageDelete>;
    destroy?: Maybe<PermissionsDataMessageDestroy>;
};
export declare type PermissionsDataMessageCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataMessageDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataMessageDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataMessageRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<MessagePermissionFilter>;
    fields?: Maybe<MessageFieldsPermissions>;
};
export declare type PermissionsDataMessageUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<MessagePermissionFilter>;
    fields?: Maybe<MessageFieldsPermissions>;
};
export declare type PermissionsDataRoles = {
    create?: Maybe<PermissionsDataRolesCreate>;
    read?: Maybe<PermissionsDataRolesRead>;
    update?: Maybe<PermissionsDataRolesUpdate>;
    delete?: Maybe<PermissionsDataRolesDelete>;
    destroy?: Maybe<PermissionsDataRolesDestroy>;
};
export declare type PermissionsDataRolesCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataRolesDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataRolesDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataRolesRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<RolePermissionFilter>;
    fields?: Maybe<RoleFieldsPermissions>;
};
export declare type PermissionsDataRolesUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<RolePermissionFilter>;
    fields?: Maybe<RoleFieldsPermissions>;
};
export declare type PermissionsDataUsers = {
    create?: Maybe<PermissionsDataUsersCreate>;
    read?: Maybe<PermissionsDataUsersRead>;
    update?: Maybe<PermissionsDataUsersUpdate>;
    delete?: Maybe<PermissionsDataUsersDelete>;
    destroy?: Maybe<PermissionsDataUsersDestroy>;
};
export declare type PermissionsDataUsersCreate = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataUsersDelete = {
    allow: Scalars['Boolean'];
    restore?: Maybe<Scalars['Boolean']>;
    review?: Maybe<Scalars['Boolean']>;
};
export declare type PermissionsDataUsersDestroy = {
    allow: Scalars['Boolean'];
};
export declare type PermissionsDataUsersRead = {
    allow: Scalars['Boolean'];
    filter?: Maybe<UserPermissionFilter>;
    fields?: Maybe<UserFieldsPermissions>;
};
export declare type PermissionsDataUsersUpdate = {
    allow: Scalars['Boolean'];
    filter?: Maybe<UserPermissionFilter>;
    fields?: Maybe<UserFieldsPermissions>;
};
/** PermissionsInput create input */
export declare type PermissionsInput = {
    data?: Maybe<PermissionsData>;
    custom?: Maybe<PermissionsCustom>;
};
/** Permissions subscription filter */
export declare type PermissionSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<PermissionFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
export declare 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 declare type QueryApiTokenArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryApplicationArgs = {
    id: Scalars['String'];
};
export declare type QueryAsyncSessionStatusArgs = {
    sessionId: Scalars['String'];
};
export declare type QueryAuthenticationProfileArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryBillingInvoicesListArgs = {
    by?: Maybe<BillingInvoicesListFilterType>;
    limit?: Maybe<Scalars['Int']>;
    before?: Maybe<Scalars['ID']>;
    after?: Maybe<Scalars['ID']>;
};
export declare type QueryBillingMetricUsagesListArgs = {
    filter?: Maybe<BillingMetricUsagesListFilter>;
};
export declare type QueryChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare type QueryChannelMemberArgs = {
    id?: Maybe<Scalars['ID']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare 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 declare type QueryDeployStatusArgs = {
    buildName: Scalars['String'];
};
export declare type QueryEnvironmentVariableArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryFileArgs = {
    id?: Maybe<Scalars['ID']>;
    fileId?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryFunctionsListArgs = {
    applicationId?: Maybe<Scalars['String']>;
    filter?: Maybe<FunctionInfoFilter>;
    orderBy?: Maybe<Array<Maybe<FunctionInfoOrderBy>>>;
};
export declare type QueryLogsArgs = {
    functionName: Scalars['String'];
    applicationId?: Maybe<Scalars['String']>;
    limit?: Maybe<Scalars['Int']>;
    startTime?: Maybe<Scalars['DateTime']>;
    endTime?: Maybe<Scalars['DateTime']>;
};
export declare type QueryMessageArgs = {
    id?: Maybe<Scalars['ID']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryRoleArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryTableArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
export declare type QueryTableFieldArgs = {
    id: Scalars['ID'];
};
export declare type QueryTablesListArgs = {
    filter?: Maybe<TableListFilter>;
};
export declare type QueryTeamInvitationDetailsArgs = {
    uuid: Scalars['String'];
};
export declare type QueryTeamMemberArgs = {
    id?: Maybe<Scalars['ID']>;
    userId?: Maybe<Scalars['ID']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type QueryUserArgs = {
    id?: Maybe<Scalars['ID']>;
    email?: Maybe<Scalars['String']>;
    withDeleted?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type RefreshTokenInput = {
    email?: Maybe<Scalars['String']>;
    refreshToken: Scalars['String'];
    authProfileId?: Maybe<Scalars['ID']>;
};
/** Relation */
export declare 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 declare type RelationCreateInput = {
    refTableId: Scalars['ID'];
    refFieldName?: Maybe<Scalars['String']>;
    refFieldDisplayName?: Maybe<Scalars['String']>;
    refFieldIsList: Scalars['Boolean'];
    refFieldIsRequired: Scalars['Boolean'];
};
/** Relation Update Input */
export declare type RelationUpdateInput = {
    refTableId?: Maybe<Scalars['ID']>;
    refFieldName?: Maybe<Scalars['String']>;
    refFieldDisplayName?: Maybe<Scalars['String']>;
    refFieldIsList?: Maybe<Scalars['Boolean']>;
    refFieldIsRequired?: Maybe<Scalars['Boolean']>;
};
export declare type ReplaceFunctionArguments = {
    from: Scalars['String'];
    to: Scalars['String'];
};
export declare 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 declare 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 declare 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 declare 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 declare 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 declare type RolePermissionsArgs = {
    filter?: Maybe<PermissionInputFilter>;
};
/** Roles create input */
export declare 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 declare 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 declare type RoleDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** RoleFieldsPermissions create input */
export declare type RoleFieldsPermissions = {
    createdAt?: Maybe<Scalars['Boolean']>;
    updatedAt?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['Boolean']>;
    description?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type RoleGroupBy = {
    query: RoleGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type RoleKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** RoleListResponse output */
export declare type RoleListResponse = {
    __typename?: 'RoleListResponse';
    /** List items */
    items: Array<Role>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** RoleManyResponse output */
export declare type RoleManyResponse = {
    __typename?: 'RoleManyResponse';
    /** List items */
    items: Array<Role>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type RolePayload = {
    __typename?: 'RolePayload';
    mutation: MutationType;
    node?: Maybe<Role>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<Role>;
};
export declare 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 declare type RolePermissionRelationFilter = {
    some?: Maybe<RolePermissionFilter>;
    every?: Maybe<RolePermissionFilter>;
    none?: Maybe<RolePermissionFilter>;
};
export declare type RoleRelationFilter = {
    some?: Maybe<RoleFilter>;
    every?: Maybe<RoleFilter>;
    none?: Maybe<RoleFilter>;
};
/** ApiTokens update input from roles */
export declare type Roles_ApiTokenUpdateInput = {
    filter?: Maybe<ApiTokenKeyFilter>;
    data: ApiTokenUpdateInput;
};
/** AuthenticationProfiles create input from roles */
export declare 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 declare type Roles_AuthenticationProfileUpdateInput = {
    filter?: Maybe<AuthenticationProfileKeyFilter>;
    data: AuthenticationProfileUpdateInput;
};
/** TeamMembers update input from roles */
export declare type Roles_TeamMemberUpdateInput = {
    filter?: Maybe<TeamMemberKeyFilter>;
    data: TeamMemberUpdateInput;
};
/** Users create input from roles */
export declare 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 declare type Roles_UserUpdateInput = {
    filter?: Maybe<UserKeyFilter>;
    data: UserUpdateInput;
};
/** Roles relation input */
export declare type RolesApiTokensManyRelationInput = {
    connect?: Maybe<Array<ApiTokenKeyFilter>>;
};
/** Roles relation input */
export declare type RolesApiTokensRelationInput = {
    connect?: Maybe<Array<ApiTokenKeyFilter>>;
};
/** Roles relation input */
export declare type RolesApiTokensUpdateRelationInput = {
    connect?: Maybe<Array<ApiTokenKeyFilter>>;
    disconnect?: Maybe<Array<ApiTokenKeyFilter>>;
    reconnect?: Maybe<Array<ApiTokenKeyFilter>>;
    update?: Maybe<Array<Maybe<Roles_ApiTokenUpdateInput>>>;
};
/** Roles relation input */
export declare type RolesAuthenticationProfilesManyRelationInput = {
    connect?: Maybe<Array<AuthenticationProfileKeyFilter>>;
};
/** Roles relation input */
export declare type RolesAuthenticationProfilesRelationInput = {
    connect?: Maybe<Array<AuthenticationProfileKeyFilter>>;
    create?: Maybe<Array<Maybe<Roles_AuthenticationProfileCreateInput>>>;
};
/** Roles relation input */
export declare 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 declare 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 declare type RolesTeamMembersManyRelationInput = {
    connect?: Maybe<Array<TeamMemberKeyFilter>>;
};
/** Roles relation input */
export declare type RolesTeamMembersRelationInput = {
    connect?: Maybe<Array<TeamMemberKeyFilter>>;
};
/** Roles relation input */
export declare type RolesTeamMembersUpdateRelationInput = {
    connect?: Maybe<Array<TeamMemberKeyFilter>>;
    disconnect?: Maybe<Array<TeamMemberKeyFilter>>;
    reconnect?: Maybe<Array<TeamMemberKeyFilter>>;
    update?: Maybe<Array<Maybe<Roles_TeamMemberUpdateInput>>>;
};
/** Roles subscription filter */
export declare type RoleSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<RoleFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Roles relation input */
export declare type RolesUsersManyRelationInput = {
    connect?: Maybe<Array<UserKeyFilter>>;
};
/** Roles relation input */
export declare type RolesUsersRelationInput = {
    connect?: Maybe<Array<UserKeyFilter>>;
    create?: Maybe<Array<Maybe<Roles_UserCreateInput>>>;
};
/** Roles relation input */
export declare 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 declare type RoleUpdateByFilterInput = {
    name?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    description?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
    systemType?: Maybe<Array<Maybe<UpdateByFilterStringInput>>>;
};
/** Roles update input */
export declare 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 declare type SchemaOrigin = {
    __typename?: 'SchemaOrigin';
    type: SchemaOriginType;
    provider?: Maybe<Scalars['String']>;
};
/** Schema Origin Type Enum */
export declare type SchemaOriginType = 'REMOTE' | 'LOCAL' | 'VIEW';
export declare 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 declare 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 declare type SettingGroupBy = {
    query: SettingGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare 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 declare 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 declare type SettingPayload = {
    __typename?: 'SettingPayload';
    mutation: MutationType;
    node?: Maybe<Setting>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<Setting>;
};
export declare 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 declare type SettingPermissionRelationFilter = {
    some?: Maybe<SettingPermissionFilter>;
    every?: Maybe<SettingPermissionFilter>;
    none?: Maybe<SettingPermissionFilter>;
};
export declare type SettingRelationFilter = {
    some?: Maybe<SettingFilter>;
    every?: Maybe<SettingFilter>;
    none?: Maybe<SettingFilter>;
};
export declare 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 declare type SettingSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<SettingFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Settings update input */
export declare 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 declare type SignUpResendInput = {
    email: Scalars['String'];
};
/** Smart Field Attributes */
export declare type SmartFieldTypeAttributes = {
    __typename?: 'SmartFieldTypeAttributes';
    format: Scalars['String'];
    innerFields?: Maybe<Array<Maybe<CustomTableField>>>;
};
/** Smart Type Format Enum */
export declare type SmartTypeFormatEnum = 'ADDRESS' | 'PHONE';
/** SortOrder */
export declare type SortOrder = 'ASC' | 'DESC';
export declare type StringPadFunctionArguments = {
    len: Scalars['Int'];
    str: Scalars['String'];
};
export declare 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 declare 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 declare type StringTrimMode = 'BOTH' | 'LEADING' | 'TRAILING';
export declare 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 declare type SubscriptionApiTokensArgs = {
    filter?: Maybe<ApiTokenSubscriptionFilter>;
};
export declare type SubscriptionAuthenticationProfilesArgs = {
    filter?: Maybe<AuthenticationProfileSubscriptionFilter>;
};
export declare type SubscriptionAuthenticationSettingsArgs = {
    filter?: Maybe<AuthenticationSettingSubscriptionFilter>;
};
export declare type SubscriptionChannelArgs = {
    filter?: Maybe<ChannelSubscriptionFilter>;
};
export declare type SubscriptionChannelMemberArgs = {
    filter?: Maybe<ChannelMemberSubscriptionFilter>;
};
export declare type SubscriptionEnvironmentVariablesArgs = {
    filter?: Maybe<EnvironmentVariableSubscriptionFilter>;
};
export declare type SubscriptionFilesArgs = {
    filter?: Maybe<FileSubscriptionFilter>;
};
export declare type SubscriptionMessageArgs = {
    filter?: Maybe<MessageSubscriptionFilter>;
};
export declare type SubscriptionPermissionsArgs = {
    filter?: Maybe<PermissionSubscriptionFilter>;
};
export declare type SubscriptionRolesArgs = {
    filter?: Maybe<RoleSubscriptionFilter>;
};
export declare type SubscriptionSettingsArgs = {
    filter?: Maybe<SettingSubscriptionFilter>;
};
export declare type SubscriptionTeamInvitationsArgs = {
    filter?: Maybe<TeamInvitationSubscriptionFilter>;
};
export declare type SubscriptionTeamMembersArgs = {
    filter?: Maybe<TeamMemberSubscriptionFilter>;
};
export declare type SubscriptionUsersArgs = {
    filter?: Maybe<UserSubscriptionFilter>;
};
export declare type SubstringFunctionArguments = {
    pos: Scalars['Int'];
    len?: Maybe<Scalars['Int']>;
};
export declare type SuccessResponse = {
    __typename?: 'SuccessResponse';
    success?: Maybe<Scalars['Boolean']>;
};
/** Switch Field Attributes */
export declare type SwitchFieldTypeAttributes = {
    __typename?: 'SwitchFieldTypeAttributes';
    format: Scalars['String'];
    listOptions?: Maybe<Array<Maybe<Scalars['String']>>>;
};
/** Switch Type Format Enum */
export declare type SwitchTypeFormatEnum = 'ON_OFF' | 'YES_NO' | 'TRUE_FALSE' | 'ACTIVE_INACTIVE' | 'HIGH_LOW' | 'CUSTOM';
/** Application */
export declare 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 declare type SystemApplicationDeleteMutationInput = {
    id: Scalars['String'];
    force?: Maybe<Scalars['Boolean']>;
};
/** Application install input */
export declare type SystemApplicationInstallInput = {
    appType: Scalars['String'];
    name: Scalars['String'];
    status?: Maybe<SystemApplicationStatusEnum>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** SystemApplicationListResponse output */
export declare type SystemApplicationListResponse = {
    __typename?: 'SystemApplicationListResponse';
    /** List items */
    items: Array<SystemApplication>;
    /** List items count */
    count: Scalars['Int'];
};
/** Application Status Enum */
export declare type SystemApplicationStatusEnum = 'ACTIVE' | 'INACTIVE';
/** Application update input */
export declare type SystemApplicationUpdateInput = {
    id: Scalars['String'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    status?: Maybe<SystemApplicationStatusEnum>;
};
export declare 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 declare type SystemBillingDetailsResponse = {
    __typename?: 'SystemBillingDetailsResponse';
    last4?: Maybe<Scalars['String']>;
    expMonth?: Maybe<Scalars['Int']>;
    expYear?: Maybe<Scalars['Int']>;
    brand?: Maybe<Scalars['String']>;
};
/** BillingDetailsUpdateMutationInput */
export declare type SystemBillingDetailsUpdateMutationInput = {
    cardToken: Scalars['String'];
};
export declare 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 declare type SystemBillingInvoicesListFilterType = 'WORKSPACE' | 'CUSTOMER';
/** SystemBillingInvoicesListResponse output */
export declare type SystemBillingInvoicesListResponse = {
    __typename?: 'SystemBillingInvoicesListResponse';
    /** List items */
    items: Array<SystemBillingInvoiceItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type SystemBillingLimitMetricItem = {
    __typename?: 'SystemBillingLimitMetricItem';
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    showPriority?: Maybe<Scalars['Int']>;
    unit?: Maybe<Scalars['String']>;
};
export declare type SystemBillingMetricUsageItem = {
    __typename?: 'SystemBillingMetricUsageItem';
    limitMetric?: Maybe<SystemBillingLimitMetricItem>;
    value?: Maybe<Scalars['Float']>;
};
export declare type SystemBillingMetricUsageQuotaItem = {
    __typename?: 'SystemBillingMetricUsageQuotaItem';
    limitMetric?: Maybe<SystemBillingLimitMetricItem>;
    value?: Maybe<Scalars['Float']>;
};
/** SystemBillingMetricUsageQuotasListResponse output */
export declare type SystemBillingMetricUsageQuotasListResponse = {
    __typename?: 'SystemBillingMetricUsageQuotasListResponse';
    /** List items */
    items: Array<SystemBillingMetricUsageQuotaItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type SystemBillingMetricUsagesListFilter = {
    entryDate: DateTimePredicate;
};
/** SystemBillingMetricUsagesListResponse output */
export declare type SystemBillingMetricUsagesListResponse = {
    __typename?: 'SystemBillingMetricUsagesListResponse';
    /** List items */
    items: Array<SystemBillingMetricUsageItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type SystemBillingNextPlanResponse = {
    __typename?: 'SystemBillingNextPlanResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    price?: Maybe<Scalars['Int']>;
    displayName?: Maybe<Scalars['String']>;
};
export declare 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 declare 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 declare type SystemBillingPlanUpdateMutationInput = {
    planId: Scalars['ID'];
};
export declare type SystemBranchEnvironmentMode = 'FULL' | 'SYSTEM';
/** Ci Status */
export declare type SystemCiStatusOutput = {
    __typename?: 'SystemCiStatusOutput';
    status: Scalars['String'];
    migrations?: Maybe<Array<Maybe<Scalars['String']>>>;
};
/** Computed field mode */
export declare type SystemComputedFieldMode = 'VIRTUAL' | 'STORED';
/** Custom Table Field Type */
export declare 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 declare type SystemDateFieldTypeAttributes = {
    __typename?: 'SystemDateFieldTypeAttributes';
    format: Scalars['String'];
};
/** Date Type Format Enum */
export declare type SystemDateTypeFormatEnum = 'DATE' | 'DATETIME';
/** DeployDataResponse */
export declare type SystemDeployDataResponse = {
    __typename?: 'SystemDeployDataResponse';
    uploadBuildUrl: Scalars['String'];
    uploadMetaDataUrl: Scalars['String'];
    buildName: Scalars['String'];
};
/** DeployingBuildInput */
export declare type SystemDeployingBuildInput = {
    buildName: Scalars['String'];
    options?: Maybe<SystemDeployOptions>;
};
export declare type SystemDeployModeEnum = 'FULL' | 'ONLY_PLUGINS' | 'ONLY_PROJECT' | 'FUNCTIONS' | 'MIGRATIONS';
/** DeployOptions */
export declare type SystemDeployOptions = {
    mode?: Maybe<SystemDeployModeEnum>;
    pluginNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    extensionNames?: Maybe<Array<Maybe<Scalars['String']>>>;
};
export declare type SystemDeployStatusEnum = 'deploying' | 'complete_error' | 'complete_success' | 'compiling' | 'preparing' | 'initialize';
/** SystemDeployStatusResult */
export declare type SystemDeployStatusResult = {
    __typename?: 'SystemDeployStatusResult';
    status: SystemDeployStatusEnum;
    message?: Maybe<Scalars['String']>;
};
/** SystemEnvironmentBackupListResponse output */
export declare type SystemEnvironmentBackupListResponse = {
    __typename?: 'SystemEnvironmentBackupListResponse';
    /** List items */
    items: Array<EnvironmentBackupItem>;
    /** List items count */
    count: Scalars['Int'];
};
/** SystemEnvironmentsListResponse output */
export declare type SystemEnvironmentsListResponse = {
    __typename?: 'SystemEnvironmentsListResponse';
    /** List items */
    items: Array<EnvironmentItem>;
    /** List items count */
    count: Scalars['Int'];
};
/** Field Data Features */
export declare type SystemFieldDataFeatures = {
    __typename?: 'SystemFieldDataFeatures';
    create: Scalars['Boolean'];
    update: Scalars['Boolean'];
    sort: Scalars['Boolean'];
};
/** Field Schema Features */
export declare type SystemFieldSchemaFeatures = {
    __typename?: 'SystemFieldSchemaFeatures';
    update: Scalars['Boolean'];
    delete: Scalars['Boolean'];
};
/** Field types */
export declare type SystemFieldType = 'ID' | 'UUID' | 'JSON' | 'NUMBER' | 'TEXT' | 'DATE' | 'SWITCH' | 'RELATION' | 'FILE' | 'SMART' | 'GEO' | 'ONE_WAY_RELATION' | 'MISSING_RELATION';
/** Field Type Attributes */
export declare type SystemFieldTypeAttributes = SystemDateFieldTypeAttributes | SystemFileFieldTypeAttributes | SystemMissingRelationFieldTypeAttributes | SystemNumberFieldTypeAttributes | SystemSmartFieldTypeAttributes | SystemSwitchFieldTypeAttributes | SystemTextFieldTypeAttributes | SystemUuidFieldTypeAttributes | SystemGeoFieldTypeAttributes;
/** Field Type Attributes Input */
export declare 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 declare 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 declare type SystemFileTypeFormatEnum = 'FILE' | 'IMAGE';
/** FunctionInfo */
export declare type SystemFunctionInfo = {
    name: Scalars['String'];
    functionType: SystemFunctionType;
    description?: Maybe<Scalars['String']>;
    application?: Maybe<SystemApplication>;
};
/** FunctionInfoFilter */
export declare type SystemFunctionInfoFilter = {
    name?: Maybe<Scalars['String']>;
    functionType?: Maybe<SystemFunctionType>;
    description?: Maybe<Scalars['String']>;
};
/** FunctionInfoOrderBy */
export declare type SystemFunctionInfoOrderBy = 'name_ASC' | 'name_DESC' | 'functionType_ASC' | 'functionType_DESC' | 'description_ASC' | 'description_DESC';
/** SystemFunctionListResponse output */
export declare type SystemFunctionListResponse = {
    __typename?: 'SystemFunctionListResponse';
    /** List items */
    items: Array<SystemFunctionInfo>;
    /** List items count */
    count: Scalars['Int'];
};
/** FunctionLogEntry */
export declare type SystemFunctionLogEntry = {
    __typename?: 'SystemFunctionLogEntry';
    timestamp?: Maybe<Scalars['DateTime']>;
    message?: Maybe<Scalars['String']>;
};
/** FunctionResolverInfo */
export declare type SystemFunctionResolverInfo = SystemFunctionInfo & {
    __typename?: 'SystemFunctionResolverInfo';
    name: Scalars['String'];
    functionType: SystemFunctionType;
    description?: Maybe<Scalars['String']>;
    gqlType: Scalars['String'];
    application?: Maybe<SystemApplication>;
};
/** FunctionTaskInfo */
export declare type SystemFunctionTaskInfo = SystemFunctionInfo & {
    __typename?: 'SystemFunctionTaskInfo';
    name: Scalars['String'];
    functionType: SystemFunctionType;
    description?: Maybe<Scalars['String']>;
    scheduleExpression?: Maybe<Scalars['String']>;
    application?: Maybe<SystemApplication>;
};
/** FunctionTriggerInfo */
export declare 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 declare type SystemFunctionType = 'resolver' | 'trigger' | 'webhook' | 'task' | 'schedule';
/** FunctionWebhookInfo */
export declare 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 declare type SystemGeoFieldTypeAttributes = {
    __typename?: 'SystemGeoFieldTypeAttributes';
    format: Scalars['String'];
    srid?: Maybe<Scalars['Int']>;
};
/** Table Create Index Input */
export declare type SystemIndexCreateInput = {
    tableId: Scalars['ID'];
    type: TableIndexType;
    columns: Array<SystemTableIndexColumnInput>;
    force?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
};
/** Table Delete Index Input */
export declare type SystemIndexDeleteInput = {
    id: Scalars['ID'];
};
/** Table Update Index Input */
export declare type SystemIndexUpdateInput = {
    id: Scalars['ID'];
    type?: Maybe<TableIndexType>;
    columns?: Maybe<Array<SystemTableIndexColumnInput>>;
    force?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
};
/** InvokeData */
export declare type SystemInvokeData = {
    functionName: Scalars['String'];
    inputArgs?: Maybe<Scalars['String']>;
};
/** InvokeFunctionResponse */
export declare type SystemInvokeFunctionResponse = {
    __typename?: 'SystemInvokeFunctionResponse';
    responseData: Scalars['String'];
};
/** MissingRelation Field Attributes */
export declare type SystemMissingRelationFieldTypeAttributes = {
    __typename?: 'SystemMissingRelationFieldTypeAttributes';
    missingTable: Scalars['String'];
};
export declare 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 declare type SystemMutationApplicationDeleteArgs = {
    data: SystemApplicationDeleteMutationInput;
};
export declare type SystemMutationApplicationInstallArgs = {
    data: SystemApplicationInstallInput;
};
export declare type SystemMutationApplicationUpdateArgs = {
    data: SystemApplicationUpdateInput;
};
export declare type SystemMutationBillingDetailsUpdateArgs = {
    data: SystemBillingDetailsUpdateMutationInput;
};
export declare type SystemMutationBillingPlanUpdateArgs = {
    data: SystemBillingPlanUpdateMutationInput;
};
export declare type SystemMutationDeployArgs = {
    data?: Maybe<SystemDeployingBuildInput>;
};
export declare type SystemMutationEnvironmentBackupArgs = {
    environmentName: Scalars['String'];
};
export declare type SystemMutationEnvironmentBranchArgs = {
    name: Scalars['String'];
    mode?: Maybe<SystemBranchEnvironmentMode>;
};
export declare type SystemMutationEnvironmentDeleteArgs = {
    environmentName: Scalars['String'];
};
export declare type SystemMutationEnvironmentRestoreArgs = {
    environmentName: Scalars['String'];
    backup: Scalars['String'];
};
export declare type SystemMutationFieldCreateArgs = {
    data: SystemTableFieldCreateInput;
};
export declare type SystemMutationFieldDeleteArgs = {
    data: SystemTableFieldDeleteInput;
};
export declare type SystemMutationFieldUpdateArgs = {
    data: SystemTableFieldUpdateInput;
};
export declare type SystemMutationFieldUpdatePositionArgs = {
    data: SystemTableFieldPositionUpdateInput;
};
export declare type SystemMutationIndexCreateArgs = {
    data: SystemIndexCreateInput;
};
export declare type SystemMutationIndexDeleteArgs = {
    data: SystemIndexDeleteInput;
};
export declare type SystemMutationIndexUpdateArgs = {
    data: SystemIndexUpdateInput;
};
export declare type SystemMutationInvokeArgs = {
    data?: Maybe<SystemInvokeData>;
};
export declare type SystemMutationTableCreateArgs = {
    data: SystemTableCreateInput;
};
export declare type SystemMutationTableDeleteArgs = {
    data: SystemTableDeleteInput;
};
export declare type SystemMutationTableUpdateArgs = {
    data: SystemTableUpdateInput;
};
export declare type SystemMutationViewCreateArgs = {
    data: SystemViewCreateInput;
};
export declare type SystemMutationViewUpdateArgs = {
    data: SystemViewUpdateInput;
};
export declare type SystemMutationWorkspaceCreateArgs = {
    data: SystemWorkspaceCreateMutationInput;
};
export declare type SystemMutationWorkspaceCreateAsyncArgs = {
    data: SystemWorkspaceCreateMutationInput;
};
export declare type SystemMutationWorkspaceDeleteArgs = {
    data: SystemWorkspaceDeleteMutationInput;
};
export declare type SystemMutationWorkspaceLeaveArgs = {
    force?: Maybe<Scalars['Boolean']>;
};
export declare type SystemMutationWorkspaceUpdateArgs = {
    data: SystemWorkspaceUpdateMutationInput;
};
/** Number Field Attributes */
export declare 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 declare type SystemNumberTypeFormatEnum = 'NUMBER' | 'CURRENCY' | 'PERCENTAGE' | 'FRACTION' | 'SCIENTIFIC';
/** Diff Environment Input */
export declare type SystemPlanEnvironmentOutput = {
    __typename?: 'SystemPlanEnvironmentOutput';
    url?: Maybe<Scalars['String']>;
};
export declare 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 declare type SystemQueryApplicationArgs = {
    id: Scalars['String'];
};
export declare type SystemQueryBillingInvoicesListArgs = {
    by?: Maybe<SystemBillingInvoicesListFilterType>;
    limit?: Maybe<Scalars['Int']>;
    before?: Maybe<Scalars['ID']>;
    after?: Maybe<Scalars['ID']>;
};
export declare type SystemQueryBillingMetricUsagesListArgs = {
    filter?: Maybe<SystemBillingMetricUsagesListFilter>;
};
export declare type SystemQueryDeployStatusArgs = {
    buildName: Scalars['String'];
};
export declare type SystemQueryEnvironmentBackupsListArgs = {
    environmentName?: Maybe<Scalars['String']>;
};
export declare type SystemQueryFunctionsListArgs = {
    applicationId?: Maybe<Scalars['String']>;
    filter?: Maybe<SystemFunctionInfoFilter>;
    orderBy?: Maybe<Array<Maybe<SystemFunctionInfoOrderBy>>>;
};
export declare type SystemQueryLogsArgs = {
    functionName: Scalars['String'];
    applicationId?: Maybe<Scalars['String']>;
    limit?: Maybe<Scalars['Int']>;
    startTime?: Maybe<Scalars['DateTime']>;
    endTime?: Maybe<Scalars['DateTime']>;
};
export declare type SystemQueryLogsListArgs = {
    functionName: Scalars['String'];
    applicationId?: Maybe<Scalars['String']>;
    limit?: Maybe<Scalars['Int']>;
    startTime?: Maybe<Scalars['DateTime']>;
    endTime?: Maybe<Scalars['DateTime']>;
};
export declare type SystemQueryTableArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
export declare type SystemQueryTableFieldArgs = {
    id: Scalars['ID'];
};
export declare type SystemQueryTablesListArgs = {
    filter?: Maybe<SystemTableListFilter>;
};
/** Relation */
export declare 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 declare type SystemRelationCreateInput = {
    refTableId: Scalars['ID'];
    refFieldName?: Maybe<Scalars['String']>;
    refFieldDisplayName?: Maybe<Scalars['String']>;
    refFieldIsList: Scalars['Boolean'];
    refFieldIsRequired: Scalars['Boolean'];
};
/** Relation Update Input */
export declare 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 declare type SystemSchemaOrigin = {
    __typename?: 'SystemSchemaOrigin';
    type: SystemSchemaOriginType;
    provider?: Maybe<Scalars['String']>;
};
/** Schema Origin Type Enum */
export declare type SystemSchemaOriginType = 'REMOTE' | 'LOCAL' | 'VIEW';
/** Smart Field Attributes */
export declare type SystemSmartFieldTypeAttributes = {
    __typename?: 'SystemSmartFieldTypeAttributes';
    format: Scalars['String'];
    innerFields?: Maybe<Array<Maybe<SystemCustomTableField>>>;
};
/** Smart Type Format Enum */
export declare type SystemSmartTypeFormatEnum = 'ADDRESS' | 'PHONE';
/** Switch Field Attributes */
export declare type SystemSwitchFieldTypeAttributes = {
    __typename?: 'SystemSwitchFieldTypeAttributes';
    format: Scalars['String'];
    listOptions?: Maybe<Array<Maybe<Scalars['String']>>>;
};
/** Switch Type Format Enum */
export declare type SystemSwitchTypeFormatEnum = 'ON_OFF' | 'YES_NO' | 'TRUE_FALSE' | 'ACTIVE_INACTIVE' | 'HIGH_LOW' | 'CUSTOM';
/** Table */
export declare 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 declare type SystemTableAttributes = SystemViewAttributes;
/** Table Create Input */
export declare type SystemTableCreateInput = {
    name: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** Table Data Features */
export declare type SystemTableDataFeatures = {
    __typename?: 'SystemTableDataFeatures';
    create: Scalars['Boolean'];
    update: Scalars['Boolean'];
    delete: Scalars['Boolean'];
};
/** Table Delete Input */
export declare type SystemTableDeleteInput = {
    id: Scalars['ID'];
};
/** TableField */
export declare 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 declare 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 declare type SystemTableFieldDeleteInput = {
    id: Scalars['ID'];
};
/** Table Field Position Update Input */
export declare type SystemTableFieldPositionUpdateInput = {
    id: Scalars['ID'];
    newPosition: Scalars['Int'];
};
/** Table Field Update Input */
export declare 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 declare 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 declare type SystemTableIndexColumn = {
    __typename?: 'SystemTableIndexColumn';
    name: Scalars['String'];
};
/** Table Index Column Input */
export declare type SystemTableIndexColumnInput = {
    name: Scalars['String'];
};
/** Table List Filter */
export declare type SystemTableListFilter = {
    onlyUserTables?: Maybe<Scalars['Boolean']>;
    tableNames?: Maybe<Array<Maybe<Scalars['String']>>>;
};
/** Table List Response */
export declare type SystemTableListResponse = {
    __typename?: 'SystemTableListResponse';
    items?: Maybe<Array<Maybe<SystemTable>>>;
    count?: Maybe<Scalars['Int']>;
};
/** Table Schema Create Features */
export declare 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 declare type SystemTableSchemaFeatures = {
    __typename?: 'SystemTableSchemaFeatures';
    create: SystemTableSchemaCreateFeatures;
    update?: Maybe<SystemTableSchemaMetaFieldFeatures>;
    computedFields: Scalars['Boolean'];
};
/** Table Schema Meta Field Features */
export declare type SystemTableSchemaMetaFieldFeatures = {
    __typename?: 'SystemTableSchemaMetaFieldFeatures';
    name: Scalars['Boolean'];
    displayName: Scalars['Boolean'];
};
/** Table Update Input */
export declare type SystemTableUpdateInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** Text Field Attributes */
export declare type SystemTextFieldTypeAttributes = {
    __typename?: 'SystemTextFieldTypeAttributes';
    format: Scalars['String'];
    fieldSize?: Maybe<Scalars['Int']>;
};
/** Text Type Format Enum */
export declare type SystemTextTypeFormatEnum = 'UNFORMATTED' | 'NAME' | 'EIN' | 'EMAIL';
export declare 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 declare type SystemUserBillingConfigurationResponse = {
    __typename?: 'SystemUserBillingConfigurationResponse';
    isFreePlanAvailable: Scalars['Boolean'];
    isCancelSubscriptionAvailable: Scalars['Boolean'];
    availablePlans: Array<SystemBillingPlanBaseInfo>;
};
/** User Type */
export declare type SystemUserType = 'Agency' | 'MyOwn' | 'Team';
/** UUID Field Attributes */
export declare type SystemUuidFieldTypeAttributes = {
    __typename?: 'SystemUUIDFieldTypeAttributes';
    fieldSize?: Maybe<Scalars['Int']>;
};
/** View Attributes */
export declare type SystemViewAttributes = {
    __typename?: 'SystemViewAttributes';
    query?: Maybe<Scalars['String']>;
};
/** View Create Input */
export declare type SystemViewCreateInput = {
    name: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    query: Scalars['String'];
    description?: Maybe<Scalars['String']>;
};
/** View Update Input */
export declare type SystemViewUpdateInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    query?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** WorkspaceCreateMutationInput */
export declare type SystemWorkspaceCreateMutationInput = {
    name: Scalars['String'];
    billingPlanId?: Maybe<Scalars['ID']>;
};
export declare type SystemWorkspaceCreateResponse = {
    __typename?: 'SystemWorkspaceCreateResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** WorkspaceDeleteMutationInput */
export declare type SystemWorkspaceDeleteMutationInput = {
    id: Scalars['ID'];
};
export declare type SystemWorkspaceImage = {
    __typename?: 'SystemWorkspaceImage';
    id?: Maybe<Scalars['String']>;
    downloadUrl?: Maybe<Scalars['String']>;
};
/** SystemWorkspaceListResponse output */
export declare type SystemWorkspaceListResponse = {
    __typename?: 'SystemWorkspaceListResponse';
    /** List items */
    items: Array<WorkspaceItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type SystemWorkspaceStatus = 'active' | 'blocked' | 'canceled' | 'suspended' | 'canceling' | 'pending';
/** WorkspaceUpdateMutationInput */
export declare type SystemWorkspaceUpdateMutationInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
};
export declare type SystemWorkspaceUpdateResponse = {
    __typename?: 'SystemWorkspaceUpdateResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** Table */
export declare 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 declare type TableAttributes = ViewAttributes;
/** Table Create Input */
export declare type TableCreateInput = {
    name: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** Table Data Features */
export declare type TableDataFeatures = {
    __typename?: 'TableDataFeatures';
    create: Scalars['Boolean'];
    update: Scalars['Boolean'];
    delete: Scalars['Boolean'];
};
/** Table Delete Input */
export declare type TableDeleteInput = {
    id: Scalars['ID'];
};
/** TableField */
export declare 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 declare 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 declare type TableFieldDeleteInput = {
    id: Scalars['ID'];
};
/** Table Field Position Update Input */
export declare type TableFieldPositionUpdateInput = {
    id: Scalars['ID'];
    newPosition: Scalars['Int'];
};
/** Table Field Update Input */
export declare 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 declare 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 declare type TableIndexColumn = {
    __typename?: 'TableIndexColumn';
    name: Scalars['String'];
};
/** Table Index Column Input */
export declare type TableIndexColumnInput = {
    name: Scalars['String'];
};
export declare type TableIndexType = 'INDEX' | 'UNIQUE';
/** Table List Filter */
export declare type TableListFilter = {
    onlyUserTables?: Maybe<Scalars['Boolean']>;
    tableNames?: Maybe<Array<Maybe<Scalars['String']>>>;
};
/** Table List Response */
export declare type TableListResponse = {
    __typename?: 'TableListResponse';
    items?: Maybe<Array<Maybe<Table>>>;
    count?: Maybe<Scalars['Int']>;
};
/** Table Schema Create Features */
export declare 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 declare type TableSchemaFeatures = {
    __typename?: 'TableSchemaFeatures';
    create: TableSchemaCreateFeatures;
    update?: Maybe<TableSchemaMetaFieldFeatures>;
    computedFields: Scalars['Boolean'];
};
/** Table Schema Meta Field Features */
export declare type TableSchemaMetaFieldFeatures = {
    __typename?: 'TableSchemaMetaFieldFeatures';
    name: Scalars['Boolean'];
    displayName: Scalars['Boolean'];
};
/** Table Update Input */
export declare type TableUpdateInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
export declare 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 declare type TeamInvitationAcceptInput = {
    uuid: Scalars['String'];
    accepted: Scalars['Boolean'];
};
/** TeamInvitationAcceptResponse */
export declare type TeamInvitationAcceptResponse = {
    __typename?: 'TeamInvitationAcceptResponse';
    success: Scalars['Boolean'];
};
/** Cancel team members invitations input */
export declare type TeamInvitationCancelInput = {
    memberId: Scalars['ID'];
};
/** TeamInvitations delete input */
export declare type TeamInvitationDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** Team Invitation Details */
export declare 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 declare 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 declare type TeamInvitationGroupBy = {
    query: TeamInvitationGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type TeamInvitationKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    uuid?: Maybe<Scalars['String']>;
};
/** TeamInvitationListResponse output */
export declare 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 declare 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 declare type TeamInvitationPayload = {
    __typename?: 'TeamInvitationPayload';
    mutation: MutationType;
    node?: Maybe<TeamInvitation>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<TeamInvitation>;
};
export declare 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 declare type TeamInvitationPermissionRelationFilter = {
    some?: Maybe<TeamInvitationPermissionFilter>;
    every?: Maybe<TeamInvitationPermissionFilter>;
    none?: Maybe<TeamInvitationPermissionFilter>;
};
export declare type TeamInvitationRelationFilter = {
    some?: Maybe<TeamInvitationFilter>;
    every?: Maybe<TeamInvitationFilter>;
    none?: Maybe<TeamInvitationFilter>;
};
/** Resend team invitation input */
export declare type TeamInvitationResendInput = {
    memberId: Scalars['ID'];
};
/** Team Invitations Details List */
export declare type TeamInvitationsDetailsList = {
    __typename?: 'TeamInvitationsDetailsList';
    items?: Maybe<Array<Maybe<TeamInvitationDetails>>>;
    count?: Maybe<Scalars['Int']>;
};
export declare 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 declare type TeamInvitationSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<TeamInvitationFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
export declare 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 declare 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 declare 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 declare 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 declare type TeamMemberPermissionsArgs = {
    filter?: Maybe<PermissionInputFilter>;
};
/** TeamMembers delete input */
export declare type TeamMemberDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
export declare 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 declare type TeamMemberGroupBy = {
    query: TeamMemberGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type TeamMemberKeyFilter = {
    id?: Maybe<Scalars['ID']>;
};
/** TeamMemberListResponse output */
export declare type TeamMemberListResponse = {
    __typename?: 'TeamMemberListResponse';
    /** List items */
    items: Array<TeamMember>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** TeamMemberManyResponse output */
export declare type TeamMemberManyResponse = {
    __typename?: 'TeamMemberManyResponse';
    /** List items */
    items: Array<TeamMember>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type TeamMemberPayload = {
    __typename?: 'TeamMemberPayload';
    mutation: MutationType;
    node?: Maybe<TeamMember>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<TeamMember>;
};
export declare 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 declare type TeamMemberPermissionRelationFilter = {
    some?: Maybe<TeamMemberPermissionFilter>;
    every?: Maybe<TeamMemberPermissionFilter>;
    none?: Maybe<TeamMemberPermissionFilter>;
};
export declare type TeamMemberRelationFilter = {
    some?: Maybe<TeamMemberFilter>;
    every?: Maybe<TeamMemberFilter>;
    none?: Maybe<TeamMemberFilter>;
};
/** Files create input from teamMembers_avatar */
export declare 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 declare 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 declare 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 declare type TeamMembers_RoleUpdateInput = {
    filter?: Maybe<RoleKeyFilter>;
    data: RoleUpdateInput;
};
/** TeamMembers relation input */
export declare type TeamMembersAvatarUpdateRelationInput = {
    connect?: Maybe<FileKeyFilter>;
    disconnect?: Maybe<FileKeyFilter>;
    reconnect?: Maybe<FileKeyFilter>;
    create?: Maybe<TeamMembers_Avatar_FileCreateInput>;
    update?: Maybe<TeamMembers_Avatar_FileUpdateInput>;
};
export declare 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 declare type TeamMembersReceivedTeamInvitationsUpdateRelationInput = {
    connect?: Maybe<Array<TeamInvitationKeyFilter>>;
    disconnect?: Maybe<Array<TeamInvitationKeyFilter>>;
    reconnect?: Maybe<Array<TeamInvitationKeyFilter>>;
};
/** TeamMembers relation input */
export declare 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 declare type TeamMembersSentTeamInvitationsUpdateRelationInput = {
    connect?: Maybe<Array<TeamInvitationKeyFilter>>;
    disconnect?: Maybe<Array<TeamInvitationKeyFilter>>;
    reconnect?: Maybe<Array<TeamInvitationKeyFilter>>;
};
/** TeamMembers subscription filter */
export declare type TeamMemberSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<TeamMemberFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** TeamMembers update input */
export declare 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 declare 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 declare type TextFieldTypeAttributes = {
    __typename?: 'TextFieldTypeAttributes';
    format: Scalars['String'];
    fieldSize?: Maybe<Scalars['Int']>;
};
/** Text Type Format Enum */
export declare type TextTypeFormatEnum = 'UNFORMATTED' | 'NAME' | 'EIN' | 'EMAIL';
export declare type TrimFunctionArguments = {
    str: Scalars['String'];
    mode?: Maybe<StringTrimMode>;
};
export declare type UpdateByFilterBooleanSwitchInput = {
    set?: Maybe<Scalars['Boolean']>;
    invert?: Maybe<Scalars['Boolean']>;
};
export declare type UpdateByFilterDateTimeInput = {
    set?: Maybe<Scalars['String']>;
    add?: Maybe<UpdateByFilterDateTimePartsInput>;
    sub?: Maybe<UpdateByFilterDateTimePartsInput>;
};
export declare 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 declare type UpdateByFilterJsonInput = {
    set?: Maybe<Scalars['JSON']>;
};
export declare type UpdateByFilterStringInput = {
    prefix?: Maybe<Scalars['String']>;
    postfix?: Maybe<Scalars['String']>;
    set?: Maybe<Scalars['String']>;
};
export declare type UpdateByFilterStringSwitchInput = {
    set?: Maybe<Scalars['String']>;
};
/** UpdatedFieldsFilter */
export declare type UpdatedFieldsFilter = {
    contains?: Maybe<Array<Maybe<Scalars['String']>>>;
    every?: Maybe<Array<Maybe<Scalars['String']>>>;
};
export declare 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 declare 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 declare 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 declare type UserPermissionsArgs = {
    filter?: Maybe<PermissionInputFilter>;
};
/** ChannelMember create input from user */
export declare type User_ChannelMemberCreateInput = {
    channel: ChannelMemberChannelRelationInput;
    user?: Maybe<ChannelMemberUserRelationInput>;
    lastReadTS?: Maybe<Scalars['DateTime']>;
};
/** ChannelMember update input from user */
export declare type User_ChannelMemberUpdateInput = {
    filter?: Maybe<ChannelMemberKeyFilter>;
    data: ChannelMemberUpdateInput;
};
export declare type UserBillingConfigurationResponse = {
    __typename?: 'UserBillingConfigurationResponse';
    isFreePlanAvailable: Scalars['Boolean'];
    isCancelSubscriptionAvailable: Scalars['Boolean'];
    availablePlans: Array<BillingPlanBaseInfo>;
};
/** Users create input */
export declare 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 declare 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 declare type UserDeleteInput = {
    id?: Maybe<Scalars['ID']>;
    force?: Maybe<Scalars['Boolean']>;
};
/** UserFieldsPermissions create input */
export declare 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 declare 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 declare type UserGroupBy = {
    query: UserGroupByQuery;
    sort?: Maybe<Array<GroupBySort>>;
    having?: Maybe<Having>;
    first?: Maybe<Scalars['Int']>;
    last?: Maybe<Scalars['Int']>;
    skip?: Maybe<Scalars['Int']>;
};
export declare 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 declare type UserInfoAvatar = {
    __typename?: 'UserInfoAvatar';
    id?: Maybe<Scalars['String']>;
    downloadUrl?: Maybe<Scalars['String']>;
};
/** Invitation Details */
export declare 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 declare type UserInvitationList = {
    __typename?: 'UserInvitationList';
    items?: Maybe<Array<Maybe<UserInvitationDetails>>>;
    count?: Maybe<Scalars['Int']>;
};
export declare type UserKeyFilter = {
    id?: Maybe<Scalars['ID']>;
    email?: Maybe<Scalars['String']>;
};
/** UserListResponse output */
export declare type UserListResponse = {
    __typename?: 'UserListResponse';
    /** List items */
    items: Array<User>;
    /** List items count */
    count: Scalars['Int'];
    /** Aggregated items */
    groups: Array<GroupByResponse>;
};
/** UserLoginInput */
export declare type UserLoginInput = {
    email: Scalars['String'];
    password: Scalars['String'];
    fromInvitation?: Maybe<Scalars['String']>;
    authProfileId?: Maybe<Scalars['ID']>;
};
/** UserManyResponse output */
export declare type UserManyResponse = {
    __typename?: 'UserManyResponse';
    /** List items */
    items: Array<User>;
    /** List items count */
    count: Scalars['Int'];
};
/** No longer supported. Use `sort` instead. */
export declare 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 declare type UserPayload = {
    __typename?: 'UserPayload';
    mutation: MutationType;
    node?: Maybe<User>;
    updatedFields?: Maybe<Array<Maybe<Scalars['String']>>>;
    previousValues?: Maybe<User>;
};
/** User Permission */
export declare type UserPermission = {
    __typename?: 'UserPermission';
    resourceType?: Maybe<Scalars['String']>;
    resource?: Maybe<Scalars['String']>;
    permission?: Maybe<Scalars['JSON']>;
};
export declare 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 declare type UserPermissionList = {
    __typename?: 'UserPermissionList';
    items?: Maybe<Array<UserPermission>>;
    count: Scalars['Int'];
};
export declare type UserPermissionRelationFilter = {
    some?: Maybe<UserPermissionFilter>;
    every?: Maybe<UserPermissionFilter>;
    none?: Maybe<UserPermissionFilter>;
};
export declare type UserRelationFilter = {
    some?: Maybe<UserFilter>;
    every?: Maybe<UserFilter>;
    none?: Maybe<UserFilter>;
};
/** Files create input from users_avatar */
export declare 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 declare 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 declare 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 declare type Users_RoleUpdateInput = {
    filter?: Maybe<RoleKeyFilter>;
    data: RoleUpdateInput;
};
/** Users relation input */
export declare type UsersAvatarManyRelationInput = {
    connect?: Maybe<FileKeyFilter>;
};
/** Users relation input */
export declare type UsersAvatarRelationInput = {
    connect?: Maybe<FileKeyFilter>;
    create?: Maybe<Users_Avatar_FileCreateInput>;
};
/** Users relation input */
export declare 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 declare type UsersChannelIdentitiesManyRelationInput = {
    connect?: Maybe<Array<ChannelMemberKeyFilter>>;
};
/** Users relation input */
export declare type UsersChannelIdentitiesRelationInput = {
    connect?: Maybe<Array<ChannelMemberKeyFilter>>;
    create?: Maybe<Array<Maybe<User_ChannelMemberCreateInput>>>;
};
/** Users relation input */
export declare 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 declare 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 declare type UsersRolesManyRelationInput = {
    connect?: Maybe<Array<RoleKeyFilter>>;
};
/** Users relation input */
export declare type UsersRolesRelationInput = {
    connect?: Maybe<Array<RoleKeyFilter>>;
    create?: Maybe<Array<Maybe<Users_RoleCreateInput>>>;
};
/** Users relation input */
export declare 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 declare type UserSubscriptionFilter = {
    mutation_in?: Maybe<Array<Maybe<MutationType>>>;
    node?: Maybe<UserFilter>;
    updatedFields?: Maybe<UpdatedFieldsFilter>;
};
/** Users update input */
export declare 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 declare 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 declare type UuidFieldTypeAttributes = {
    __typename?: 'UUIDFieldTypeAttributes';
    fieldSize?: Maybe<Scalars['Int']>;
};
/** VerificationEmailResendInput */
export declare type VerificationEmailResendInput = {
    email: Scalars['String'];
};
/** View Attributes */
export declare type ViewAttributes = {
    __typename?: 'ViewAttributes';
    query?: Maybe<Scalars['String']>;
};
/** View Create Input */
export declare type ViewCreateInput = {
    name: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    query: Scalars['String'];
    description?: Maybe<Scalars['String']>;
};
/** View Update Input */
export declare type ViewUpdateInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    query?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
};
/** WorkspaceCreateMutationInput */
export declare type WorkspaceCreateMutationInput = {
    name: Scalars['String'];
    billingPlanId?: Maybe<Scalars['ID']>;
};
export declare type WorkspaceCreateResponse = {
    __typename?: 'WorkspaceCreateResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
/** WorkspaceDeleteMutationInput */
export declare type WorkspaceDeleteMutationInput = {
    id: Scalars['ID'];
};
/** LoginResponseWorkspace name and id */
export declare type WorkspaceInfo = {
    __typename?: 'WorkspaceInfo';
    workspace?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
export declare 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 declare type WorkspaceListResponse = {
    __typename?: 'WorkspaceListResponse';
    /** List items */
    items: Array<WorkspaceItem>;
    /** List items count */
    count: Scalars['Int'];
};
export declare type WorkspaceStatus = 'active' | 'blocked' | 'canceled' | 'suspended' | 'canceling' | 'pending';
/** WorkspaceUpdateMutationInput */
export declare type WorkspaceUpdateMutationInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
};
export declare type WorkspaceUpdateResponse = {
    __typename?: 'WorkspaceUpdateResponse';
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
};
export declare 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 declare type ChannelPreviewFragment = ({
    __typename?: 'Channel';
} & {
    members: Maybe<({
        __typename?: 'ChannelMemberListResponse';
    } & Pick<ChannelMemberListResponse, 'count'>)>;
} & ChannelPreviewCommonFragment);
export declare type DmPreviewFragment = ({
    __typename?: 'Channel';
} & {
    members: Maybe<({
        __typename?: 'ChannelMemberListResponse';
    } & Pick<ChannelMemberListResponse, 'count'> & {
        items: Array<({
            __typename?: 'ChannelMember';
        } & {
            user: Maybe<({
                __typename?: 'User';
            } & UserFullnameFragment)>;
        })>;
    })>;
} & ChannelPreviewCommonFragment);
export declare type ChannelMemberFragment = ({
    __typename?: 'ChannelMember';
} & Pick<ChannelMember, 'id'> & {
    user: Maybe<({
        __typename?: 'User';
    } & {
        avatar: Maybe<({
            __typename?: 'File';
        } & ImageFragment)>;
    } & UserFullnameFragment)>;
});
export declare type ChannelIdentityCommonFragment = ({
    __typename?: 'ChannelMember';
} & Pick<ChannelMember, 'id' | 'lastReadTS' | 'hasUnreads'> & {
    user: Maybe<({
        __typename?: 'User';
    } & Pick<User, 'id'>)>;
});
export declare type ChannelIdentityFragment = ({
    __typename?: 'ChannelMember';
} & {
    channel: Maybe<({
        __typename?: 'Channel';
    } & ChannelPreviewFragment)>;
} & ChannelIdentityCommonFragment);
export declare type DmIdentityFragment = ({
    __typename?: 'ChannelMember';
} & {
    channel: Maybe<({
        __typename?: 'Channel';
    } & DmPreviewFragment)>;
} & ChannelIdentityCommonFragment);
export declare type ChannelMessagesQueryVariables = {
    id: Scalars['ID'];
    filter?: Maybe<MessageFilter>;
    orderBy?: Maybe<Array<Maybe<MessageOrderBy>>>;
    last?: Maybe<Scalars['Int']>;
    before?: Maybe<Scalars['String']>;
};
export declare type ChannelMessagesQuery = ({
    __typename?: 'Query';
} & {
    channel: Maybe<({
        __typename?: 'Channel';
    } & Pick<Channel, 'id'> & {
        messages: Maybe<({
            __typename?: 'MessageListResponse';
        } & Pick<MessageListResponse, 'count'> & {
            items: Array<({
                __typename?: 'Message';
            } & MessageFragment)>;
        })>;
    })>;
});
export declare type ChannelMembersQueryVariables = {
    id: Scalars['ID'];
    first?: Maybe<Scalars['Int']>;
};
export declare type ChannelMembersQuery = ({
    __typename?: 'Query';
} & {
    channel: Maybe<({
        __typename?: 'Channel';
    } & Pick<Channel, 'id'> & {
        members: Maybe<({
            __typename?: 'ChannelMemberListResponse';
        } & Pick<ChannelMemberListResponse, 'count'> & {
            items: Array<({
                __typename?: 'ChannelMember';
            } & ChannelMemberFragment)>;
        })>;
    })>;
});
export declare type ChannelFormQueryVariables = {
    id: Scalars['ID'];
};
export declare type ChannelFormQuery = ({
    __typename?: 'Query';
} & {
    channel: Maybe<({
        __typename?: 'Channel';
    } & Pick<Channel, 'id' | 'name' | 'purpose'>)>;
});
export declare type ChannelsSearchQueryVariables = {
    first: Scalars['Int'];
    searchText: Scalars['String'];
    userId: Scalars['ID'];
};
export declare 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 declare type ChannelCreateMutationVariables = {
    data: ChannelCreateInput;
};
export declare 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 declare type ChannelDeleteMutationVariables = {
    id: Scalars['ID'];
};
export declare type ChannelDeleteMutation = ({
    __typename?: 'Mutation';
} & {
    channelDelete: Maybe<({
        __typename?: 'SuccessResponse';
    } & Pick<SuccessResponse, 'success'>)>;
});
export declare type FindOrCreateDmMutationVariables = {
    usersIds: Array<Scalars['ID']>;
    channelMembersFilter?: ChannelMemberFilter;
};
export declare 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 declare type ChannelMemberUpdateMutationVariables = {
    id: Scalars['ID'];
    lastReadTS: Scalars['DateTime'];
};
export declare type ChannelMemberUpdateMutation = ({
    __typename?: 'Mutation';
} & {
    channelMemberUpdate: ({
        __typename?: 'ChannelMember';
    } & Pick<ChannelMember, 'id' | 'lastReadTS'>);
});
export declare type ChannelMemberDeleteMutationVariables = {
    id: Scalars['ID'];
};
export declare type ChannelMemberDeleteMutation = ({
    __typename?: 'Mutation';
} & {
    channelMemberDelete: Maybe<({
        __typename?: 'SuccessResponse';
    } & Pick<SuccessResponse, 'success'>)>;
});
export declare type ChannelMemberCreateMutationVariables = {
    data: ChannelMemberCreateInput;
};
export declare type ChannelMemberCreateMutation = ({
    __typename?: 'Mutation';
} & {
    channelMemberCreate: ({
        __typename?: 'ChannelMember';
    } & Pick<ChannelMember, 'id'>);
});
export declare type ChannelUpdateMutationVariables = {
    data: ChannelUpdateInput;
};
export declare type ChannelUpdateMutation = ({
    __typename?: 'Mutation';
} & {
    channelUpdate: ({
        __typename?: 'Channel';
    } & Pick<Channel, 'id'>);
});
export declare type UserChannelIdentitiesSubSubscriptionVariables = {
    userId: Scalars['ID'];
};
export declare type UserChannelIdentitiesSubSubscription = ({
    __typename?: 'Subscription';
} & {
    ChannelMember: Maybe<({
        __typename?: 'ChannelMemberPayload';
    } & {
        node: Maybe<({
            __typename?: 'ChannelMember';
        } & ChannelIdentityFragment)>;
    })>;
});
export declare type ImageFragment = ({
    __typename?: 'File';
} & Pick<File, 'id' | 'downloadUrl'>);
export declare type AttachmentFragment = ({
    __typename?: 'File';
} & Pick<File, 'id' | 'createdAt' | 'fileId' | 'downloadUrl' | 'filename' | 'previewUrl'>);
export declare type FileDeleteMutationVariables = {
    data: FileDeleteInput;
};
export declare type FileDeleteMutation = ({
    __typename?: 'Mutation';
} & {
    fileDelete: Maybe<({
        __typename?: 'SuccessResponse';
    } & Pick<SuccessResponse, 'success'>)>;
});
export declare type MessageFragment = ({
    __typename?: 'Message';
} & Pick<Message, 'id' | 'createdAt' | 'text'> & {
    createdBy: Maybe<({
        __typename?: 'User';
    } & UserPreviewFragment)>;
    attachments: Maybe<({
        __typename?: 'FileListResponse';
    } & {
        items: Array<({
            __typename?: 'File';
        } & AttachmentFragment)>;
    })>;
});
export declare type MessageCreateMutationVariables = {
    data: MessageCreateInput;
};
export declare type MessageCreateMutation = ({
    __typename?: 'Mutation';
} & {
    messageCreate: ({
        __typename?: 'Message';
    } & MessageFragment);
});
export declare type MessageDeleteMutationVariables = {
    data: MessageDeleteInput;
};
export declare type MessageDeleteMutation = ({
    __typename?: 'Mutation';
} & {
    messageDelete: Maybe<({
        __typename?: 'SuccessResponse';
    } & Pick<SuccessResponse, 'success'>)>;
});
export declare type MessageUpdateMutationVariables = {
    data: MessageUpdateInput;
};
export declare type MessageUpdateMutation = ({
    __typename?: 'Mutation';
} & {
    messageUpdate: ({
        __typename?: 'Message';
    } & Pick<Message, 'id'>);
});
export declare type UserChannelsMessagesSubSubscriptionVariables = {
    userId: Scalars['ID'];
};
export declare 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 declare type UserFullnameFragment = ({
    __typename?: 'User';
} & Pick<User, 'id' | 'firstName' | 'lastName'>);
export declare type UserPreviewFragment = ({
    __typename?: 'User';
} & {
    avatar: Maybe<({
        __typename?: 'File';
    } & ImageFragment)>;
} & UserFullnameFragment);
export declare type UserChannelsPreviewQueryVariables = {
    id?: Maybe<Scalars['ID']>;
    channelMembersFilter?: ChannelMemberFilter;
};
export declare type UserChannelsPreviewQuery = ({
    __typename?: 'Query';
} & {
    user: Maybe<({
        __typename?: 'User';
    } & Pick<User, 'id'> & {
        channelIdentities: Maybe<({
            __typename?: 'ChannelMemberListResponse';
        } & {
            items: Array<({
                __typename?: 'ChannelMember';
            } & ChannelIdentityFragment)>;
        })>;
    })>;
});
export declare type UserDmsPreviewQueryVariables = {
    id?: Maybe<Scalars['ID']>;
    channelMembersFilter?: ChannelMemberFilter;
};
export declare type UserDmsPreviewQuery = ({
    __typename?: 'Query';
} & {
    user: Maybe<({
        __typename?: 'User';
    } & Pick<User, 'id'> & {
        channelIdentities: Maybe<({
            __typename?: 'ChannelMemberListResponse';
        } & {
            items: Array<({
                __typename?: 'ChannelMember';
            } & DmIdentityFragment)>;
        })>;
    })>;
});
export declare type UserContactsPreviewQueryVariables = {
    filter: UserFilter;
};
export declare type UserContactsPreviewQuery = ({
    __typename?: 'Query';
} & {
    usersList: ({
        __typename?: 'UserListResponse';
    } & {
        items: Array<({
            __typename?: 'User';
        } & UserPreviewFragment)>;
    });
});
export declare type UsersSearchQueryVariables = {
    first: Scalars['Int'];
    searchText: Scalars['String'];
    channelId: Scalars['ID'];
    usersFilter: UserFilter;
};
export declare type UsersSearchQuery = ({
    __typename?: 'Query';
} & {
    usersList: ({
        __typename?: 'UserListResponse';
    } & {
        items: Array<({
            __typename?: 'User';
        } & UserPreviewFragment)>;
    });
});
export declare type UsersDmSearchQueryVariables = {
    first: Scalars['Int'];
    searchText: Scalars['String'];
    idNotIn?: Maybe<Array<Scalars['ID']>>;
};
export declare type UsersDmSearchQuery = ({
    __typename?: 'Query';
} & {
    usersList: ({
        __typename?: 'UserListResponse';
    } & {
        items: Array<({
            __typename?: 'User';
        } & UserPreviewFragment)>;
    });
});
export declare const UserFullnameFragmentDoc: any;
export declare const ImageFragmentDoc: any;
export declare const ChannelMemberFragmentDoc: any;
export declare const ChannelIdentityCommonFragmentDoc: any;
export declare const ChannelPreviewCommonFragmentDoc: any;
export declare const ChannelPreviewFragmentDoc: any;
export declare const ChannelIdentityFragmentDoc: any;
export declare const DmPreviewFragmentDoc: any;
export declare const DmIdentityFragmentDoc: any;
export declare const UserPreviewFragmentDoc: any;
export declare const AttachmentFragmentDoc: any;
export declare const MessageFragmentDoc: any;
export declare const ChannelMessagesDocument: any;
export declare type ChannelMessagesComponentProps = Omit<ReactApollo.QueryProps<ChannelMessagesQuery, ChannelMessagesQueryVariables>, 'query'> & ({
    variables: ChannelMessagesQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const ChannelMessagesComponent: (props: ChannelMessagesComponentProps) => JSX.Element;
export declare type ChannelMessagesProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelMessagesQuery, ChannelMessagesQueryVariables>> & TChildProps;
export declare function withChannelMessages<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelMessagesQuery, ChannelMessagesQueryVariables, ChannelMessagesProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    channel: Maybe<{
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id"> & {
        messages: Maybe<{
            __typename?: "MessageListResponse" | undefined;
        } & Pick<MessageListResponse, "count"> & {
            items: ({
                __typename?: "Message" | undefined;
            } & {
                __typename?: "Message" | undefined;
            } & Pick<Message, "id" | "createdAt" | "text"> & {
                createdBy: Maybe<{
                    __typename?: "User" | undefined;
                } & {
                    __typename?: "User" | undefined;
                } & {
                    avatar: Maybe<{
                        __typename?: "File" | undefined;
                    } & {
                        __typename?: "File" | undefined;
                    } & Pick<File, "id" | "downloadUrl">>;
                } & {
                    __typename?: "User" | undefined;
                } & Pick<User, "id" | "firstName" | "lastName">>;
                attachments: Maybe<{
                    __typename?: "FileListResponse" | undefined;
                } & {
                    items: ({
                        __typename?: "File" | undefined;
                    } & {
                        __typename?: "File" | undefined;
                    } & Pick<File, "id" | "createdAt" | "downloadUrl" | "fileId" | "filename" | "previewUrl">)[];
                }>;
            })[];
        }>;
    }>;
}, ChannelMessagesQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelMembersDocument: any;
export declare type ChannelMembersComponentProps = Omit<ReactApollo.QueryProps<ChannelMembersQuery, ChannelMembersQueryVariables>, 'query'> & ({
    variables: ChannelMembersQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const ChannelMembersComponent: (props: ChannelMembersComponentProps) => JSX.Element;
export declare type ChannelMembersProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelMembersQuery, ChannelMembersQueryVariables>> & TChildProps;
export declare function withChannelMembers<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelMembersQuery, ChannelMembersQueryVariables, ChannelMembersProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    channel: Maybe<{
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id"> & {
        members: Maybe<{
            __typename?: "ChannelMemberListResponse" | undefined;
        } & Pick<ChannelMemberListResponse, "count"> & {
            items: ({
                __typename?: "ChannelMember" | undefined;
            } & {
                __typename?: "ChannelMember" | undefined;
            } & Pick<ChannelMember, "id"> & {
                user: Maybe<{
                    __typename?: "User" | undefined;
                } & {
                    avatar: Maybe<{
                        __typename?: "File" | undefined;
                    } & {
                        __typename?: "File" | undefined;
                    } & Pick<File, "id" | "downloadUrl">>;
                } & {
                    __typename?: "User" | undefined;
                } & Pick<User, "id" | "firstName" | "lastName">>;
            })[];
        }>;
    }>;
}, ChannelMembersQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelFormDocument: any;
export declare type ChannelFormComponentProps = Omit<ReactApollo.QueryProps<ChannelFormQuery, ChannelFormQueryVariables>, 'query'> & ({
    variables: ChannelFormQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const ChannelFormComponent: (props: ChannelFormComponentProps) => JSX.Element;
export declare type ChannelFormProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelFormQuery, ChannelFormQueryVariables>> & TChildProps;
export declare function withChannelForm<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelFormQuery, ChannelFormQueryVariables, ChannelFormProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    channel: Maybe<{
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id" | "name" | "purpose">>;
}, ChannelFormQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelsSearchDocument: any;
export declare type ChannelsSearchComponentProps = Omit<ReactApollo.QueryProps<ChannelsSearchQuery, ChannelsSearchQueryVariables>, 'query'> & ({
    variables: ChannelsSearchQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const ChannelsSearchComponent: (props: ChannelsSearchComponentProps) => JSX.Element;
export declare type ChannelsSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<ChannelsSearchQuery, ChannelsSearchQueryVariables>> & TChildProps;
export declare function withChannelsSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelsSearchQuery, ChannelsSearchQueryVariables, ChannelsSearchProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    channelsList: {
        __typename?: "ChannelListResponse" | undefined;
    } & {
        items: ({
            __typename?: "Channel" | undefined;
        } & Pick<Channel, "id" | "name"> & {
            members: Maybe<{
                __typename?: "ChannelMemberListResponse" | undefined;
            } & Pick<ChannelMemberListResponse, "count"> & {
                items: ({
                    __typename?: "ChannelMember" | undefined;
                } & Pick<ChannelMember, "id"> & {
                    user: Maybe<{
                        __typename?: "User" | undefined;
                    } & {
                        avatar: Maybe<{
                            __typename?: "File" | undefined;
                        } & {
                            __typename?: "File" | undefined;
                        } & Pick<File, "id" | "downloadUrl">>;
                    } & {
                        __typename?: "User" | undefined;
                    } & Pick<User, "id" | "firstName" | "lastName">>;
                })[];
            }>;
        })[];
    };
}, ChannelsSearchQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelCreateDocument: any;
export declare type ChannelCreateMutationFn = ReactApollo.MutationFn<ChannelCreateMutation, ChannelCreateMutationVariables>;
export declare type ChannelCreateComponentProps = Omit<ReactApollo.MutationProps<ChannelCreateMutation, ChannelCreateMutationVariables>, 'mutation'>;
export declare const ChannelCreateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelCreate: {
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id" | "name"> & {
        members: Maybe<{
            __typename?: "ChannelMemberListResponse" | undefined;
        } & {
            items: ({
                __typename?: "ChannelMember" | undefined;
            } & Pick<ChannelMember, "id"> & {
                user: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
            })[];
        }>;
    };
}, ChannelCreateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelCreateMutation, ChannelCreateMutationVariables>> & TChildProps;
export declare function withChannelCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelCreateMutation, ChannelCreateMutationVariables, ChannelCreateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelCreate: {
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id" | "name"> & {
        members: Maybe<{
            __typename?: "ChannelMemberListResponse" | undefined;
        } & {
            items: ({
                __typename?: "ChannelMember" | undefined;
            } & Pick<ChannelMember, "id"> & {
                user: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
            })[];
        }>;
    };
}, ChannelCreateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelDeleteDocument: any;
export declare type ChannelDeleteMutationFn = ReactApollo.MutationFn<ChannelDeleteMutation, ChannelDeleteMutationVariables>;
export declare type ChannelDeleteComponentProps = Omit<ReactApollo.MutationProps<ChannelDeleteMutation, ChannelDeleteMutationVariables>, 'mutation'>;
export declare const ChannelDeleteComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, ChannelDeleteMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelDeleteMutation, ChannelDeleteMutationVariables>> & TChildProps;
export declare function withChannelDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelDeleteMutation, ChannelDeleteMutationVariables, ChannelDeleteProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, ChannelDeleteMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const FindOrCreateDmDocument: any;
export declare type FindOrCreateDmMutationFn = ReactApollo.MutationFn<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>;
export declare type FindOrCreateDmComponentProps = Omit<ReactApollo.MutationProps<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>, 'mutation'>;
export declare const FindOrCreateDmComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    findOrCreateDM: Maybe<{
        __typename?: "FindOrCreateDMResponse" | undefined;
    } & Pick<FindOrCreateDmResponse, "id" | "name"> & {
        members: {
            __typename?: "FindOrCreateDMMemberList" | undefined;
        } & {
            items: ({
                __typename?: "FindOrCreateDMMember" | undefined;
            } & Pick<FindOrCreateDmMember, "id"> & {
                user: {
                    __typename?: "FindOrCreateDMUser" | undefined;
                } & Pick<FindOrCreateDmUser, "id">;
            })[];
        };
    }>;
}, FindOrCreateDmMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type FindOrCreateDmProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<FindOrCreateDmMutation, FindOrCreateDmMutationVariables>> & TChildProps;
export declare function withFindOrCreateDm<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, FindOrCreateDmMutation, FindOrCreateDmMutationVariables, FindOrCreateDmProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    findOrCreateDM: Maybe<{
        __typename?: "FindOrCreateDMResponse" | undefined;
    } & Pick<FindOrCreateDmResponse, "id" | "name"> & {
        members: {
            __typename?: "FindOrCreateDMMemberList" | undefined;
        } & {
            items: ({
                __typename?: "FindOrCreateDMMember" | undefined;
            } & Pick<FindOrCreateDmMember, "id"> & {
                user: {
                    __typename?: "FindOrCreateDMUser" | undefined;
                } & Pick<FindOrCreateDmUser, "id">;
            })[];
        };
    }>;
}, FindOrCreateDmMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelMemberUpdateDocument: any;
export declare type ChannelMemberUpdateMutationFn = ReactApollo.MutationFn<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>;
export declare type ChannelMemberUpdateComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>, 'mutation'>;
export declare const ChannelMemberUpdateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberUpdate: {
        __typename?: "ChannelMember" | undefined;
    } & Pick<ChannelMember, "id" | "lastReadTS">;
}, ChannelMemberUpdateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelMemberUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables>> & TChildProps;
export declare function withChannelMemberUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelMemberUpdateMutation, ChannelMemberUpdateMutationVariables, ChannelMemberUpdateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberUpdate: {
        __typename?: "ChannelMember" | undefined;
    } & Pick<ChannelMember, "id" | "lastReadTS">;
}, ChannelMemberUpdateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelMemberDeleteDocument: any;
export declare type ChannelMemberDeleteMutationFn = ReactApollo.MutationFn<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>;
export declare type ChannelMemberDeleteComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>, 'mutation'>;
export declare const ChannelMemberDeleteComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, ChannelMemberDeleteMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelMemberDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables>> & TChildProps;
export declare function withChannelMemberDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelMemberDeleteMutation, ChannelMemberDeleteMutationVariables, ChannelMemberDeleteProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, ChannelMemberDeleteMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelMemberCreateDocument: any;
export declare type ChannelMemberCreateMutationFn = ReactApollo.MutationFn<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>;
export declare type ChannelMemberCreateComponentProps = Omit<ReactApollo.MutationProps<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>, 'mutation'>;
export declare const ChannelMemberCreateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberCreate: {
        __typename?: "ChannelMember" | undefined;
    } & Pick<ChannelMember, "id">;
}, ChannelMemberCreateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelMemberCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables>> & TChildProps;
export declare function withChannelMemberCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelMemberCreateMutation, ChannelMemberCreateMutationVariables, ChannelMemberCreateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelMemberCreate: {
        __typename?: "ChannelMember" | undefined;
    } & Pick<ChannelMember, "id">;
}, ChannelMemberCreateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const ChannelUpdateDocument: any;
export declare type ChannelUpdateMutationFn = ReactApollo.MutationFn<ChannelUpdateMutation, ChannelUpdateMutationVariables>;
export declare type ChannelUpdateComponentProps = Omit<ReactApollo.MutationProps<ChannelUpdateMutation, ChannelUpdateMutationVariables>, 'mutation'>;
export declare const ChannelUpdateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelUpdate: {
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id">;
}, ChannelUpdateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type ChannelUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<ChannelUpdateMutation, ChannelUpdateMutationVariables>> & TChildProps;
export declare function withChannelUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, ChannelUpdateMutation, ChannelUpdateMutationVariables, ChannelUpdateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    channelUpdate: {
        __typename?: "Channel" | undefined;
    } & Pick<Channel, "id">;
}, ChannelUpdateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UserChannelIdentitiesSubDocument: any;
export declare type UserChannelIdentitiesSubComponentProps = Omit<ReactApollo.SubscriptionProps<UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables>, 'subscription'>;
export declare const UserChannelIdentitiesSubComponent: (props: Pick<ReactApollo.SubscriptionProps<{
    __typename?: "Subscription" | undefined;
} & {
    ChannelMember: Maybe<{
        __typename?: "ChannelMemberPayload" | undefined;
    } & {
        node: Maybe<{
            __typename?: "ChannelMember" | undefined;
        } & {
            __typename?: "ChannelMember" | undefined;
        } & {
            channel: Maybe<{
                __typename?: "Channel" | undefined;
            } & {
                __typename?: "Channel" | undefined;
            } & {
                members: Maybe<{
                    __typename?: "ChannelMemberListResponse" | undefined;
                } & Pick<ChannelMemberListResponse, "count">>;
            } & {
                __typename?: "Channel" | undefined;
            } & Pick<Channel, "id" | "name" | "public" | "type"> & {
                createdBy: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
                messages: Maybe<{
                    __typename?: "MessageListResponse" | undefined;
                } & {
                    items: ({
                        __typename?: "Message" | undefined;
                    } & Pick<Message, "createdAt"> & {
                        createdBy: Maybe<{
                            __typename?: "User" | undefined;
                        } & Pick<User, "id">>;
                    })[];
                }>;
            }>;
        } & {
            __typename?: "ChannelMember" | undefined;
        } & Pick<ChannelMember, "id" | "lastReadTS" | "hasUnreads"> & {
            user: Maybe<{
                __typename?: "User" | undefined;
            } & Pick<User, "id">>;
        }>;
    }>;
}, UserChannelIdentitiesSubSubscriptionVariables>, "children" | "variables" | "fetchPolicy" | "client" | "shouldResubscribe" | "onSubscriptionData" | "onSubscriptionComplete">) => JSX.Element;
export declare type UserChannelIdentitiesSubProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables>> & TChildProps;
export declare function withUserChannelIdentitiesSub<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UserChannelIdentitiesSubSubscription, UserChannelIdentitiesSubSubscriptionVariables, UserChannelIdentitiesSubProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Subscription" | undefined;
} & {
    ChannelMember: Maybe<{
        __typename?: "ChannelMemberPayload" | undefined;
    } & {
        node: Maybe<{
            __typename?: "ChannelMember" | undefined;
        } & {
            __typename?: "ChannelMember" | undefined;
        } & {
            channel: Maybe<{
                __typename?: "Channel" | undefined;
            } & {
                __typename?: "Channel" | undefined;
            } & {
                members: Maybe<{
                    __typename?: "ChannelMemberListResponse" | undefined;
                } & Pick<ChannelMemberListResponse, "count">>;
            } & {
                __typename?: "Channel" | undefined;
            } & Pick<Channel, "id" | "name" | "public" | "type"> & {
                createdBy: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
                messages: Maybe<{
                    __typename?: "MessageListResponse" | undefined;
                } & {
                    items: ({
                        __typename?: "Message" | undefined;
                    } & Pick<Message, "createdAt"> & {
                        createdBy: Maybe<{
                            __typename?: "User" | undefined;
                        } & Pick<User, "id">>;
                    })[];
                }>;
            }>;
        } & {
            __typename?: "ChannelMember" | undefined;
        } & Pick<ChannelMember, "id" | "lastReadTS" | "hasUnreads"> & {
            user: Maybe<{
                __typename?: "User" | undefined;
            } & Pick<User, "id">>;
        }>;
    }>;
}, UserChannelIdentitiesSubSubscriptionVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const FileDeleteDocument: any;
export declare type FileDeleteMutationFn = ReactApollo.MutationFn<FileDeleteMutation, FileDeleteMutationVariables>;
export declare type FileDeleteComponentProps = Omit<ReactApollo.MutationProps<FileDeleteMutation, FileDeleteMutationVariables>, 'mutation'>;
export declare const FileDeleteComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    fileDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, FileDeleteMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type FileDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<FileDeleteMutation, FileDeleteMutationVariables>> & TChildProps;
export declare function withFileDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, FileDeleteMutation, FileDeleteMutationVariables, FileDeleteProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    fileDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, FileDeleteMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const MessageCreateDocument: any;
export declare type MessageCreateMutationFn = ReactApollo.MutationFn<MessageCreateMutation, MessageCreateMutationVariables>;
export declare type MessageCreateComponentProps = Omit<ReactApollo.MutationProps<MessageCreateMutation, MessageCreateMutationVariables>, 'mutation'>;
export declare const MessageCreateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageCreate: {
        __typename?: "Message" | undefined;
    } & {
        __typename?: "Message" | undefined;
    } & Pick<Message, "id" | "createdAt" | "text"> & {
        createdBy: Maybe<{
            __typename?: "User" | undefined;
        } & {
            __typename?: "User" | undefined;
        } & {
            avatar: Maybe<{
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "downloadUrl">>;
        } & {
            __typename?: "User" | undefined;
        } & Pick<User, "id" | "firstName" | "lastName">>;
        attachments: Maybe<{
            __typename?: "FileListResponse" | undefined;
        } & {
            items: ({
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "createdAt" | "downloadUrl" | "fileId" | "filename" | "previewUrl">)[];
        }>;
    };
}, MessageCreateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type MessageCreateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageCreateMutation, MessageCreateMutationVariables>> & TChildProps;
export declare function withMessageCreate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, MessageCreateMutation, MessageCreateMutationVariables, MessageCreateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageCreate: {
        __typename?: "Message" | undefined;
    } & {
        __typename?: "Message" | undefined;
    } & Pick<Message, "id" | "createdAt" | "text"> & {
        createdBy: Maybe<{
            __typename?: "User" | undefined;
        } & {
            __typename?: "User" | undefined;
        } & {
            avatar: Maybe<{
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "downloadUrl">>;
        } & {
            __typename?: "User" | undefined;
        } & Pick<User, "id" | "firstName" | "lastName">>;
        attachments: Maybe<{
            __typename?: "FileListResponse" | undefined;
        } & {
            items: ({
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "createdAt" | "downloadUrl" | "fileId" | "filename" | "previewUrl">)[];
        }>;
    };
}, MessageCreateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const MessageDeleteDocument: any;
export declare type MessageDeleteMutationFn = ReactApollo.MutationFn<MessageDeleteMutation, MessageDeleteMutationVariables>;
export declare type MessageDeleteComponentProps = Omit<ReactApollo.MutationProps<MessageDeleteMutation, MessageDeleteMutationVariables>, 'mutation'>;
export declare const MessageDeleteComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, MessageDeleteMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type MessageDeleteProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageDeleteMutation, MessageDeleteMutationVariables>> & TChildProps;
export declare function withMessageDelete<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, MessageDeleteMutation, MessageDeleteMutationVariables, MessageDeleteProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageDelete: Maybe<{
        __typename?: "SuccessResponse" | undefined;
    } & Pick<SuccessResponse, "success">>;
}, MessageDeleteMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const MessageUpdateDocument: any;
export declare type MessageUpdateMutationFn = ReactApollo.MutationFn<MessageUpdateMutation, MessageUpdateMutationVariables>;
export declare type MessageUpdateComponentProps = Omit<ReactApollo.MutationProps<MessageUpdateMutation, MessageUpdateMutationVariables>, 'mutation'>;
export declare const MessageUpdateComponent: (props: Pick<ReactApollo.MutationProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageUpdate: {
        __typename?: "Message" | undefined;
    } & Pick<Message, "id">;
}, MessageUpdateMutationVariables>, "update" | "children" | "onCompleted" | "onError" | "variables" | "fetchPolicy" | "client" | "context" | "ignoreResults" | "optimisticResponse" | "refetchQueries" | "awaitRefetchQueries">) => JSX.Element;
export declare type MessageUpdateProps<TChildProps = {}> = Partial<ReactApollo.MutateProps<MessageUpdateMutation, MessageUpdateMutationVariables>> & TChildProps;
export declare function withMessageUpdate<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, MessageUpdateMutation, MessageUpdateMutationVariables, MessageUpdateProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.MutateProps<{
    __typename?: "Mutation" | undefined;
} & {
    messageUpdate: {
        __typename?: "Message" | undefined;
    } & Pick<Message, "id">;
}, MessageUpdateMutationVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UserChannelsMessagesSubDocument: any;
export declare type UserChannelsMessagesSubComponentProps = Omit<ReactApollo.SubscriptionProps<UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables>, 'subscription'>;
export declare const UserChannelsMessagesSubComponent: (props: Pick<ReactApollo.SubscriptionProps<{
    __typename?: "Subscription" | undefined;
} & {
    Message: Maybe<{
        __typename?: "MessagePayload" | undefined;
    } & Pick<MessagePayload, "mutation"> & {
        node: Maybe<{
            __typename?: "Message" | undefined;
        } & Pick<Message, "isDeleted"> & {
            channel: Maybe<{
                __typename?: "Channel" | undefined;
            } & Pick<Channel, "id" | "type">>;
        } & {
            __typename?: "Message" | undefined;
        } & Pick<Message, "id" | "createdAt" | "text"> & {
            createdBy: Maybe<{
                __typename?: "User" | undefined;
            } & {
                __typename?: "User" | undefined;
            } & {
                avatar: Maybe<{
                    __typename?: "File" | undefined;
                } & {
                    __typename?: "File" | undefined;
                } & Pick<File, "id" | "downloadUrl">>;
            } & {
                __typename?: "User" | undefined;
            } & Pick<User, "id" | "firstName" | "lastName">>;
            attachments: Maybe<{
                __typename?: "FileListResponse" | undefined;
            } & {
                items: ({
                    __typename?: "File" | undefined;
                } & {
                    __typename?: "File" | undefined;
                } & Pick<File, "id" | "createdAt" | "downloadUrl" | "fileId" | "filename" | "previewUrl">)[];
            }>;
        }>;
    }>;
}, UserChannelsMessagesSubSubscriptionVariables>, "children" | "variables" | "fetchPolicy" | "client" | "shouldResubscribe" | "onSubscriptionData" | "onSubscriptionComplete">) => JSX.Element;
export declare type UserChannelsMessagesSubProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables>> & TChildProps;
export declare function withUserChannelsMessagesSub<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UserChannelsMessagesSubSubscription, UserChannelsMessagesSubSubscriptionVariables, UserChannelsMessagesSubProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Subscription" | undefined;
} & {
    Message: Maybe<{
        __typename?: "MessagePayload" | undefined;
    } & Pick<MessagePayload, "mutation"> & {
        node: Maybe<{
            __typename?: "Message" | undefined;
        } & Pick<Message, "isDeleted"> & {
            channel: Maybe<{
                __typename?: "Channel" | undefined;
            } & Pick<Channel, "id" | "type">>;
        } & {
            __typename?: "Message" | undefined;
        } & Pick<Message, "id" | "createdAt" | "text"> & {
            createdBy: Maybe<{
                __typename?: "User" | undefined;
            } & {
                __typename?: "User" | undefined;
            } & {
                avatar: Maybe<{
                    __typename?: "File" | undefined;
                } & {
                    __typename?: "File" | undefined;
                } & Pick<File, "id" | "downloadUrl">>;
            } & {
                __typename?: "User" | undefined;
            } & Pick<User, "id" | "firstName" | "lastName">>;
            attachments: Maybe<{
                __typename?: "FileListResponse" | undefined;
            } & {
                items: ({
                    __typename?: "File" | undefined;
                } & {
                    __typename?: "File" | undefined;
                } & Pick<File, "id" | "createdAt" | "downloadUrl" | "fileId" | "filename" | "previewUrl">)[];
            }>;
        }>;
    }>;
}, UserChannelsMessagesSubSubscriptionVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UserChannelsPreviewDocument: any;
export declare type UserChannelsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables>, 'query'> & ({
    variables: UserChannelsPreviewQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const UserChannelsPreviewComponent: (props: UserChannelsPreviewComponentProps) => JSX.Element;
export declare type UserChannelsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables>> & TChildProps;
export declare function withUserChannelsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UserChannelsPreviewQuery, UserChannelsPreviewQueryVariables, UserChannelsPreviewProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    user: Maybe<{
        __typename?: "User" | undefined;
    } & Pick<User, "id"> & {
        channelIdentities: Maybe<{
            __typename?: "ChannelMemberListResponse" | undefined;
        } & {
            items: ({
                __typename?: "ChannelMember" | undefined;
            } & {
                __typename?: "ChannelMember" | undefined;
            } & {
                channel: Maybe<{
                    __typename?: "Channel" | undefined;
                } & {
                    __typename?: "Channel" | undefined;
                } & {
                    members: Maybe<{
                        __typename?: "ChannelMemberListResponse" | undefined;
                    } & Pick<ChannelMemberListResponse, "count">>;
                } & {
                    __typename?: "Channel" | undefined;
                } & Pick<Channel, "id" | "name" | "public" | "type"> & {
                    createdBy: Maybe<{
                        __typename?: "User" | undefined;
                    } & Pick<User, "id">>;
                    messages: Maybe<{
                        __typename?: "MessageListResponse" | undefined;
                    } & {
                        items: ({
                            __typename?: "Message" | undefined;
                        } & Pick<Message, "createdAt"> & {
                            createdBy: Maybe<{
                                __typename?: "User" | undefined;
                            } & Pick<User, "id">>;
                        })[];
                    }>;
                }>;
            } & {
                __typename?: "ChannelMember" | undefined;
            } & Pick<ChannelMember, "id" | "lastReadTS" | "hasUnreads"> & {
                user: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
            })[];
        }>;
    }>;
}, UserChannelsPreviewQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UserDmsPreviewDocument: any;
export declare type UserDmsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserDmsPreviewQuery, UserDmsPreviewQueryVariables>, 'query'> & ({
    variables: UserDmsPreviewQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const UserDmsPreviewComponent: (props: UserDmsPreviewComponentProps) => JSX.Element;
export declare type UserDmsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserDmsPreviewQuery, UserDmsPreviewQueryVariables>> & TChildProps;
export declare function withUserDmsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UserDmsPreviewQuery, UserDmsPreviewQueryVariables, UserDmsPreviewProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    user: Maybe<{
        __typename?: "User" | undefined;
    } & Pick<User, "id"> & {
        channelIdentities: Maybe<{
            __typename?: "ChannelMemberListResponse" | undefined;
        } & {
            items: ({
                __typename?: "ChannelMember" | undefined;
            } & {
                __typename?: "ChannelMember" | undefined;
            } & {
                channel: Maybe<{
                    __typename?: "Channel" | undefined;
                } & {
                    __typename?: "Channel" | undefined;
                } & {
                    members: Maybe<{
                        __typename?: "ChannelMemberListResponse" | undefined;
                    } & Pick<ChannelMemberListResponse, "count"> & {
                        items: ({
                            __typename?: "ChannelMember" | undefined;
                        } & {
                            user: Maybe<{
                                __typename?: "User" | undefined;
                            } & {
                                __typename?: "User" | undefined;
                            } & Pick<User, "id" | "firstName" | "lastName">>;
                        })[];
                    }>;
                } & {
                    __typename?: "Channel" | undefined;
                } & Pick<Channel, "id" | "name" | "public" | "type"> & {
                    createdBy: Maybe<{
                        __typename?: "User" | undefined;
                    } & Pick<User, "id">>;
                    messages: Maybe<{
                        __typename?: "MessageListResponse" | undefined;
                    } & {
                        items: ({
                            __typename?: "Message" | undefined;
                        } & Pick<Message, "createdAt"> & {
                            createdBy: Maybe<{
                                __typename?: "User" | undefined;
                            } & Pick<User, "id">>;
                        })[];
                    }>;
                }>;
            } & {
                __typename?: "ChannelMember" | undefined;
            } & Pick<ChannelMember, "id" | "lastReadTS" | "hasUnreads"> & {
                user: Maybe<{
                    __typename?: "User" | undefined;
                } & Pick<User, "id">>;
            })[];
        }>;
    }>;
}, UserDmsPreviewQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UserContactsPreviewDocument: any;
export declare type UserContactsPreviewComponentProps = Omit<ReactApollo.QueryProps<UserContactsPreviewQuery, UserContactsPreviewQueryVariables>, 'query'> & ({
    variables: UserContactsPreviewQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const UserContactsPreviewComponent: (props: UserContactsPreviewComponentProps) => JSX.Element;
export declare type UserContactsPreviewProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UserContactsPreviewQuery, UserContactsPreviewQueryVariables>> & TChildProps;
export declare function withUserContactsPreview<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UserContactsPreviewQuery, UserContactsPreviewQueryVariables, UserContactsPreviewProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    usersList: {
        __typename?: "UserListResponse" | undefined;
    } & {
        items: ({
            __typename?: "User" | undefined;
        } & {
            __typename?: "User" | undefined;
        } & {
            avatar: Maybe<{
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "downloadUrl">>;
        } & {
            __typename?: "User" | undefined;
        } & Pick<User, "id" | "firstName" | "lastName">)[];
    };
}, UserContactsPreviewQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UsersSearchDocument: any;
export declare type UsersSearchComponentProps = Omit<ReactApollo.QueryProps<UsersSearchQuery, UsersSearchQueryVariables>, 'query'> & ({
    variables: UsersSearchQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const UsersSearchComponent: (props: UsersSearchComponentProps) => JSX.Element;
export declare type UsersSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UsersSearchQuery, UsersSearchQueryVariables>> & TChildProps;
export declare function withUsersSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UsersSearchQuery, UsersSearchQueryVariables, UsersSearchProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    usersList: {
        __typename?: "UserListResponse" | undefined;
    } & {
        items: ({
            __typename?: "User" | undefined;
        } & {
            __typename?: "User" | undefined;
        } & {
            avatar: Maybe<{
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "downloadUrl">>;
        } & {
            __typename?: "User" | undefined;
        } & Pick<User, "id" | "firstName" | "lastName">)[];
    };
}, UsersSearchQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;
export declare const UsersDmSearchDocument: any;
export declare type UsersDmSearchComponentProps = Omit<ReactApollo.QueryProps<UsersDmSearchQuery, UsersDmSearchQueryVariables>, 'query'> & ({
    variables: UsersDmSearchQueryVariables;
    skip?: false;
} | {
    skip: true;
});
export declare const UsersDmSearchComponent: (props: UsersDmSearchComponentProps) => JSX.Element;
export declare type UsersDmSearchProps<TChildProps = {}> = Partial<ReactApollo.DataProps<UsersDmSearchQuery, UsersDmSearchQueryVariables>> & TChildProps;
export declare function withUsersDmSearch<TProps, TChildProps = {}>(operationOptions?: ReactApollo.OperationOption<TProps, UsersDmSearchQuery, UsersDmSearchQueryVariables, UsersDmSearchProps<TChildProps>>): (WrappedComponent: React.ComponentType<TProps & Partial<ReactApollo.DataProps<{
    __typename?: "Query" | undefined;
} & {
    usersList: {
        __typename?: "UserListResponse" | undefined;
    } & {
        items: ({
            __typename?: "User" | undefined;
        } & {
            __typename?: "User" | undefined;
        } & {
            avatar: Maybe<{
                __typename?: "File" | undefined;
            } & {
                __typename?: "File" | undefined;
            } & Pick<File, "id" | "downloadUrl">>;
        } & {
            __typename?: "User" | undefined;
        } & Pick<User, "id" | "firstName" | "lastName">)[];
    };
}, UsersDmSearchQueryVariables>> & TChildProps>) => React.ComponentClass<TProps, any>;