@salad-labs/loopz-typescript/dist/graphql/generated/graphql.d.ts

The Official Loopz TypeScript SDK

export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    AWSDateTime: {
        input: Date;
        output: Date;
    };
    AWSEmail: {
        input: string;
        output: string;
    };
    AWSIPAddress: {
        input: any;
        output: any;
    };
    AWSJSON: {
        input: string;
        output: string;
    };
    AWSPhone: {
        input: any;
        output: any;
    };
    AWSTime: {
        input: any;
        output: any;
    };
    AWSTimestamp: {
        input: string;
        output: string;
    };
    AWSURL: {
        input: string;
        output: string;
    };
    BigInt: {
        input: any;
        output: any;
    };
    Double: {
        input: any;
        output: any;
    };
};
export type ActiveUserConversation = {
    __typename?: 'ActiveUserConversation';
    conversationId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    id: Scalars['ID']['output'];
    organizationId: Scalars['String']['output'];
    updatedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    userConversationId: Scalars['String']['output'];
    userId?: Maybe<Scalars['ID']['output']>;
    userOrganizationStatusId?: Maybe<Scalars['String']['output']>;
    userStatusId?: Maybe<Scalars['String']['output']>;
};
export declare enum ActiveUserConversationType {
    Active = "ACTIVE",
    Canceled = "CANCELED"
}
export declare enum AddGroupFrom {
    Everyone = "EVERYONE",
    OnlyFollowed = "ONLY_FOLLOWED"
}
export type AddMemberToConversationInput = {
    conversationId: Scalars['ID']['input'];
    member: EncryptedIdentityInput;
};
export type AddMembersToConversationInput = {
    conversationId: Scalars['ID']['input'];
    members: Array<EncryptedIdentityInput>;
};
export type AddReactionToMessageInput = {
    conversationId: Scalars['ID']['input'];
    messageId: Scalars['ID']['input'];
    reactionContent: Scalars['String']['input'];
};
export type AddReportToConversationInput = {
    conversationId: Scalars['ID']['input'];
    description: Scalars['String']['input'];
};
export type AddReportToMessageInput = {
    description: Scalars['String']['input'];
    messageId: Scalars['ID']['input'];
};
export type BatchDeleteMessagesResult = {
    __typename?: 'BatchDeleteMessagesResult';
    conversationId: Scalars['String']['output'];
    membersIds: Array<Scalars['ID']['output']>;
    messagesIds: Array<Scalars['ID']['output']>;
};
export type BlacklistUserEntry = {
    __typename?: 'BlacklistUserEntry';
    blockedId: Scalars['ID']['output'];
    blockedUser?: Maybe<User>;
    blockerBlockedId?: Maybe<Scalars['String']['output']>;
    blockerId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    id: Scalars['ID']['output'];
};
export type Conversation = {
    __typename?: 'Conversation';
    bannerImageURL?: Maybe<Scalars['String']['output']>;
    conversationId?: Maybe<Scalars['String']['output']>;
    createdAt: Scalars['AWSDateTime']['output'];
    deletedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    imageSettings?: Maybe<Scalars['AWSJSON']['output']>;
    imageURL?: Maybe<Scalars['String']['output']>;
    lastMessageSentAt?: Maybe<Scalars['AWSDateTime']['output']>;
    members?: Maybe<Array<Maybe<ConversationMember>>>;
    membersIds?: Maybe<Array<Scalars['ID']['output']>>;
    messages?: Maybe<Array<Maybe<Message>>>;
    mutedBy?: Maybe<Array<Muted>>;
    name: Scalars['String']['output'];
    organizationConversationId?: Maybe<Scalars['String']['output']>;
    organizationId?: Maybe<Scalars['String']['output']>;
    owner?: Maybe<User>;
    ownerId?: Maybe<Scalars['ID']['output']>;
    pin?: Maybe<Array<Maybe<ConversationPin>>>;
    publicConversationAESKey?: Maybe<Scalars['String']['output']>;
    publicConversationIVKey?: Maybe<Scalars['String']['output']>;
    reports?: Maybe<Array<Maybe<ConversationReport>>>;
    settings?: Maybe<Scalars['AWSJSON']['output']>;
    type: ConversationType;
    updatedAt?: Maybe<Scalars['AWSDateTime']['output']>;
};
export type ConversationCounter = {
    __typename?: 'ConversationCounter';
    counter: Scalars['Int']['output'];
    id: Scalars['ID']['output'];
};
export type ConversationIdItemKey = {
    __typename?: 'ConversationIdItemKey';
    id: Scalars['ID']['output'];
};
export type ConversationKeysInput = {
    conversationAESKey: Scalars['String']['input'];
    conversationIVKey: Scalars['String']['input'];
};
export type ConversationMember = {
    __typename?: 'ConversationMember';
    conversationId: Scalars['ID']['output'];
    counterpartyUserTypeOrgId: Scalars['String']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    encryptedConversationAESKey: Scalars['String']['output'];
    encryptedConversationIVKey: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    type: UserType;
    updatedAt: Scalars['AWSDateTime']['output'];
    user?: Maybe<User>;
    userConversationId: Scalars['String']['output'];
    userId: Scalars['ID']['output'];
};
export type ConversationPin = {
    __typename?: 'ConversationPin';
    conversation?: Maybe<Conversation>;
    conversationId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    id: Scalars['ID']['output'];
    updatedAt: Scalars['AWSDateTime']['output'];
    user?: Maybe<User>;
    userId: Scalars['ID']['output'];
};
export type ConversationReport = {
    __typename?: 'ConversationReport';
    createdAt: Scalars['AWSDateTime']['output'];
    description?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    updatedAt: Scalars['AWSDateTime']['output'];
    user?: Maybe<User>;
    userId?: Maybe<Scalars['ID']['output']>;
};
export type ConversationTradingPool = {
    __typename?: 'ConversationTradingPool';
    conversation?: Maybe<Conversation>;
    conversationId?: Maybe<Scalars['ID']['output']>;
    createdAt?: Maybe<Scalars['AWSDateTime']['output']>;
    deletedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    id: Scalars['ID']['output'];
    involvedUsers: Array<Scalars['ID']['output']>;
    membersIds: Array<Scalars['ID']['output']>;
    operation?: Maybe<Scalars['AWSJSON']['output']>;
    organizationConversationId?: Maybe<Scalars['String']['output']>;
    status?: Maybe<ConversationTradingPoolStatus>;
    statusOrganizationConversationId?: Maybe<Scalars['String']['output']>;
    type?: Maybe<ConversationTradingPoolType>;
    updatedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    userId?: Maybe<Scalars['ID']['output']>;
};
export declare enum ConversationTradingPoolStatus {
    TradeAll = "TRADE_ALL",
    TradeCompleted = "TRADE_COMPLETED",
    TradeInitialized = "TRADE_INITIALIZED",
    TradeProgress = "TRADE_PROGRESS"
}
export declare enum ConversationTradingPoolType {
    Rent = "RENT",
    Trade = "TRADE"
}
export declare enum ConversationType {
    Community = "COMMUNITY",
    Group = "GROUP",
    OneToOne = "ONE_TO_ONE",
    Public = "PUBLIC"
}
export type CreateConversationInput = {
    bannerImageURL?: InputMaybe<Scalars['String']['input']>;
    conversationKeys?: InputMaybe<ConversationKeysInput>;
    description?: InputMaybe<Scalars['String']['input']>;
    imageSettings?: InputMaybe<Scalars['AWSJSON']['input']>;
    imageURL?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type DeleteBatchConversationMessagesInput = {
    conversationId: Scalars['ID']['input'];
    messagesIds: Array<Scalars['ID']['input']>;
};
export type DeleteConversationMessageInput = {
    messageId: Scalars['ID']['input'];
};
export type EditMessageInput = {
    content: Scalars['String']['input'];
    conversationId: Scalars['ID']['input'];
    messageId: Scalars['ID']['input'];
};
export type EjectMemberInput = {
    conversationId: Scalars['ID']['input'];
    userId: Scalars['ID']['input'];
};
export type EncryptedIdentityInput = {
    encryptedConversationAESKey?: InputMaybe<Scalars['String']['input']>;
    encryptedConversationIVKey?: InputMaybe<Scalars['String']['input']>;
    memberId: Scalars['ID']['input'];
};
export type EraseConversationByAdminBatchResult = {
    __typename?: 'EraseConversationByAdminBatchResult';
    conversationId: Scalars['String']['output'];
    items: Array<EraseConversationItemKey>;
};
export type EraseConversationItemKey = {
    __typename?: 'EraseConversationItemKey';
    id: Scalars['ID']['output'];
};
export type FindUsersByUsernameInput = {
    nextToken?: InputMaybe<Scalars['String']['input']>;
    searchTerm: Scalars['String']['input'];
};
export type FindUsersByUsernameResult = {
    __typename?: 'FindUsersByUsernameResult';
    items: Array<User>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type JoinConversationInput = {
    conversationId: Scalars['ID']['input'];
    encryptedConversationAESKey?: InputMaybe<Scalars['String']['input']>;
    encryptedConversationIVKey?: InputMaybe<Scalars['String']['input']>;
};
export type JoinConversationResult = {
    __typename?: 'JoinConversationResult';
    conversation: Conversation;
    conversationId: Scalars['ID']['output'];
    member: User;
};
export type ListAllActiveUserConversationIdsInput = {
    nextToken?: InputMaybe<Scalars['String']['input']>;
    type: ActiveUserConversationType;
};
export type ListAllActiveUserConversationIdsResult = {
    __typename?: 'ListAllActiveUserConversationIdsResult';
    items: Array<Scalars['ID']['output']>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListConversationMemberByUserIdResult = {
    __typename?: 'ListConversationMemberByUserIdResult';
    items: Array<ConversationMember>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListConversationMembers = {
    __typename?: 'ListConversationMembers';
    conversationId: Scalars['ID']['output'];
    items: Array<ConversationMember>;
    membersIds: Array<Scalars['ID']['output']>;
};
export type ListConversationsByIdsResult = {
    __typename?: 'ListConversationsByIdsResult';
    items: Array<Conversation>;
    unprocessedKeys?: Maybe<Array<Scalars['ID']['output']>>;
};
export type ListConversationsPinnedByUserIdResult = {
    __typename?: 'ListConversationsPinnedByUserIdResult';
    items: Array<ConversationPin>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListMessagesByConversationIdInput = {
    conversationId: Scalars['ID']['input'];
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListMessagesByConversationIdResult = {
    __typename?: 'ListMessagesByConversationIdResult';
    items: Array<Message>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListMessagesByRangeOrderInput = {
    conversationId: Scalars['ID']['input'];
    maxOrder: Scalars['Int']['input'];
    minOrder: Scalars['Int']['input'];
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListMessagesByRangeOrderResult = {
    __typename?: 'ListMessagesByRangeOrderResult';
    items: Array<Message>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListMessagesImportantByUserConversationIdInput = {
    conversationId: Scalars['ID']['input'];
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListMessagesImportantByUserConversationIdResult = {
    __typename?: 'ListMessagesImportantByUserConversationIdResult';
    items: Array<MessageImportant>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListMessagesUpdatedInput = {
    conversationId: Scalars['ID']['input'];
    greaterThanDate: Scalars['AWSDateTime']['input'];
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListMessagesUpdatedResult = {
    __typename?: 'ListMessagesUpdatedResult';
    items: Array<Message>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListTradesByConversationIdInput = {
    conversationId: Scalars['ID']['input'];
    nextToken?: InputMaybe<Scalars['String']['input']>;
    status: ConversationTradingPoolStatus;
};
export type ListTradesByConversationIdResult = {
    __typename?: 'ListTradesByConversationIdResult';
    items: Array<ConversationTradingPool>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ListUsersByIdsResult = {
    __typename?: 'ListUsersByIdsResult';
    items: Array<User>;
    unprocessedKeys?: Maybe<Array<Scalars['ID']['output']>>;
};
export type MemberOutResult = {
    __typename?: 'MemberOutResult';
    conversation: Conversation;
    conversationId: Scalars['String']['output'];
    memberOut: User;
    membersIds: Array<Scalars['ID']['output']>;
};
export type Message = {
    __typename?: 'Message';
    content: Scalars['String']['output'];
    conversation?: Maybe<Conversation>;
    conversationId: Scalars['ID']['output'];
    conversationOrderId: Scalars['ID']['output'];
    conversationUpdatedAtId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    deletedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    id: Scalars['ID']['output'];
    important?: Maybe<Array<Maybe<MessageImportant>>>;
    membersIds: Array<Scalars['ID']['output']>;
    messageRoot?: Maybe<Message>;
    messageRootId?: Maybe<Scalars['ID']['output']>;
    order: Scalars['Int']['output'];
    organizationConversationId?: Maybe<Scalars['String']['output']>;
    organizationId?: Maybe<Scalars['String']['output']>;
    organizationUserConversationId?: Maybe<Scalars['String']['output']>;
    pin?: Maybe<Array<Maybe<MessagePin>>>;
    reactions?: Maybe<Array<Reaction>>;
    reports?: Maybe<Array<Maybe<MessageReport>>>;
    type?: Maybe<MessageType>;
    updatedAt?: Maybe<Scalars['AWSDateTime']['output']>;
    user?: Maybe<User>;
    userConversationId?: Maybe<Scalars['String']['output']>;
    userId: Scalars['ID']['output'];
};
export type MessageImportant = {
    __typename?: 'MessageImportant';
    conversation?: Maybe<Conversation>;
    conversationId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    id: Scalars['ID']['output'];
    message?: Maybe<Message>;
    messageId: Scalars['ID']['output'];
    updatedAt: Scalars['AWSDateTime']['output'];
    user?: Maybe<User>;
    userConversationId: Scalars['String']['output'];
    userId: Scalars['ID']['output'];
};
export type MessagePin = {
    __typename?: 'MessagePin';
    conversation?: Maybe<Conversation>;
    conversationId: Scalars['ID']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    id: Scalars['ID']['output'];
    message?: Maybe<Message>;
    messageId: Scalars['ID']['output'];
    user?: Maybe<User>;
    userId: Scalars['ID']['output'];
};
export type MessageReport = {
    __typename?: 'MessageReport';
    createdAt: Scalars['AWSDateTime']['output'];
    description: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    updatedAt: Scalars['AWSDateTime']['output'];
    user?: Maybe<User>;
    userId: Scalars['ID']['output'];
};
export declare enum MessageType {
    Attachment = "ATTACHMENT",
    Nft = "NFT",
    Rent = "RENT",
    Textual = "TEXTUAL",
    TradeProposal = "TRADE_PROPOSAL"
}
export type ModelAddGroupFromInput = {
    eq?: InputMaybe<AddGroupFrom>;
    ne?: InputMaybe<AddGroupFrom>;
};
export type ModelConversationTradingPoolStatusInput = {
    eq?: InputMaybe<ConversationTradingPoolStatus>;
    ne?: InputMaybe<ConversationTradingPoolStatus>;
};
export type ModelConversationTradingPoolTypeInput = {
    eq?: InputMaybe<ConversationTradingPoolType>;
    ne?: InputMaybe<ConversationTradingPoolType>;
};
export type ModelConversationTypeInput = {
    eq?: InputMaybe<ConversationType>;
    ne?: InputMaybe<ConversationType>;
};
export type ModelMessageTypeInput = {
    eq?: InputMaybe<MessageType>;
    ne?: InputMaybe<MessageType>;
};
export type ModelReceiveMessageFromInput = {
    eq?: InputMaybe<ReceiveMessageFrom>;
    ne?: InputMaybe<ReceiveMessageFrom>;
};
export type ModelUserOnlineStatusInput = {
    eq?: InputMaybe<UserOnlineStatus>;
    ne?: InputMaybe<UserOnlineStatus>;
};
export type ModelUserTypeInput = {
    eq?: InputMaybe<UserType>;
    ne?: InputMaybe<UserType>;
};
export type Mutation = {
    __typename?: 'Mutation';
    addBlockedUser?: Maybe<User>;
    addImportantToMessage?: Maybe<Message>;
    addMembersToConversation?: Maybe<ListConversationMembers>;
    addPinToConversation?: Maybe<Conversation>;
    addPinToMessage?: Maybe<Message>;
    addReactionToMessage?: Maybe<Message>;
    addReportToConversation?: Maybe<ConversationReport>;
    addReportToMessage?: Maybe<MessageReport>;
    archiveConversation?: Maybe<User>;
    archiveConversations?: Maybe<User>;
    createConversationGroup?: Maybe<Conversation>;
    createConversationOneToOne?: Maybe<Conversation>;
    deleteBatchConversationMessages?: Maybe<BatchDeleteMessagesResult>;
    deleteConversationMessage?: Maybe<Message>;
    deleteRequestTrade?: Maybe<ConversationTradingPool>;
    editMessage?: Maybe<Message>;
    ejectMember?: Maybe<MemberOutResult>;
    eraseConversationByAdmin?: Maybe<EraseConversationByAdminBatchResult>;
    joinConversation?: Maybe<JoinConversationResult>;
    leaveConversation?: Maybe<MemberOutResult>;
    muteConversation?: Maybe<Conversation>;
    removeBlockedUser?: Maybe<User>;
    removeImportantFromMessage?: Maybe<Message>;
    removePinFromConversation?: Maybe<Scalars['Boolean']['output']>;
    removePinFromMessage?: Maybe<Message>;
    removeReactionFromMessage?: Maybe<Message>;
    requestTrade?: Maybe<ConversationTradingPool>;
    sendMessage?: Maybe<Message>;
    unarchiveConversation?: Maybe<User>;
    unarchiveConversations?: Maybe<User>;
    unmuteConversation?: Maybe<Conversation>;
    updateConversationGroup?: Maybe<Conversation>;
    updateRequestTrade?: Maybe<ConversationTradingPool>;
    updateUserInfo?: Maybe<User>;
};
export type MutationAddBlockedUserArgs = {
    blockId: Scalars['ID']['input'];
};
export type MutationAddImportantToMessageArgs = {
    messageId: Scalars['ID']['input'];
};
export type MutationAddMembersToConversationArgs = {
    input: AddMembersToConversationInput;
};
export type MutationAddPinToConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationAddPinToMessageArgs = {
    messageId: Scalars['ID']['input'];
};
export type MutationAddReactionToMessageArgs = {
    input: AddReactionToMessageInput;
};
export type MutationAddReportToConversationArgs = {
    input: AddReportToConversationInput;
};
export type MutationAddReportToMessageArgs = {
    input: AddReportToMessageInput;
};
export type MutationArchiveConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationArchiveConversationsArgs = {
    conversationIds: Array<Scalars['ID']['input']>;
};
export type MutationCreateConversationGroupArgs = {
    input: CreateConversationInput;
};
export type MutationCreateConversationOneToOneArgs = {
    input: CreateConversationInput;
};
export type MutationDeleteBatchConversationMessagesArgs = {
    input: DeleteBatchConversationMessagesInput;
};
export type MutationDeleteConversationMessageArgs = {
    input: DeleteConversationMessageInput;
};
export type MutationDeleteRequestTradeArgs = {
    requestTradeId: Scalars['ID']['input'];
};
export type MutationEditMessageArgs = {
    input: EditMessageInput;
};
export type MutationEjectMemberArgs = {
    input: EjectMemberInput;
};
export type MutationEraseConversationByAdminArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationJoinConversationArgs = {
    input?: InputMaybe<JoinConversationInput>;
};
export type MutationLeaveConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationMuteConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationRemoveBlockedUserArgs = {
    blockId: Scalars['ID']['input'];
};
export type MutationRemoveImportantFromMessageArgs = {
    messageId: Scalars['ID']['input'];
};
export type MutationRemovePinFromConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationRemovePinFromMessageArgs = {
    messageId: Scalars['ID']['input'];
};
export type MutationRemoveReactionFromMessageArgs = {
    input: RemoveReactionFromMessageInput;
};
export type MutationRequestTradeArgs = {
    input: RequestTradeInput;
};
export type MutationSendMessageArgs = {
    input: SendMessageInput;
};
export type MutationUnarchiveConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationUnarchiveConversationsArgs = {
    conversationIds: Array<Scalars['ID']['input']>;
};
export type MutationUnmuteConversationArgs = {
    conversationId: Scalars['ID']['input'];
};
export type MutationUpdateConversationGroupArgs = {
    input: UpdateConversationGroupInput;
};
export type MutationUpdateRequestTradeArgs = {
    input: UpdateRequestTradeInput;
};
export type MutationUpdateUserInfoArgs = {
    input: UpdateUserInfoInput;
};
export type Muted = {
    __typename?: 'Muted';
    createdAt: Scalars['AWSDateTime']['output'];
    userId: Scalars['ID']['output'];
};
export declare enum MutedDuration {
    EightHours = "EIGHT_HOURS",
    Forever = "FOREVER",
    OneDay = "ONE_DAY",
    OneWeek = "ONE_WEEK"
}
export type OperationCounterpartiesInput = {
    counterpartyAddress: Scalars['String']['input'];
    counterpartyDid: Scalars['String']['input'];
    creatorAddress: Scalars['String']['input'];
    creatorDid: Scalars['String']['input'];
};
export type Query = {
    __typename?: 'Query';
    findUsersByUsername?: Maybe<FindUsersByUsernameResult>;
    getConversationById?: Maybe<Conversation>;
    getConversationTradingPoolById?: Maybe<ConversationTradingPool>;
    getCurrentUser?: Maybe<User>;
    getMessageById?: Maybe<Message>;
    listAllActiveUserConversationIds?: Maybe<ListAllActiveUserConversationIdsResult>;
    listConversationMemberByUserId?: Maybe<ListConversationMemberByUserIdResult>;
    listConversationsByIds?: Maybe<ListConversationsByIdsResult>;
    listConversationsPinnedByCurrentUser?: Maybe<ListConversationsPinnedByUserIdResult>;
    listMessagesByConversationId?: Maybe<ListMessagesByConversationIdResult>;
    listMessagesByRangeOrder?: Maybe<ListMessagesByRangeOrderResult>;
    listMessagesImportantByUserConversationId?: Maybe<ListMessagesImportantByUserConversationIdResult>;
    listMessagesUpdated?: Maybe<ListMessagesUpdatedResult>;
    listTradesByConversationId?: Maybe<ListTradesByConversationIdResult>;
    listUsersByIds?: Maybe<ListUsersByIdsResult>;
};
export type QueryFindUsersByUsernameArgs = {
    input: FindUsersByUsernameInput;
};
export type QueryGetConversationByIdArgs = {
    conversationId: Scalars['ID']['input'];
};
export type QueryGetConversationTradingPoolByIdArgs = {
    conversationTradingPoolId: Scalars['ID']['input'];
};
export type QueryGetMessageByIdArgs = {
    messageId: Scalars['ID']['input'];
};
export type QueryListAllActiveUserConversationIdsArgs = {
    input: ListAllActiveUserConversationIdsInput;
};
export type QueryListConversationMemberByUserIdArgs = {
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryListConversationsByIdsArgs = {
    conversationsIds: Array<Scalars['ID']['input']>;
};
export type QueryListConversationsPinnedByCurrentUserArgs = {
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryListMessagesByConversationIdArgs = {
    input: ListMessagesByConversationIdInput;
};
export type QueryListMessagesByRangeOrderArgs = {
    input: ListMessagesByRangeOrderInput;
};
export type QueryListMessagesImportantByUserConversationIdArgs = {
    input: ListMessagesImportantByUserConversationIdInput;
};
export type QueryListMessagesUpdatedArgs = {
    input: ListMessagesUpdatedInput;
};
export type QueryListTradesByConversationIdArgs = {
    input: ListTradesByConversationIdInput;
};
export type QueryListUsersByIdsArgs = {
    usersIds: Array<Scalars['ID']['input']>;
};
export type Reaction = {
    __typename?: 'Reaction';
    content: Scalars['String']['output'];
    createdAt: Scalars['AWSDateTime']['output'];
    userId: Scalars['ID']['output'];
};
export declare enum ReceiveMessageFrom {
    Everyone = "EVERYONE",
    NoOne = "NO_ONE",
    OnlyFollowed = "ONLY_FOLLOWED"
}
export type RemoveReactionFromMessageInput = {
    conversationId: Scalars['ID']['input'];
    messageId: Scalars['ID']['input'];
    reactionContent: Scalars['ID']['input'];
};
export type RequestTradeInput = {
    conversationId: Scalars['ID']['input'];
    involvedUsers: Array<Scalars['ID']['input']>;
    operation: Scalars['AWSJSON']['input'];
};
export type SendMessageInput = {
    content: Scalars['String']['input'];
    conversationId: Scalars['ID']['input'];
    messageRootId?: InputMaybe<Scalars['String']['input']>;
    type: MessageType;
};
export type Subscription = {
    __typename?: 'Subscription';
    onAddMembersToConversation?: Maybe<ListConversationMembers>;
    onAddPinConversation?: Maybe<Conversation>;
    onAddPinMessage?: Maybe<Message>;
    onAddReaction?: Maybe<Message>;
    onBatchDeleteMessages?: Maybe<BatchDeleteMessagesResult>;
    onChatJoinEvents?: Maybe<JoinConversationResult>;
    onChatMemberEvents?: Maybe<MemberOutResult>;
    onChatMessageEvents?: Maybe<Message>;
    onDeleteMessage?: Maybe<Message>;
    onDeleteRequestTrade?: Maybe<ConversationTradingPool>;
    onEditMessage?: Maybe<Message>;
    onEjectMember?: Maybe<MemberOutResult>;
    onLeaveConversation?: Maybe<MemberOutResult>;
    onMuteConversation?: Maybe<Conversation>;
    onRemovePinMessage?: Maybe<Message>;
    onRemoveReaction?: Maybe<Message>;
    onRequestTrade?: Maybe<ConversationTradingPool>;
    onSendMessage?: Maybe<Message>;
    onUnmuteConversation?: Maybe<Conversation>;
    onUpdateConversationGroup?: Maybe<Conversation>;
    onUpdateRequestTrade?: Maybe<ConversationTradingPool>;
    onUpdateUser?: Maybe<User>;
};
export type SubscriptionOnChatJoinEventsArgs = {
    conversationId: Scalars['ID']['input'];
};
export type SubscriptionOnChatMemberEventsArgs = {
    conversationId: Scalars['ID']['input'];
};
export type SubscriptionOnChatMessageEventsArgs = {
    conversationId: Scalars['ID']['input'];
};
export type UpdateConversationGroupInput = {
    bannerImageURL?: InputMaybe<Scalars['String']['input']>;
    conversationId: Scalars['ID']['input'];
    description?: InputMaybe<Scalars['String']['input']>;
    imageSettings?: InputMaybe<Scalars['AWSJSON']['input']>;
    imageURL?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    settings?: InputMaybe<Scalars['AWSJSON']['input']>;
};
export type UpdateRequestTradeInput = {
    conversationTradingPoolId: Scalars['ID']['input'];
    counterparties?: InputMaybe<OperationCounterpartiesInput>;
    orderId?: InputMaybe<Scalars['String']['input']>;
    status: ConversationTradingPoolStatus;
};
export type UpdateUserInfoInput = {
    allowAddToGroupsFrom?: InputMaybe<AddGroupFrom>;
    allowGroupsSuggestion?: InputMaybe<Scalars['Boolean']['input']>;
    allowNotification?: InputMaybe<Scalars['Boolean']['input']>;
    allowNotificationSound?: InputMaybe<Scalars['Boolean']['input']>;
    allowReadReceipt?: InputMaybe<Scalars['Boolean']['input']>;
    allowReceiveMessageFrom?: InputMaybe<ReceiveMessageFrom>;
    onlineStatus?: InputMaybe<UserOnlineStatus>;
    visibility?: InputMaybe<Scalars['Boolean']['input']>;
};
export type User = {
    __typename?: 'User';
    address?: Maybe<Scalars['String']['output']>;
    allowAddToGroupsFrom?: Maybe<AddGroupFrom>;
    allowGroupsSuggestion?: Maybe<Scalars['Boolean']['output']>;
    allowNotification?: Maybe<Scalars['Boolean']['output']>;
    allowNotificationSound?: Maybe<Scalars['Boolean']['output']>;
    allowReadReceipt?: Maybe<Scalars['Boolean']['output']>;
    allowReceiveMessageFrom?: Maybe<ReceiveMessageFrom>;
    archivedConversations?: Maybe<Array<Scalars['ID']['output']>>;
    avatarUrl?: Maybe<Scalars['AWSURL']['output']>;
    bannerImageUrl?: Maybe<Scalars['AWSURL']['output']>;
    bio?: Maybe<Scalars['String']['output']>;
    blacklist?: Maybe<Array<Maybe<BlacklistUserEntry>>>;
    blacklistIds?: Maybe<Array<Scalars['ID']['output']>>;
    city?: Maybe<Scalars['String']['output']>;
    country?: Maybe<Scalars['String']['output']>;
    createdAt: Scalars['String']['output'];
    did: Scalars['String']['output'];
    didOrganizationId: Scalars['String']['output'];
    didPrivy?: Maybe<Scalars['String']['output']>;
    e2ePublicKey?: Maybe<Scalars['String']['output']>;
    e2eSecret?: Maybe<Scalars['String']['output']>;
    e2eSecretIV?: Maybe<Scalars['String']['output']>;
    email?: Maybe<Scalars['String']['output']>;
    gender?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    imageSettings?: Maybe<Scalars['AWSJSON']['output']>;
    isCreator?: Maybe<Scalars['Boolean']['output']>;
    isPfpNft?: Maybe<Scalars['Boolean']['output']>;
    isVerified?: Maybe<Scalars['Boolean']['output']>;
    lat?: Maybe<Scalars['Float']['output']>;
    lng?: Maybe<Scalars['Float']['output']>;
    onlineStatus?: Maybe<UserOnlineStatus>;
    organizationId?: Maybe<Scalars['String']['output']>;
    updatedAt?: Maybe<Scalars['String']['output']>;
    username?: Maybe<Scalars['String']['output']>;
    usernameLowerCase?: Maybe<Scalars['String']['output']>;
    visibility?: Maybe<Scalars['Boolean']['output']>;
};
export type UserFollow = {
    __typename?: 'UserFollow';
    createdAt: Scalars['AWSDateTime']['output'];
    followed?: Maybe<User>;
    followedId: Scalars['ID']['output'];
    id: Scalars['ID']['output'];
    user?: Maybe<User>;
    userFollowedId: Scalars['String']['output'];
    userId: Scalars['ID']['output'];
};
export declare enum UserOnlineStatus {
    Busy = "BUSY",
    Offline = "OFFLINE",
    Online = "ONLINE"
}
export declare enum UserType {
    Administrator = "ADMINISTRATOR",
    User = "USER"
}
//# sourceMappingURL=graphql.d.ts.map