@cobuildlab/8base-chat/dist/shared/graphql/__generated__/index.d.ts

Chat component that uses 8base

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_WEE