import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
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;
    };
    AWSDate: {
        input: any;
        output: any;
    };
    AWSDateTime: {
        input: any;
        output: any;
    };
    AWSEmail: {
        input: any;
        output: any;
    };
    AWSIPAddress: {
        input: any;
        output: any;
    };
    AWSJSON: {
        input: any;
        output: any;
    };
    AWSPhone: {
        input: any;
        output: any;
    };
    AWSTime: {
        input: any;
        output: any;
    };
    AWSTimestamp: {
        input: any;
        output: any;
    };
    AWSURL: {
        input: any;
        output: any;
    };
};
export type AvailableAddresses = {
    __typename?: 'AvailableAddresses';
    addresses: Array<Scalars['String']['output']>;
};
export type BlockEmailAddressesBulkUpdateResult = {
    __typename?: 'BlockEmailAddressesBulkUpdateResult';
    failedAddresses?: Maybe<Array<Scalars['String']['output']>>;
    status: UpdateEmailMessagesStatus;
    successAddresses?: Maybe<Array<Scalars['String']['output']>>;
};
export type BlockEmailAddressesInput = {
    blockedAddresses: Array<BlockedEmailAddressInput>;
    emailAddressId?: InputMaybe<Scalars['String']['input']>;
    owner: Scalars['ID']['input'];
};
export declare enum BlockedAddressAction {
    Drop = "DROP",
    Spam = "SPAM"
}
export declare enum BlockedAddressHashAlgorithm {
    Sha256 = "SHA256"
}
export type BlockedEmailAddress = {
    __typename?: 'BlockedEmailAddress';
    action?: Maybe<BlockedAddressAction>;
    createdAtEpochMs: Scalars['Float']['output'];
    emailAddressId?: Maybe<Scalars['String']['output']>;
    hashAlgorithm: BlockedAddressHashAlgorithm;
    hashedBlockedValue: Scalars['String']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    sealedValue: SealedAttribute;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type BlockedEmailAddressInput = {
    action?: InputMaybe<BlockedAddressAction>;
    hashAlgorithm: BlockedAddressHashAlgorithm;
    hashedBlockedValue: Scalars['String']['input'];
    sealedValue: SealedAttributeInput;
};
export type CancelScheduledDraftMessageInput = {
    draftMessageKey: Scalars['String']['input'];
    emailAddressId: Scalars['String']['input'];
};
export type CheckEmailAddressAvailabilityInput = {
    domains?: InputMaybe<Array<Scalars['String']['input']>>;
    localParts: Array<Scalars['String']['input']>;
};
export type ConfiguredDomains = {
    __typename?: 'ConfiguredDomains';
    domains: Array<Scalars['String']['output']>;
};
export type CreateCustomEmailFolderInput = {
    customFolderName: SealedAttributeInput;
    emailAddressId: Scalars['ID']['input'];
};
export type CreatePublicKeyInput = {
    algorithm: Scalars['String']['input'];
    keyFormat?: InputMaybe<KeyFormat>;
    keyId: Scalars['String']['input'];
    keyRingId: Scalars['String']['input'];
    publicKey: Scalars['String']['input'];
};
export type CustomEmailFolderUpdateValuesInput = {
    customFolderName?: InputMaybe<SealedAttributeInput>;
};
export type DateRangeInput = {
    endDateEpochMs: Scalars['Float']['input'];
    startDateEpochMs: Scalars['Float']['input'];
};
export type DeleteCustomEmailFolderInput = {
    emailAddressId: Scalars['ID']['input'];
    emailFolderId: Scalars['ID']['input'];
};
export type DeleteEmailMessageInput = {
    messageId: Scalars['ID']['input'];
};
export type DeleteEmailMessagesInput = {
    messageIds: Array<Scalars['ID']['input']>;
};
export type DeleteMessagesByFolderIdInput = {
    emailAddressId: Scalars['ID']['input'];
    folderId: Scalars['ID']['input'];
    hardDelete?: InputMaybe<Scalars['Boolean']['input']>;
};
export type DeprovisionEmailAddressInput = {
    emailAddressId: Scalars['ID']['input'];
};
export type DeprovisionEmailMaskInput = {
    emailMaskId: Scalars['ID']['input'];
};
export type DisableEmailMaskInput = {
    emailMaskId: Scalars['ID']['input'];
};
export type EmailAddress = {
    __typename?: 'EmailAddress';
    alias?: Maybe<SealedAttribute>;
    createdAtEpochMs: Scalars['Float']['output'];
    emailAddress: Scalars['String']['output'];
    folders: Array<EmailFolder>;
    id: Scalars['ID']['output'];
    identityId: Scalars['ID']['output'];
    keyIds: Array<Scalars['String']['output']>;
    keyRingId: Scalars['ID']['output'];
    lastReceivedAtEpochMs?: Maybe<Scalars['Float']['output']>;
    numberOfEmailMessages: Scalars['Int']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    size: Scalars['Float']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type EmailAddressConnection = {
    __typename?: 'EmailAddressConnection';
    items: Array<EmailAddress>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type EmailAddressMetadataUpdateValuesInput = {
    alias?: InputMaybe<SealedAttributeInput>;
};
export type EmailAddressPublicInfo = {
    __typename?: 'EmailAddressPublicInfo';
    emailAddress: Scalars['String']['output'];
    enableEncryption?: Maybe<Scalars['Boolean']['output']>;
    keyId: Scalars['String']['output'];
    publicKey: Scalars['String']['output'];
    publicKeyDetails: EmailAddressPublicKey;
};
export type EmailAddressPublicKey = {
    __typename?: 'EmailAddressPublicKey';
    algorithm: Scalars['String']['output'];
    keyFormat: KeyFormat;
    publicKey: Scalars['String']['output'];
};
export type EmailConfigurationData = {
    __typename?: 'EmailConfigurationData';
    deleteEmailMessagesLimit: Scalars['Int']['output'];
    emailMasksEnabled: Scalars['Boolean']['output'];
    emailMessageMaxInboundMessageSize: Scalars['Int']['output'];
    emailMessageMaxOutboundMessageSize: Scalars['Int']['output'];
    emailMessageRecipientsLimit: Scalars['Int']['output'];
    encryptedEmailMessageRecipientsLimit: Scalars['Int']['output'];
    externalEmailMasksEnabled: Scalars['Boolean']['output'];
    prohibitedFileExtensions: Array<Scalars['String']['output']>;
    sendEncryptedEmailEnabled: Scalars['Boolean']['output'];
    updateEmailMessagesLimit: Scalars['Int']['output'];
};
export type EmailFolder = {
    __typename?: 'EmailFolder';
    createdAtEpochMs: Scalars['Float']['output'];
    customFolderName?: Maybe<SealedAttribute>;
    emailAddressId: Scalars['ID']['output'];
    folderName: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    size: Scalars['Float']['output'];
    ttl?: Maybe<Scalars['Float']['output']>;
    unseenCount: Scalars['Float']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type EmailFolderConnection = {
    __typename?: 'EmailFolderConnection';
    items: Array<EmailFolder>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type EmailMask = {
    __typename?: 'EmailMask';
    createdAtEpochMs: Scalars['Float']['output'];
    expiresAtEpochSec?: Maybe<Scalars['Int']['output']>;
    id: Scalars['ID']['output'];
    identityId: Scalars['ID']['output'];
    inboundDelivered: Scalars['Int']['output'];
    inboundReceived: Scalars['Int']['output'];
    keyRingId: Scalars['ID']['output'];
    maskAddress: Scalars['String']['output'];
    metadata?: Maybe<SealedAttribute>;
    outboundDelivered: Scalars['Int']['output'];
    outboundReceived: Scalars['Int']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    realAddress: Scalars['String']['output'];
    realAddressType: EmailMaskRealAddressType;
    spamCount: Scalars['Int']['output'];
    status: EmailMaskStatus;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
    virusCount: Scalars['Int']['output'];
};
export type EmailMaskConnection = {
    __typename?: 'EmailMaskConnection';
    items: Array<EmailMask>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type EmailMaskDomains = {
    __typename?: 'EmailMaskDomains';
    domains: Array<Scalars['String']['output']>;
};
export type EmailMaskFilterInput = {
    and?: InputMaybe<Array<InputMaybe<EmailMaskFilterInput>>>;
    not?: InputMaybe<EmailMaskFilterInput>;
    or?: InputMaybe<Array<InputMaybe<EmailMaskFilterInput>>>;
    realAddressType?: InputMaybe<EmailMaskRealAddressTypeFilterInput>;
    status?: InputMaybe<EmailMaskStatusFilterInput>;
};
export declare enum EmailMaskRealAddressType {
    External = "EXTERNAL",
    Internal = "INTERNAL"
}
export type EmailMaskRealAddressTypeFilterInput = {
    eq?: InputMaybe<EmailMaskRealAddressType>;
    in?: InputMaybe<Array<InputMaybe<EmailMaskRealAddressType>>>;
    ne?: InputMaybe<EmailMaskRealAddressType>;
    notIn?: InputMaybe<Array<InputMaybe<EmailMaskRealAddressType>>>;
};
export declare enum EmailMaskStatus {
    Disabled = "DISABLED",
    Enabled = "ENABLED",
    Locked = "LOCKED",
    Pending = "PENDING"
}
export type EmailMaskStatusFilterInput = {
    eq?: InputMaybe<EmailMaskStatus>;
    in?: InputMaybe<Array<InputMaybe<EmailMaskStatus>>>;
    ne?: InputMaybe<EmailMaskStatus>;
    notIn?: InputMaybe<Array<InputMaybe<EmailMaskStatus>>>;
};
export type EmailMessageConnection = {
    __typename?: 'EmailMessageConnection';
    items: Array<SealedEmailMessage>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type EmailMessageDateRangeInput = {
    sortDateEpochMs?: InputMaybe<DateRangeInput>;
    updatedAtEpochMs?: InputMaybe<DateRangeInput>;
};
export declare enum EmailMessageDirection {
    Inbound = "INBOUND",
    Outbound = "OUTBOUND"
}
export declare enum EmailMessageEncryptionStatus {
    Encrypted = "ENCRYPTED",
    Unencrypted = "UNENCRYPTED"
}
export declare enum EmailMessageState {
    Deleted = "DELETED",
    Delivered = "DELIVERED",
    Failed = "FAILED",
    Queued = "QUEUED",
    Received = "RECEIVED",
    Sent = "SENT",
    Undelivered = "UNDELIVERED"
}
export type EmailMessageUpdateValuesInput = {
    folderId?: InputMaybe<Scalars['ID']['input']>;
    seen?: InputMaybe<Scalars['Boolean']['input']>;
};
export type EnableEmailMaskInput = {
    emailMaskId: Scalars['ID']['input'];
};
export type GetEmailAddressBlocklistInput = {
    owner: Scalars['ID']['input'];
};
export type GetEmailAddressBlocklistResponse = {
    __typename?: 'GetEmailAddressBlocklistResponse';
    blockedAddresses: Array<BlockedEmailAddress>;
};
export declare enum KeyFormat {
    RsaPublicKey = "RSA_PUBLIC_KEY",
    Spki = "SPKI"
}
export type ListEmailAddressesForSudoIdInput = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sudoId: Scalars['ID']['input'];
};
export type ListEmailAddressesInput = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListEmailFoldersForEmailAddressIdInput = {
    emailAddressId: Scalars['ID']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListEmailMasksForOwnerInput = {
    filter?: InputMaybe<EmailMaskFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type ListEmailMessagesForEmailAddressIdInput = {
    emailAddressId: Scalars['ID']['input'];
    includeDeletedMessages?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
    specifiedDateRange?: InputMaybe<EmailMessageDateRangeInput>;
};
export type ListEmailMessagesForEmailFolderIdInput = {
    folderId: Scalars['ID']['input'];
    includeDeletedMessages?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
    specifiedDateRange?: InputMaybe<EmailMessageDateRangeInput>;
};
export type ListEmailMessagesInput = {
    includeDeletedMessages?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
    specifiedDateRange?: InputMaybe<EmailMessageDateRangeInput>;
};
export type ListScheduledDraftMessagesForEmailAddressIdInput = {
    emailAddressId: Scalars['ID']['input'];
    filter?: InputMaybe<ScheduledDraftMessageFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type LookupEmailAddressesPublicInfoInput = {
    emailAddresses: Array<Scalars['String']['input']>;
};
export type LookupEmailAddressesPublicInfoResponse = {
    __typename?: 'LookupEmailAddressesPublicInfoResponse';
    items: Array<EmailAddressPublicInfo>;
};
export type Mutation = {
    __typename?: 'Mutation';
    blockEmailAddresses: BlockEmailAddressesBulkUpdateResult;
    cancelScheduledDraftMessage: Scalars['String']['output'];
    createCustomEmailFolder: EmailFolder;
    createPublicKeyForEmail: PublicKey;
    deleteCustomEmailFolder?: Maybe<EmailFolder>;
    deleteEmailMessage: Scalars['ID']['output'];
    deleteEmailMessages: Array<Scalars['ID']['output']>;
    deleteMessagesByFolderId: Scalars['ID']['output'];
    deprovisionEmailAddress: EmailAddress;
    deprovisionEmailMask: EmailMask;
    disableEmailMask: EmailMask;
    enableEmailMask: EmailMask;
    provisionEmailAddress: EmailAddress;
    provisionEmailMask: EmailMask;
    scheduleSendDraftMessage: ScheduledDraftMessage;
    sendEmailMessageV2: SendEmailMessageResult;
    sendEncryptedEmailMessage: SendEmailMessageResult;
    sendMaskedEmailMessage: SendEmailMessageResult;
    unblockEmailAddresses: BlockEmailAddressesBulkUpdateResult;
    updateCustomEmailFolder: EmailFolder;
    updateEmailAddressMetadata: Scalars['ID']['output'];
    updateEmailMask: EmailMask;
    updateEmailMessagesV2: UpdateEmailMessagesV2Result;
    verifyExternalEmailAddress: VerifyExternalEmailAddressResult;
};
export type MutationBlockEmailAddressesArgs = {
    input: BlockEmailAddressesInput;
};
export type MutationCancelScheduledDraftMessageArgs = {
    input: CancelScheduledDraftMessageInput;
};
export type MutationCreateCustomEmailFolderArgs = {
    input: CreateCustomEmailFolderInput;
};
export type MutationCreatePublicKeyForEmailArgs = {
    input: CreatePublicKeyInput;
};
export type MutationDeleteCustomEmailFolderArgs = {
    input: DeleteCustomEmailFolderInput;
};
export type MutationDeleteEmailMessageArgs = {
    input: DeleteEmailMessageInput;
};
export type MutationDeleteEmailMessagesArgs = {
    input: DeleteEmailMessagesInput;
};
export type MutationDeleteMessagesByFolderIdArgs = {
    input: DeleteMessagesByFolderIdInput;
};
export type MutationDeprovisionEmailAddressArgs = {
    input: DeprovisionEmailAddressInput;
};
export type MutationDeprovisionEmailMaskArgs = {
    input: DeprovisionEmailMaskInput;
};
export type MutationDisableEmailMaskArgs = {
    input: DisableEmailMaskInput;
};
export type MutationEnableEmailMaskArgs = {
    input: EnableEmailMaskInput;
};
export type MutationProvisionEmailAddressArgs = {
    input: ProvisionEmailAddressInput;
};
export type MutationProvisionEmailMaskArgs = {
    input: ProvisionEmailMaskInput;
};
export type MutationScheduleSendDraftMessageArgs = {
    input: ScheduleSendDraftMessageInput;
};
export type MutationSendEmailMessageV2Args = {
    input: SendEmailMessageInput;
};
export type MutationSendEncryptedEmailMessageArgs = {
    input: SendEncryptedEmailMessageInput;
};
export type MutationSendMaskedEmailMessageArgs = {
    input: SendMaskedEmailMessageInput;
};
export type MutationUnblockEmailAddressesArgs = {
    input: UnblockEmailAddressesInput;
};
export type MutationUpdateCustomEmailFolderArgs = {
    input: UpdateCustomEmailFolderInput;
};
export type MutationUpdateEmailAddressMetadataArgs = {
    input: UpdateEmailAddressMetadataInput;
};
export type MutationUpdateEmailMaskArgs = {
    input: UpdateEmailMaskInput;
};
export type MutationUpdateEmailMessagesV2Args = {
    input: UpdateEmailMessagesInput;
};
export type MutationVerifyExternalEmailAddressArgs = {
    input: VerifyExternalEmailAddressInput;
};
export type Owner = {
    __typename?: 'Owner';
    id: Scalars['String']['output'];
    issuer: Scalars['String']['output'];
};
export type OwnerInput = {
    id: Scalars['String']['input'];
    issuer: Scalars['String']['input'];
};
export type PaginatedPublicKey = {
    __typename?: 'PaginatedPublicKey';
    items: Array<PublicKey>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ProvisionEmailAddressInput = {
    alias?: InputMaybe<SealedAttributeInput>;
    emailAddress: Scalars['String']['input'];
    key: ProvisionEmailAddressPublicKeyInput;
    ownershipProofTokens: Array<Scalars['String']['input']>;
};
export type ProvisionEmailAddressPublicKeyInput = {
    algorithm: Scalars['String']['input'];
    keyFormat?: InputMaybe<KeyFormat>;
    keyId: Scalars['String']['input'];
    publicKey: Scalars['String']['input'];
};
export type ProvisionEmailMaskInput = {
    expiresAtEpochSec?: InputMaybe<Scalars['Int']['input']>;
    key: ProvisionEmailMaskPublicKeyInput;
    maskAddress: Scalars['String']['input'];
    metadata?: InputMaybe<SealedAttributeInput>;
    ownershipProofTokens: Array<Scalars['String']['input']>;
    realAddress: Scalars['String']['input'];
};
export type ProvisionEmailMaskPublicKeyInput = {
    algorithm: Scalars['String']['input'];
    keyFormat: KeyFormat;
    keyId: Scalars['String']['input'];
    publicKey: Scalars['String']['input'];
};
export type PublicKey = {
    __typename?: 'PublicKey';
    algorithm: Scalars['String']['output'];
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    keyFormat: KeyFormat;
    keyId: Scalars['String']['output'];
    keyRingId: Scalars['String']['output'];
    owner: Scalars['ID']['output'];
    publicKey: Scalars['String']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type Query = {
    __typename?: 'Query';
    checkEmailAddressAvailability: AvailableAddresses;
    getConfiguredEmailDomains: ConfiguredDomains;
    getEmailAddress?: Maybe<EmailAddress>;
    getEmailAddressBlocklist: GetEmailAddressBlocklistResponse;
    getEmailConfig: EmailConfigurationData;
    getEmailDomains: SupportedDomains;
    getEmailMaskDomains: EmailMaskDomains;
    getEmailMessage?: Maybe<SealedEmailMessage>;
    getKeyRingForEmail: PaginatedPublicKey;
    getPublicKeyForEmail?: Maybe<PublicKey>;
    getPublicKeysForEmail: PaginatedPublicKey;
    listEmailAddresses: EmailAddressConnection;
    listEmailAddressesForSudoId: EmailAddressConnection;
    listEmailFoldersForEmailAddressId: EmailFolderConnection;
    listEmailMasksForOwner: EmailMaskConnection;
    listEmailMessages: EmailMessageConnection;
    listEmailMessagesForEmailAddressId: EmailMessageConnection;
    listEmailMessagesForEmailFolderId: EmailMessageConnection;
    listScheduledDraftMessagesForEmailAddressId: ScheduledDraftMessageConnection;
    lookupEmailAddressesPublicInfo: LookupEmailAddressesPublicInfoResponse;
};
export type QueryCheckEmailAddressAvailabilityArgs = {
    input: CheckEmailAddressAvailabilityInput;
};
export type QueryGetEmailAddressArgs = {
    id: Scalars['String']['input'];
};
export type QueryGetEmailAddressBlocklistArgs = {
    input: GetEmailAddressBlocklistInput;
};
export type QueryGetEmailMessageArgs = {
    id: Scalars['ID']['input'];
};
export type QueryGetKeyRingForEmailArgs = {
    keyRingId: Scalars['String']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetPublicKeyForEmailArgs = {
    keyId: Scalars['String']['input'];
};
export type QueryGetPublicKeysForEmailArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryListEmailAddressesArgs = {
    input: ListEmailAddressesInput;
};
export type QueryListEmailAddressesForSudoIdArgs = {
    input: ListEmailAddressesForSudoIdInput;
};
export type QueryListEmailFoldersForEmailAddressIdArgs = {
    input: ListEmailFoldersForEmailAddressIdInput;
};
export type QueryListEmailMasksForOwnerArgs = {
    input: ListEmailMasksForOwnerInput;
};
export type QueryListEmailMessagesArgs = {
    input: ListEmailMessagesInput;
};
export type QueryListEmailMessagesForEmailAddressIdArgs = {
    input: ListEmailMessagesForEmailAddressIdInput;
};
export type QueryListEmailMessagesForEmailFolderIdArgs = {
    input: ListEmailMessagesForEmailFolderIdInput;
};
export type QueryListScheduledDraftMessagesForEmailAddressIdArgs = {
    input: ListScheduledDraftMessagesForEmailAddressIdInput;
};
export type QueryLookupEmailAddressesPublicInfoArgs = {
    input: LookupEmailAddressesPublicInfoInput;
};
export type Rfc822DataAttributesType = {
    __typename?: 'Rfc822DataAttributesType';
    bucket: Scalars['String']['output'];
    key: Scalars['String']['output'];
};
export type Rfc822HeaderInput = {
    bcc: Array<Scalars['String']['input']>;
    cc: Array<Scalars['String']['input']>;
    dateEpochMs?: InputMaybe<Scalars['Float']['input']>;
    from: Scalars['String']['input'];
    hasAttachments?: InputMaybe<Scalars['Boolean']['input']>;
    inReplyTo?: InputMaybe<Scalars['String']['input']>;
    references?: InputMaybe<Array<Scalars['String']['input']>>;
    replyTo: Array<Scalars['String']['input']>;
    subject?: InputMaybe<Scalars['String']['input']>;
    to: Array<Scalars['String']['input']>;
};
export type S3EmailObjectInput = {
    bucket: Scalars['String']['input'];
    key: Scalars['String']['input'];
    region: Scalars['String']['input'];
};
export type ScheduleSendDraftMessageInput = {
    draftMessageKey: Scalars['String']['input'];
    emailAddressId: Scalars['ID']['input'];
    sendAtEpochMs: Scalars['Float']['input'];
    symmetricKey: Scalars['String']['input'];
};
export type ScheduledDraftMessage = {
    __typename?: 'ScheduledDraftMessage';
    createdAtEpochMs: Scalars['Float']['output'];
    draftMessageKey: Scalars['String']['output'];
    emailAddressId: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    sendAtEpochMs: Scalars['Float']['output'];
    state: ScheduledDraftMessageState;
    updatedAtEpochMs: Scalars['Float']['output'];
};
export type ScheduledDraftMessageConnection = {
    __typename?: 'ScheduledDraftMessageConnection';
    items: Array<ScheduledDraftMessage>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ScheduledDraftMessageFilterInput = {
    and?: InputMaybe<Array<InputMaybe<ScheduledDraftMessageFilterInput>>>;
    not?: InputMaybe<ScheduledDraftMessageFilterInput>;
    or?: InputMaybe<Array<InputMaybe<ScheduledDraftMessageFilterInput>>>;
    state?: InputMaybe<ScheduledDraftMessageStateFilterInput>;
};
export declare enum ScheduledDraftMessageState {
    Cancelled = "CANCELLED",
    Failed = "FAILED",
    Scheduled = "SCHEDULED",
    Sent = "SENT"
}
export type ScheduledDraftMessageStateFilterInput = {
    eq?: InputMaybe<ScheduledDraftMessageState>;
    in?: InputMaybe<Array<InputMaybe<ScheduledDraftMessageState>>>;
    ne?: InputMaybe<ScheduledDraftMessageState>;
    notIn?: InputMaybe<Array<InputMaybe<ScheduledDraftMessageState>>>;
};
export type SealedAttribute = {
    __typename?: 'SealedAttribute';
    algorithm: Scalars['String']['output'];
    base64EncodedSealedData: Scalars['String']['output'];
    keyId: Scalars['String']['output'];
    plainTextType: Scalars['String']['output'];
};
export type SealedAttributeInput = {
    algorithm: Scalars['String']['input'];
    base64EncodedSealedData: Scalars['String']['input'];
    keyId: Scalars['String']['input'];
    plainTextType: Scalars['String']['input'];
};
export type SealedEmailMessage = {
    __typename?: 'SealedEmailMessage';
    clientRefId?: Maybe<Scalars['String']['output']>;
    createdAtEpochMs: Scalars['Float']['output'];
    deletedAtEpochMs?: Maybe<Scalars['Float']['output']>;
    direction: EmailMessageDirection;
    emailAddressId: Scalars['ID']['output'];
    emailMaskId?: Maybe<Scalars['ID']['output']>;
    encryptionStatus?: Maybe<EmailMessageEncryptionStatus>;
    folderId: Scalars['ID']['output'];
    forwarded: Scalars['Boolean']['output'];
    id: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    previousFolderId?: Maybe<Scalars['ID']['output']>;
    repliedTo: Scalars['Boolean']['output'];
    rfc822DataAttributes: Rfc822DataAttributesType;
    rfc822Header: SealedAttribute;
    seen: Scalars['Boolean']['output'];
    size: Scalars['Float']['output'];
    sortDateEpochMs: Scalars['Float']['output'];
    state: EmailMessageState;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type SendEmailMessageInput = {
    clientRefId?: InputMaybe<Scalars['String']['input']>;
    emailAddressId: Scalars['ID']['input'];
    message: S3EmailObjectInput;
};
export type SendEmailMessageResult = {
    __typename?: 'SendEmailMessageResult';
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
};
export type SendEncryptedEmailMessageInput = {
    clientRefId?: InputMaybe<Scalars['String']['input']>;
    emailAddressId: Scalars['ID']['input'];
    message: S3EmailObjectInput;
    rfc822Header: Rfc822HeaderInput;
};
export type SendMaskedEmailMessageInput = {
    emailMaskId: Scalars['ID']['input'];
    encryptionStatus: EmailMessageEncryptionStatus;
    message: S3EmailObjectInput;
    rfc822Header: Rfc822HeaderInput;
};
export declare enum SortOrder {
    Asc = "ASC",
    Desc = "DESC"
}
export type Subscription = {
    __typename?: 'Subscription';
    onEmailMessageCreated: SealedEmailMessage;
    onEmailMessageDeleted: SealedEmailMessage;
    onEmailMessageUpdated: SealedEmailMessage;
};
export type SubscriptionOnEmailMessageCreatedArgs = {
    owner: Scalars['ID']['input'];
};
export type SubscriptionOnEmailMessageDeletedArgs = {
    owner: Scalars['ID']['input'];
};
export type SubscriptionOnEmailMessageUpdatedArgs = {
    owner: Scalars['ID']['input'];
};
export type SupportedDomains = {
    __typename?: 'SupportedDomains';
    domains: Array<Scalars['String']['output']>;
};
export type UnblockEmailAddressesInput = {
    owner: Scalars['ID']['input'];
    unblockedAddresses: Array<Scalars['String']['input']>;
};
export type UpdateCustomEmailFolderInput = {
    emailAddressId: Scalars['ID']['input'];
    emailFolderId: Scalars['ID']['input'];
    values: CustomEmailFolderUpdateValuesInput;
};
export type UpdateEmailAddressMetadataInput = {
    id: Scalars['ID']['input'];
    values: EmailAddressMetadataUpdateValuesInput;
};
export type UpdateEmailMaskInput = {
    expiresAtEpochSec?: InputMaybe<Scalars['Int']['input']>;
    id: Scalars['ID']['input'];
    metadata?: InputMaybe<SealedAttributeInput>;
};
export type UpdateEmailMessagesInput = {
    messageIds: Array<Scalars['ID']['input']>;
    values: EmailMessageUpdateValuesInput;
};
export declare enum UpdateEmailMessagesStatus {
    Failed = "FAILED",
    Partial = "PARTIAL",
    Success = "SUCCESS"
}
export type UpdateEmailMessagesV2Result = {
    __typename?: 'UpdateEmailMessagesV2Result';
    failedMessages?: Maybe<Array<UpdatedEmailMessageFailure>>;
    status: UpdateEmailMessagesStatus;
    successMessages?: Maybe<Array<UpdatedEmailMessageSuccess>>;
};
export type UpdatedEmailMessageFailure = {
    __typename?: 'UpdatedEmailMessageFailure';
    errorType: Scalars['String']['output'];
    id: Scalars['ID']['output'];
};
export type UpdatedEmailMessageSuccess = {
    __typename?: 'UpdatedEmailMessageSuccess';
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
};
export type VerifyExternalEmailAddressInput = {
    emailAddress: Scalars['String']['input'];
    emailMaskId: Scalars['String']['input'];
    verificationCode?: InputMaybe<Scalars['String']['input']>;
};
export type VerifyExternalEmailAddressResult = {
    __typename?: 'VerifyExternalEmailAddressResult';
    isVerified: Scalars['Boolean']['output'];
    reason?: Maybe<Scalars['String']['output']>;
};
export type BlockedAddressFragment = {
    __typename?: 'BlockedEmailAddress';
    owner: string;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    hashAlgorithm: BlockedAddressHashAlgorithm;
    hashedBlockedValue: string;
    action?: BlockedAddressAction | null;
    emailAddressId?: string | null;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    sealedValue: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    };
};
export type BlockAddressesResultFragment = {
    __typename?: 'BlockEmailAddressesBulkUpdateResult';
    status: UpdateEmailMessagesStatus;
    failedAddresses?: Array<string> | null;
    successAddresses?: Array<string> | null;
};
export type GetEmailAddressBlocklistResponseFragment = {
    __typename?: 'GetEmailAddressBlocklistResponse';
    blockedAddresses: Array<{
        __typename?: 'BlockedEmailAddress';
        hashedBlockedValue: string;
        action?: BlockedAddressAction | null;
        emailAddressId?: string | null;
        sealedValue: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        };
    }>;
};
export type EmailAddressWithoutFoldersFragment = {
    __typename?: 'EmailAddress';
    id: string;
    owner: string;
    identityId: string;
    keyRingId: string;
    keyIds: Array<string>;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    lastReceivedAtEpochMs?: number | null;
    emailAddress: string;
    size: number;
    numberOfEmailMessages: number;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    alias?: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    } | null;
};
export type EmailAddressFragment = {
    __typename?: 'EmailAddress';
    id: string;
    owner: string;
    identityId: string;
    keyRingId: string;
    keyIds: Array<string>;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    lastReceivedAtEpochMs?: number | null;
    emailAddress: string;
    size: number;
    numberOfEmailMessages: number;
    folders: Array<{
        __typename?: 'EmailFolder';
        id: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        emailAddressId: string;
        folderName: string;
        size: number;
        unseenCount: number;
        ttl?: number | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        customFolderName?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    }>;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    alias?: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    } | null;
};
export type EmailAddressPublicKeyFragment = {
    __typename?: 'EmailAddressPublicKey';
    publicKey: string;
    keyFormat: KeyFormat;
    algorithm: string;
};
export type EmailAddressPublicInfoFragment = {
    __typename?: 'EmailAddressPublicInfo';
    emailAddress: string;
    keyId: string;
    publicKey: string;
    enableEncryption?: boolean | null;
    publicKeyDetails: {
        __typename?: 'EmailAddressPublicKey';
        publicKey: string;
        keyFormat: KeyFormat;
        algorithm: string;
    };
};
export type EmailConfigurationDataFragment = {
    __typename?: 'EmailConfigurationData';
    deleteEmailMessagesLimit: number;
    updateEmailMessagesLimit: number;
    emailMessageMaxInboundMessageSize: number;
    emailMessageMaxOutboundMessageSize: number;
    emailMessageRecipientsLimit: number;
    encryptedEmailMessageRecipientsLimit: number;
    sendEncryptedEmailEnabled: boolean;
    prohibitedFileExtensions: Array<string>;
    emailMasksEnabled: boolean;
    externalEmailMasksEnabled: boolean;
};
export type EmailFolderFragment = {
    __typename?: 'EmailFolder';
    id: string;
    owner: string;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    emailAddressId: string;
    folderName: string;
    size: number;
    unseenCount: number;
    ttl?: number | null;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    customFolderName?: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    } | null;
};
export type EmailMaskFragment = {
    __typename?: 'EmailMask';
    id: string;
    owner: string;
    keyRingId: string;
    identityId: string;
    maskAddress: string;
    realAddress: string;
    realAddressType: EmailMaskRealAddressType;
    status: EmailMaskStatus;
    inboundReceived: number;
    inboundDelivered: number;
    outboundReceived: number;
    outboundDelivered: number;
    spamCount: number;
    virusCount: number;
    expiresAtEpochSec?: number | null;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    metadata?: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    } | null;
};
export type OwnerFragment = {
    __typename?: 'Owner';
    id: string;
    issuer: string;
};
export type PaginatedPublicKeyFragment = {
    __typename?: 'PaginatedPublicKey';
    nextToken?: string | null;
    items: Array<{
        __typename?: 'PublicKey';
        id: string;
        keyId: string;
        keyRingId: string;
        algorithm: string;
        keyFormat: KeyFormat;
        publicKey: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
    }>;
};
export type PublicKeyFragment = {
    __typename?: 'PublicKey';
    id: string;
    keyId: string;
    keyRingId: string;
    algorithm: string;
    keyFormat: KeyFormat;
    publicKey: string;
    owner: string;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
};
export type ScheduledDraftMessageFragment = {
    __typename?: 'ScheduledDraftMessage';
    draftMessageKey: string;
    emailAddressId: string;
    sendAtEpochMs: number;
    state: ScheduledDraftMessageState;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    owner: string;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
};
export type SealedAttributeFragment = {
    __typename?: 'SealedAttribute';
    algorithm: string;
    keyId: string;
    plainTextType: string;
    base64EncodedSealedData: string;
};
export type SealedEmailMessageFragment = {
    __typename?: 'SealedEmailMessage';
    id: string;
    owner: string;
    emailAddressId: string;
    version: number;
    createdAtEpochMs: number;
    updatedAtEpochMs: number;
    sortDateEpochMs: number;
    folderId: string;
    previousFolderId?: string | null;
    direction: EmailMessageDirection;
    seen: boolean;
    repliedTo: boolean;
    forwarded: boolean;
    state: EmailMessageState;
    clientRefId?: string | null;
    size: number;
    encryptionStatus?: EmailMessageEncryptionStatus | null;
    emailMaskId?: string | null;
    owners: Array<{
        __typename?: 'Owner';
        id: string;
        issuer: string;
    }>;
    rfc822Header: {
        __typename?: 'SealedAttribute';
        algorithm: string;
        keyId: string;
        plainTextType: string;
        base64EncodedSealedData: string;
    };
    rfc822DataAttributes: {
        __typename?: 'Rfc822DataAttributesType';
        key: string;
        bucket: string;
    };
};
export type SendEmailMessageResultFragment = {
    __typename?: 'SendEmailMessageResult';
    id: string;
    createdAtEpochMs: number;
};
export type UpdateEmailMessagesResultFragment = {
    __typename?: 'UpdateEmailMessagesV2Result';
    status: UpdateEmailMessagesStatus;
    failedMessages?: Array<{
        __typename?: 'UpdatedEmailMessageFailure';
        id: string;
        errorType: string;
    }> | null;
    successMessages?: Array<{
        __typename?: 'UpdatedEmailMessageSuccess';
        id: string;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
    }> | null;
};
export type VerifyExternalEmailAddressResultFragment = {
    __typename?: 'VerifyExternalEmailAddressResult';
    isVerified: boolean;
    reason?: string | null;
};
export type DeleteEmailMessagesMutationVariables = Exact<{
    input: DeleteEmailMessagesInput;
}>;
export type DeleteEmailMessagesMutation = {
    __typename?: 'Mutation';
    deleteEmailMessages: Array<string>;
};
export type ProvisionEmailAddressMutationVariables = Exact<{
    input: ProvisionEmailAddressInput;
}>;
export type ProvisionEmailAddressMutation = {
    __typename?: 'Mutation';
    provisionEmailAddress: {
        __typename?: 'EmailAddress';
        id: string;
        owner: string;
        identityId: string;
        keyRingId: string;
        keyIds: Array<string>;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        lastReceivedAtEpochMs?: number | null;
        emailAddress: string;
        size: number;
        numberOfEmailMessages: number;
        folders: Array<{
            __typename?: 'EmailFolder';
            id: string;
            owner: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            emailAddressId: string;
            folderName: string;
            size: number;
            unseenCount: number;
            ttl?: number | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            customFolderName?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        alias?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type DeprovisionEmailAddressMutationVariables = Exact<{
    input: DeprovisionEmailAddressInput;
}>;
export type DeprovisionEmailAddressMutation = {
    __typename?: 'Mutation';
    deprovisionEmailAddress: {
        __typename?: 'EmailAddress';
        id: string;
        owner: string;
        identityId: string;
        keyRingId: string;
        keyIds: Array<string>;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        lastReceivedAtEpochMs?: number | null;
        emailAddress: string;
        size: number;
        numberOfEmailMessages: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        alias?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type UpdateEmailAddressMetadataMutationVariables = Exact<{
    input: UpdateEmailAddressMetadataInput;
}>;
export type UpdateEmailAddressMetadataMutation = {
    __typename?: 'Mutation';
    updateEmailAddressMetadata: string;
};
export type SendEmailMessageMutationVariables = Exact<{
    input: SendEmailMessageInput;
}>;
export type SendEmailMessageMutation = {
    __typename?: 'Mutation';
    sendEmailMessageV2: {
        __typename?: 'SendEmailMessageResult';
        id: string;
        createdAtEpochMs: number;
    };
};
export type SendEncryptedEmailMessageMutationVariables = Exact<{
    input: SendEncryptedEmailMessageInput;
}>;
export type SendEncryptedEmailMessageMutation = {
    __typename?: 'Mutation';
    sendEncryptedEmailMessage: {
        __typename?: 'SendEmailMessageResult';
        id: string;
        createdAtEpochMs: number;
    };
};
export type UpdateEmailMessagesMutationVariables = Exact<{
    input: UpdateEmailMessagesInput;
}>;
export type UpdateEmailMessagesMutation = {
    __typename?: 'Mutation';
    updateEmailMessagesV2: {
        __typename?: 'UpdateEmailMessagesV2Result';
        status: UpdateEmailMessagesStatus;
        failedMessages?: Array<{
            __typename?: 'UpdatedEmailMessageFailure';
            id: string;
            errorType: string;
        }> | null;
        successMessages?: Array<{
            __typename?: 'UpdatedEmailMessageSuccess';
            id: string;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
        }> | null;
    };
};
export type DeleteEmailMessageMutationVariables = Exact<{
    input: DeleteEmailMessageInput;
}>;
export type DeleteEmailMessageMutation = {
    __typename?: 'Mutation';
    deleteEmailMessage: string;
};
export type CreateCustomEmailFolderMutationVariables = Exact<{
    input: CreateCustomEmailFolderInput;
}>;
export type CreateCustomEmailFolderMutation = {
    __typename?: 'Mutation';
    createCustomEmailFolder: {
        __typename?: 'EmailFolder';
        id: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        emailAddressId: string;
        folderName: string;
        size: number;
        unseenCount: number;
        ttl?: number | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        customFolderName?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type DeleteCustomEmailFolderMutationVariables = Exact<{
    input: DeleteCustomEmailFolderInput;
}>;
export type DeleteCustomEmailFolderMutation = {
    __typename?: 'Mutation';
    deleteCustomEmailFolder?: {
        __typename?: 'EmailFolder';
        id: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        emailAddressId: string;
        folderName: string;
        size: number;
        unseenCount: number;
        ttl?: number | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        customFolderName?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    } | null;
};
export type UpdateCustomEmailFolderMutationVariables = Exact<{
    input: UpdateCustomEmailFolderInput;
}>;
export type UpdateCustomEmailFolderMutation = {
    __typename?: 'Mutation';
    updateCustomEmailFolder: {
        __typename?: 'EmailFolder';
        id: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        emailAddressId: string;
        folderName: string;
        size: number;
        unseenCount: number;
        ttl?: number | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        customFolderName?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type BlockEmailAddressesMutationVariables = Exact<{
    input: BlockEmailAddressesInput;
}>;
export type BlockEmailAddressesMutation = {
    __typename?: 'Mutation';
    blockEmailAddresses: {
        __typename?: 'BlockEmailAddressesBulkUpdateResult';
        status: UpdateEmailMessagesStatus;
        failedAddresses?: Array<string> | null;
        successAddresses?: Array<string> | null;
    };
};
export type UnblockEmailAddressesMutationVariables = Exact<{
    input: UnblockEmailAddressesInput;
}>;
export type UnblockEmailAddressesMutation = {
    __typename?: 'Mutation';
    unblockEmailAddresses: {
        __typename?: 'BlockEmailAddressesBulkUpdateResult';
        status: UpdateEmailMessagesStatus;
        failedAddresses?: Array<string> | null;
        successAddresses?: Array<string> | null;
    };
};
export type DeleteMessagesByFolderIdMutationVariables = Exact<{
    input: DeleteMessagesByFolderIdInput;
}>;
export type DeleteMessagesByFolderIdMutation = {
    __typename?: 'Mutation';
    deleteMessagesByFolderId: string;
};
export type ScheduleSendDraftMessageMutationVariables = Exact<{
    input: ScheduleSendDraftMessageInput;
}>;
export type ScheduleSendDraftMessageMutation = {
    __typename?: 'Mutation';
    scheduleSendDraftMessage: {
        __typename?: 'ScheduledDraftMessage';
        draftMessageKey: string;
        emailAddressId: string;
        sendAtEpochMs: number;
        state: ScheduledDraftMessageState;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owner: string;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
    };
};
export type CancelScheduledDraftMessageMutationVariables = Exact<{
    input: CancelScheduledDraftMessageInput;
}>;
export type CancelScheduledDraftMessageMutation = {
    __typename?: 'Mutation';
    cancelScheduledDraftMessage: string;
};
export type ProvisionEmailMaskMutationVariables = Exact<{
    input: ProvisionEmailMaskInput;
}>;
export type ProvisionEmailMaskMutation = {
    __typename?: 'Mutation';
    provisionEmailMask: {
        __typename?: 'EmailMask';
        id: string;
        owner: string;
        keyRingId: string;
        identityId: string;
        maskAddress: string;
        realAddress: string;
        realAddressType: EmailMaskRealAddressType;
        status: EmailMaskStatus;
        inboundReceived: number;
        inboundDelivered: number;
        outboundReceived: number;
        outboundDelivered: number;
        spamCount: number;
        virusCount: number;
        expiresAtEpochSec?: number | null;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        metadata?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type DeprovisionEmailMaskMutationVariables = Exact<{
    input: DeprovisionEmailMaskInput;
}>;
export type DeprovisionEmailMaskMutation = {
    __typename?: 'Mutation';
    deprovisionEmailMask: {
        __typename?: 'EmailMask';
        id: string;
        owner: string;
        keyRingId: string;
        identityId: string;
        maskAddress: string;
        realAddress: string;
        realAddressType: EmailMaskRealAddressType;
        status: EmailMaskStatus;
        inboundReceived: number;
        inboundDelivered: number;
        outboundReceived: number;
        outboundDelivered: number;
        spamCount: number;
        virusCount: number;
        expiresAtEpochSec?: number | null;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        metadata?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type UpdateEmailMaskMutationVariables = Exact<{
    input: UpdateEmailMaskInput;
}>;
export type UpdateEmailMaskMutation = {
    __typename?: 'Mutation';
    updateEmailMask: {
        __typename?: 'EmailMask';
        id: string;
        owner: string;
        keyRingId: string;
        identityId: string;
        maskAddress: string;
        realAddress: string;
        realAddressType: EmailMaskRealAddressType;
        status: EmailMaskStatus;
        inboundReceived: number;
        inboundDelivered: number;
        outboundReceived: number;
        outboundDelivered: number;
        spamCount: number;
        virusCount: number;
        expiresAtEpochSec?: number | null;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        metadata?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type EnableEmailMaskMutationVariables = Exact<{
    input: EnableEmailMaskInput;
}>;
export type EnableEmailMaskMutation = {
    __typename?: 'Mutation';
    enableEmailMask: {
        __typename?: 'EmailMask';
        id: string;
        owner: string;
        keyRingId: string;
        identityId: string;
        maskAddress: string;
        realAddress: string;
        realAddressType: EmailMaskRealAddressType;
        status: EmailMaskStatus;
        inboundReceived: number;
        inboundDelivered: number;
        outboundReceived: number;
        outboundDelivered: number;
        spamCount: number;
        virusCount: number;
        expiresAtEpochSec?: number | null;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        metadata?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type DisableEmailMaskMutationVariables = Exact<{
    input: DisableEmailMaskInput;
}>;
export type DisableEmailMaskMutation = {
    __typename?: 'Mutation';
    disableEmailMask: {
        __typename?: 'EmailMask';
        id: string;
        owner: string;
        keyRingId: string;
        identityId: string;
        maskAddress: string;
        realAddress: string;
        realAddressType: EmailMaskRealAddressType;
        status: EmailMaskStatus;
        inboundReceived: number;
        inboundDelivered: number;
        outboundReceived: number;
        outboundDelivered: number;
        spamCount: number;
        virusCount: number;
        expiresAtEpochSec?: number | null;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        metadata?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    };
};
export type SendMaskedEmailMessageMutationVariables = Exact<{
    input: SendMaskedEmailMessageInput;
}>;
export type SendMaskedEmailMessageMutation = {
    __typename?: 'Mutation';
    sendMaskedEmailMessage: {
        __typename?: 'SendEmailMessageResult';
        id: string;
        createdAtEpochMs: number;
    };
};
export type VerifyExternalEmailAddressMutationVariables = Exact<{
    input: VerifyExternalEmailAddressInput;
}>;
export type VerifyExternalEmailAddressMutation = {
    __typename?: 'Mutation';
    verifyExternalEmailAddress: {
        __typename?: 'VerifyExternalEmailAddressResult';
        isVerified: boolean;
        reason?: string | null;
    };
};
export type CreatePublicKeyForEmailMutationVariables = Exact<{
    input: CreatePublicKeyInput;
}>;
export type CreatePublicKeyForEmailMutation = {
    __typename?: 'Mutation';
    createPublicKeyForEmail: {
        __typename?: 'PublicKey';
        id: string;
        keyId: string;
        keyRingId: string;
        algorithm: string;
        keyFormat: KeyFormat;
        publicKey: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
    };
};
export type GetEmailConfigQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetEmailConfigQuery = {
    __typename?: 'Query';
    getEmailConfig: {
        __typename?: 'EmailConfigurationData';
        deleteEmailMessagesLimit: number;
        updateEmailMessagesLimit: number;
        emailMessageMaxInboundMessageSize: number;
        emailMessageMaxOutboundMessageSize: number;
        emailMessageRecipientsLimit: number;
        encryptedEmailMessageRecipientsLimit: number;
        sendEncryptedEmailEnabled: boolean;
        prohibitedFileExtensions: Array<string>;
        emailMasksEnabled: boolean;
        externalEmailMasksEnabled: boolean;
    };
};
export type GetEmailDomainsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetEmailDomainsQuery = {
    __typename?: 'Query';
    getEmailDomains: {
        __typename?: 'SupportedDomains';
        domains: Array<string>;
    };
};
export type GetConfiguredEmailDomainsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetConfiguredEmailDomainsQuery = {
    __typename?: 'Query';
    getConfiguredEmailDomains: {
        __typename?: 'ConfiguredDomains';
        domains: Array<string>;
    };
};
export type GetEmailMaskDomainsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetEmailMaskDomainsQuery = {
    __typename?: 'Query';
    getEmailMaskDomains: {
        __typename?: 'EmailMaskDomains';
        domains: Array<string>;
    };
};
export type CheckEmailAddressAvailabilityQueryVariables = Exact<{
    input: CheckEmailAddressAvailabilityInput;
}>;
export type CheckEmailAddressAvailabilityQuery = {
    __typename?: 'Query';
    checkEmailAddressAvailability: {
        __typename?: 'AvailableAddresses';
        addresses: Array<string>;
    };
};
export type GetEmailAddressQueryVariables = Exact<{
    id: Scalars['String']['input'];
}>;
export type GetEmailAddressQuery = {
    __typename?: 'Query';
    getEmailAddress?: {
        __typename?: 'EmailAddress';
        id: string;
        owner: string;
        identityId: string;
        keyRingId: string;
        keyIds: Array<string>;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        lastReceivedAtEpochMs?: number | null;
        emailAddress: string;
        size: number;
        numberOfEmailMessages: number;
        folders: Array<{
            __typename?: 'EmailFolder';
            id: string;
            owner: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            emailAddressId: string;
            folderName: string;
            size: number;
            unseenCount: number;
            ttl?: number | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            customFolderName?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        alias?: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        } | null;
    } | null;
};
export type ListEmailAddressesQueryVariables = Exact<{
    input: ListEmailAddressesInput;
}>;
export type ListEmailAddressesQuery = {
    __typename?: 'Query';
    listEmailAddresses: {
        __typename?: 'EmailAddressConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'EmailAddress';
            id: string;
            owner: string;
            identityId: string;
            keyRingId: string;
            keyIds: Array<string>;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            lastReceivedAtEpochMs?: number | null;
            emailAddress: string;
            size: number;
            numberOfEmailMessages: number;
            folders: Array<{
                __typename?: 'EmailFolder';
                id: string;
                owner: string;
                version: number;
                createdAtEpochMs: number;
                updatedAtEpochMs: number;
                emailAddressId: string;
                folderName: string;
                size: number;
                unseenCount: number;
                ttl?: number | null;
                owners: Array<{
                    __typename?: 'Owner';
                    id: string;
                    issuer: string;
                }>;
                customFolderName?: {
                    __typename?: 'SealedAttribute';
                    algorithm: string;
                    keyId: string;
                    plainTextType: string;
                    base64EncodedSealedData: string;
                } | null;
            }>;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            alias?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
    };
};
export type ListEmailAddressesForSudoIdQueryVariables = Exact<{
    input: ListEmailAddressesForSudoIdInput;
}>;
export type ListEmailAddressesForSudoIdQuery = {
    __typename?: 'Query';
    listEmailAddressesForSudoId: {
        __typename?: 'EmailAddressConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'EmailAddress';
            id: string;
            owner: string;
            identityId: string;
            keyRingId: string;
            keyIds: Array<string>;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            lastReceivedAtEpochMs?: number | null;
            emailAddress: string;
            size: number;
            numberOfEmailMessages: number;
            folders: Array<{
                __typename?: 'EmailFolder';
                id: string;
                owner: string;
                version: number;
                createdAtEpochMs: number;
                updatedAtEpochMs: number;
                emailAddressId: string;
                folderName: string;
                size: number;
                unseenCount: number;
                ttl?: number | null;
                owners: Array<{
                    __typename?: 'Owner';
                    id: string;
                    issuer: string;
                }>;
                customFolderName?: {
                    __typename?: 'SealedAttribute';
                    algorithm: string;
                    keyId: string;
                    plainTextType: string;
                    base64EncodedSealedData: string;
                } | null;
            }>;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            alias?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
    };
};
export type LookupEmailAddressesPublicInfoQueryVariables = Exact<{
    input: LookupEmailAddressesPublicInfoInput;
}>;
export type LookupEmailAddressesPublicInfoQuery = {
    __typename?: 'Query';
    lookupEmailAddressesPublicInfo: {
        __typename?: 'LookupEmailAddressesPublicInfoResponse';
        items: Array<{
            __typename?: 'EmailAddressPublicInfo';
            emailAddress: string;
            keyId: string;
            publicKey: string;
            enableEncryption?: boolean | null;
            publicKeyDetails: {
                __typename?: 'EmailAddressPublicKey';
                publicKey: string;
                keyFormat: KeyFormat;
                algorithm: string;
            };
        }>;
    };
};
export type ListEmailFoldersForEmailAddressIdQueryVariables = Exact<{
    input: ListEmailFoldersForEmailAddressIdInput;
}>;
export type ListEmailFoldersForEmailAddressIdQuery = {
    __typename?: 'Query';
    listEmailFoldersForEmailAddressId: {
        __typename?: 'EmailFolderConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'EmailFolder';
            id: string;
            owner: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            emailAddressId: string;
            folderName: string;
            size: number;
            unseenCount: number;
            ttl?: number | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            customFolderName?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
    };
};
export type GetEmailMessageQueryVariables = Exact<{
    id: Scalars['ID']['input'];
}>;
export type GetEmailMessageQuery = {
    __typename?: 'Query';
    getEmailMessage?: {
        __typename?: 'SealedEmailMessage';
        id: string;
        owner: string;
        emailAddressId: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        sortDateEpochMs: number;
        folderId: string;
        previousFolderId?: string | null;
        direction: EmailMessageDirection;
        seen: boolean;
        repliedTo: boolean;
        forwarded: boolean;
        state: EmailMessageState;
        clientRefId?: string | null;
        size: number;
        encryptionStatus?: EmailMessageEncryptionStatus | null;
        emailMaskId?: string | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        rfc822Header: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        };
        rfc822DataAttributes: {
            __typename?: 'Rfc822DataAttributesType';
            key: string;
            bucket: string;
        };
    } | null;
};
export type ListEmailMessagesQueryVariables = Exact<{
    input: ListEmailMessagesInput;
}>;
export type ListEmailMessagesQuery = {
    __typename?: 'Query';
    listEmailMessages: {
        __typename?: 'EmailMessageConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'SealedEmailMessage';
            id: string;
            owner: string;
            emailAddressId: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            sortDateEpochMs: number;
            folderId: string;
            previousFolderId?: string | null;
            direction: EmailMessageDirection;
            seen: boolean;
            repliedTo: boolean;
            forwarded: boolean;
            state: EmailMessageState;
            clientRefId?: string | null;
            size: number;
            encryptionStatus?: EmailMessageEncryptionStatus | null;
            emailMaskId?: string | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            rfc822Header: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            };
            rfc822DataAttributes: {
                __typename?: 'Rfc822DataAttributesType';
                key: string;
                bucket: string;
            };
        }>;
    };
};
export type ListEmailMessagesForEmailAddressIdQueryVariables = Exact<{
    input: ListEmailMessagesForEmailAddressIdInput;
}>;
export type ListEmailMessagesForEmailAddressIdQuery = {
    __typename?: 'Query';
    listEmailMessagesForEmailAddressId: {
        __typename?: 'EmailMessageConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'SealedEmailMessage';
            id: string;
            owner: string;
            emailAddressId: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            sortDateEpochMs: number;
            folderId: string;
            previousFolderId?: string | null;
            direction: EmailMessageDirection;
            seen: boolean;
            repliedTo: boolean;
            forwarded: boolean;
            state: EmailMessageState;
            clientRefId?: string | null;
            size: number;
            encryptionStatus?: EmailMessageEncryptionStatus | null;
            emailMaskId?: string | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            rfc822Header: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            };
            rfc822DataAttributes: {
                __typename?: 'Rfc822DataAttributesType';
                key: string;
                bucket: string;
            };
        }>;
    };
};
export type ListEmailMessagesForEmailFolderIdQueryVariables = Exact<{
    input: ListEmailMessagesForEmailFolderIdInput;
}>;
export type ListEmailMessagesForEmailFolderIdQuery = {
    __typename?: 'Query';
    listEmailMessagesForEmailFolderId: {
        __typename?: 'EmailMessageConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'SealedEmailMessage';
            id: string;
            owner: string;
            emailAddressId: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            sortDateEpochMs: number;
            folderId: string;
            previousFolderId?: string | null;
            direction: EmailMessageDirection;
            seen: boolean;
            repliedTo: boolean;
            forwarded: boolean;
            state: EmailMessageState;
            clientRefId?: string | null;
            size: number;
            encryptionStatus?: EmailMessageEncryptionStatus | null;
            emailMaskId?: string | null;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            rfc822Header: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            };
            rfc822DataAttributes: {
                __typename?: 'Rfc822DataAttributesType';
                key: string;
                bucket: string;
            };
        }>;
    };
};
export type ListEmailMasksForOwnerQueryVariables = Exact<{
    input: ListEmailMasksForOwnerInput;
}>;
export type ListEmailMasksForOwnerQuery = {
    __typename?: 'Query';
    listEmailMasksForOwner: {
        __typename?: 'EmailMaskConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'EmailMask';
            id: string;
            owner: string;
            keyRingId: string;
            identityId: string;
            maskAddress: string;
            realAddress: string;
            realAddressType: EmailMaskRealAddressType;
            status: EmailMaskStatus;
            inboundReceived: number;
            inboundDelivered: number;
            outboundReceived: number;
            outboundDelivered: number;
            spamCount: number;
            virusCount: number;
            expiresAtEpochSec?: number | null;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
            metadata?: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            } | null;
        }>;
    };
};
export type GetKeyRingForEmailQueryVariables = Exact<{
    keyRingId: Scalars['String']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
}>;
export type GetKeyRingForEmailQuery = {
    __typename?: 'Query';
    getKeyRingForEmail: {
        __typename?: 'PaginatedPublicKey';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'PublicKey';
            id: string;
            keyId: string;
            keyRingId: string;
            algorithm: string;
            keyFormat: KeyFormat;
            publicKey: string;
            owner: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
        }>;
    };
};
export type GetPublicKeyForEmailQueryVariables = Exact<{
    keyId: Scalars['String']['input'];
}>;
export type GetPublicKeyForEmailQuery = {
    __typename?: 'Query';
    getPublicKeyForEmail?: {
        __typename?: 'PublicKey';
        id: string;
        keyId: string;
        keyRingId: string;
        algorithm: string;
        keyFormat: KeyFormat;
        publicKey: string;
        owner: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
    } | null;
};
export type GetPublicKeysForEmailQueryVariables = Exact<{
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
}>;
export type GetPublicKeysForEmailQuery = {
    __typename?: 'Query';
    getPublicKeysForEmail: {
        __typename?: 'PaginatedPublicKey';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'PublicKey';
            id: string;
            keyId: string;
            keyRingId: string;
            algorithm: string;
            keyFormat: KeyFormat;
            publicKey: string;
            owner: string;
            version: number;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
        }>;
    };
};
export type GetEmailAddressBlocklistQueryVariables = Exact<{
    input: GetEmailAddressBlocklistInput;
}>;
export type GetEmailAddressBlocklistQuery = {
    __typename?: 'Query';
    getEmailAddressBlocklist: {
        __typename?: 'GetEmailAddressBlocklistResponse';
        blockedAddresses: Array<{
            __typename?: 'BlockedEmailAddress';
            hashedBlockedValue: string;
            action?: BlockedAddressAction | null;
            emailAddressId?: string | null;
            sealedValue: {
                __typename?: 'SealedAttribute';
                algorithm: string;
                keyId: string;
                plainTextType: string;
                base64EncodedSealedData: string;
            };
        }>;
    };
};
export type ListScheduledDraftMessagesForEmailAddressIdQueryVariables = Exact<{
    input: ListScheduledDraftMessagesForEmailAddressIdInput;
}>;
export type ListScheduledDraftMessagesForEmailAddressIdQuery = {
    __typename?: 'Query';
    listScheduledDraftMessagesForEmailAddressId: {
        __typename?: 'ScheduledDraftMessageConnection';
        nextToken?: string | null;
        items: Array<{
            __typename?: 'ScheduledDraftMessage';
            draftMessageKey: string;
            emailAddressId: string;
            sendAtEpochMs: number;
            state: ScheduledDraftMessageState;
            createdAtEpochMs: number;
            updatedAtEpochMs: number;
            owner: string;
            owners: Array<{
                __typename?: 'Owner';
                id: string;
                issuer: string;
            }>;
        }>;
    };
};
export type OnEmailMessageDeletedSubscriptionVariables = Exact<{
    owner: Scalars['ID']['input'];
}>;
export type OnEmailMessageDeletedSubscription = {
    __typename?: 'Subscription';
    onEmailMessageDeleted: {
        __typename?: 'SealedEmailMessage';
        id: string;
        owner: string;
        emailAddressId: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        sortDateEpochMs: number;
        folderId: string;
        previousFolderId?: string | null;
        direction: EmailMessageDirection;
        seen: boolean;
        repliedTo: boolean;
        forwarded: boolean;
        state: EmailMessageState;
        clientRefId?: string | null;
        size: number;
        encryptionStatus?: EmailMessageEncryptionStatus | null;
        emailMaskId?: string | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        rfc822Header: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        };
        rfc822DataAttributes: {
            __typename?: 'Rfc822DataAttributesType';
            key: string;
            bucket: string;
        };
    };
};
export type OnEmailMessageCreatedSubscriptionVariables = Exact<{
    owner: Scalars['ID']['input'];
}>;
export type OnEmailMessageCreatedSubscription = {
    __typename?: 'Subscription';
    onEmailMessageCreated: {
        __typename?: 'SealedEmailMessage';
        id: string;
        owner: string;
        emailAddressId: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        sortDateEpochMs: number;
        folderId: string;
        previousFolderId?: string | null;
        direction: EmailMessageDirection;
        seen: boolean;
        repliedTo: boolean;
        forwarded: boolean;
        state: EmailMessageState;
        clientRefId?: string | null;
        size: number;
        encryptionStatus?: EmailMessageEncryptionStatus | null;
        emailMaskId?: string | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        rfc822Header: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        };
        rfc822DataAttributes: {
            __typename?: 'Rfc822DataAttributesType';
            key: string;
            bucket: string;
        };
    };
};
export type OnEmailMessageUpdatedSubscriptionVariables = Exact<{
    owner: Scalars['ID']['input'];
}>;
export type OnEmailMessageUpdatedSubscription = {
    __typename?: 'Subscription';
    onEmailMessageUpdated: {
        __typename?: 'SealedEmailMessage';
        id: string;
        owner: string;
        emailAddressId: string;
        version: number;
        createdAtEpochMs: number;
        updatedAtEpochMs: number;
        sortDateEpochMs: number;
        folderId: string;
        previousFolderId?: string | null;
        direction: EmailMessageDirection;
        seen: boolean;
        repliedTo: boolean;
        forwarded: boolean;
        state: EmailMessageState;
        clientRefId?: string | null;
        size: number;
        encryptionStatus?: EmailMessageEncryptionStatus | null;
        emailMaskId?: string | null;
        owners: Array<{
            __typename?: 'Owner';
            id: string;
            issuer: string;
        }>;
        rfc822Header: {
            __typename?: 'SealedAttribute';
            algorithm: string;
            keyId: string;
            plainTextType: string;
            base64EncodedSealedData: string;
        };
        rfc822DataAttributes: {
            __typename?: 'Rfc822DataAttributesType';
            key: string;
            bucket: string;
        };
    };
};
export declare const SealedAttributeFragmentDoc: DocumentNode<SealedAttributeFragment, unknown>;
export declare const BlockedAddressFragmentDoc: DocumentNode<BlockedAddressFragment, unknown>;
export declare const BlockAddressesResultFragmentDoc: DocumentNode<BlockAddressesResultFragment, unknown>;
export declare const GetEmailAddressBlocklistResponseFragmentDoc: DocumentNode<GetEmailAddressBlocklistResponseFragment, unknown>;
export declare const EmailAddressWithoutFoldersFragmentDoc: DocumentNode<EmailAddressWithoutFoldersFragment, unknown>;
export declare const EmailFolderFragmentDoc: DocumentNode<EmailFolderFragment, unknown>;
export declare const EmailAddressFragmentDoc: DocumentNode<EmailAddressFragment, unknown>;
export declare const EmailAddressPublicKeyFragmentDoc: DocumentNode<EmailAddressPublicKeyFragment, unknown>;
export declare const EmailAddressPublicInfoFragmentDoc: DocumentNode<EmailAddressPublicInfoFragment, unknown>;
export declare const EmailConfigurationDataFragmentDoc: DocumentNode<EmailConfigurationDataFragment, unknown>;
export declare const EmailMaskFragmentDoc: DocumentNode<EmailMaskFragment, unknown>;
export declare const OwnerFragmentDoc: DocumentNode<OwnerFragment, unknown>;
export declare const PublicKeyFragmentDoc: DocumentNode<PublicKeyFragment, unknown>;
export declare const PaginatedPublicKeyFragmentDoc: DocumentNode<PaginatedPublicKeyFragment, unknown>;
export declare const ScheduledDraftMessageFragmentDoc: DocumentNode<ScheduledDraftMessageFragment, unknown>;
export declare const SealedEmailMessageFragmentDoc: DocumentNode<SealedEmailMessageFragment, unknown>;
export declare const SendEmailMessageResultFragmentDoc: DocumentNode<SendEmailMessageResultFragment, unknown>;
export declare const UpdateEmailMessagesResultFragmentDoc: DocumentNode<UpdateEmailMessagesResultFragment, unknown>;
export declare const VerifyExternalEmailAddressResultFragmentDoc: DocumentNode<VerifyExternalEmailAddressResultFragment, unknown>;
export declare const DeleteEmailMessagesDocument: DocumentNode<DeleteEmailMessagesMutation, DeleteEmailMessagesMutationVariables>;
export declare const ProvisionEmailAddressDocument: DocumentNode<ProvisionEmailAddressMutation, ProvisionEmailAddressMutationVariables>;
export declare const DeprovisionEmailAddressDocument: DocumentNode<DeprovisionEmailAddressMutation, DeprovisionEmailAddressMutationVariables>;
export declare const UpdateEmailAddressMetadataDocument: DocumentNode<UpdateEmailAddressMetadataMutation, UpdateEmailAddressMetadataMutationVariables>;
export declare const SendEmailMessageDocument: DocumentNode<SendEmailMessageMutation, SendEmailMessageMutationVariables>;
export declare const SendEncryptedEmailMessageDocument: DocumentNode<SendEncryptedEmailMessageMutation, SendEncryptedEmailMessageMutationVariables>;
export declare const UpdateEmailMessagesDocument: DocumentNode<UpdateEmailMessagesMutation, UpdateEmailMessagesMutationVariables>;
export declare const DeleteEmailMessageDocument: DocumentNode<DeleteEmailMessageMutation, DeleteEmailMessageMutationVariables>;
export declare const CreateCustomEmailFolderDocument: DocumentNode<CreateCustomEmailFolderMutation, CreateCustomEmailFolderMutationVariables>;
export declare const DeleteCustomEmailFolderDocument: DocumentNode<DeleteCustomEmailFolderMutation, DeleteCustomEmailFolderMutationVariables>;
export declare const UpdateCustomEmailFolderDocument: DocumentNode<UpdateCustomEmailFolderMutation, UpdateCustomEmailFolderMutationVariables>;
export declare const BlockEmailAddressesDocument: DocumentNode<BlockEmailAddressesMutation, BlockEmailAddressesMutationVariables>;
export declare const UnblockEmailAddressesDocument: DocumentNode<UnblockEmailAddressesMutation, UnblockEmailAddressesMutationVariables>;
export declare const DeleteMessagesByFolderIdDocument: DocumentNode<DeleteMessagesByFolderIdMutation, DeleteMessagesByFolderIdMutationVariables>;
export declare const ScheduleSendDraftMessageDocument: DocumentNode<ScheduleSendDraftMessageMutation, ScheduleSendDraftMessageMutationVariables>;
export declare const CancelScheduledDraftMessageDocument: DocumentNode<CancelScheduledDraftMessageMutation, CancelScheduledDraftMessageMutationVariables>;
export declare const ProvisionEmailMaskDocument: DocumentNode<ProvisionEmailMaskMutation, ProvisionEmailMaskMutationVariables>;
export declare const DeprovisionEmailMaskDocument: DocumentNode<DeprovisionEmailMaskMutation, DeprovisionEmailMaskMutationVariables>;
export declare const UpdateEmailMaskDocument: DocumentNode<UpdateEmailMaskMutation, UpdateEmailMaskMutationVariables>;
export declare const EnableEmailMaskDocument: DocumentNode<EnableEmailMaskMutation, EnableEmailMaskMutationVariables>;
export declare const DisableEmailMaskDocument: DocumentNode<DisableEmailMaskMutation, DisableEmailMaskMutationVariables>;
export declare const SendMaskedEmailMessageDocument: DocumentNode<SendMaskedEmailMessageMutation, SendMaskedEmailMessageMutationVariables>;
export declare const VerifyExternalEmailAddressDocument: DocumentNode<VerifyExternalEmailAddressMutation, VerifyExternalEmailAddressMutationVariables>;
export declare const CreatePublicKeyForEmailDocument: DocumentNode<CreatePublicKeyForEmailMutation, CreatePublicKeyForEmailMutationVariables>;
export declare const GetEmailConfigDocument: DocumentNode<GetEmailConfigQuery, GetEmailConfigQueryVariables>;
export declare const GetEmailDomainsDocument: DocumentNode<GetEmailDomainsQuery, GetEmailDomainsQueryVariables>;
export declare const GetConfiguredEmailDomainsDocument: DocumentNode<GetConfiguredEmailDomainsQuery, GetConfiguredEmailDomainsQueryVariables>;
export declare const GetEmailMaskDomainsDocument: DocumentNode<GetEmailMaskDomainsQuery, GetEmailMaskDomainsQueryVariables>;
export declare const CheckEmailAddressAvailabilityDocument: DocumentNode<CheckEmailAddressAvailabilityQuery, CheckEmailAddressAvailabilityQueryVariables>;
export declare const GetEmailAddressDocument: DocumentNode<GetEmailAddressQuery, GetEmailAddressQueryVariables>;
export declare const ListEmailAddressesDocument: DocumentNode<ListEmailAddressesQuery, ListEmailAddressesQueryVariables>;
export declare const ListEmailAddressesForSudoIdDocument: DocumentNode<ListEmailAddressesForSudoIdQuery, ListEmailAddressesForSudoIdQueryVariables>;
export declare const LookupEmailAddressesPublicInfoDocument: DocumentNode<LookupEmailAddressesPublicInfoQuery, LookupEmailAddressesPublicInfoQueryVariables>;
export declare const ListEmailFoldersForEmailAddressIdDocument: DocumentNode<ListEmailFoldersForEmailAddressIdQuery, ListEmailFoldersForEmailAddressIdQueryVariables>;
export declare const GetEmailMessageDocument: DocumentNode<GetEmailMessageQuery, GetEmailMessageQueryVariables>;
export declare const ListEmailMessagesDocument: DocumentNode<ListEmailMessagesQuery, ListEmailMessagesQueryVariables>;
export declare const ListEmailMessagesForEmailAddressIdDocument: DocumentNode<ListEmailMessagesForEmailAddressIdQuery, ListEmailMessagesForEmailAddressIdQueryVariables>;
export declare const ListEmailMessagesForEmailFolderIdDocument: DocumentNode<ListEmailMessagesForEmailFolderIdQuery, ListEmailMessagesForEmailFolderIdQueryVariables>;
export declare const ListEmailMasksForOwnerDocument: DocumentNode<ListEmailMasksForOwnerQuery, ListEmailMasksForOwnerQueryVariables>;
export declare const GetKeyRingForEmailDocument: DocumentNode<GetKeyRingForEmailQuery, GetKeyRingForEmailQueryVariables>;
export declare const GetPublicKeyForEmailDocument: DocumentNode<GetPublicKeyForEmailQuery, GetPublicKeyForEmailQueryVariables>;
export declare const GetPublicKeysForEmailDocument: DocumentNode<GetPublicKeysForEmailQuery, GetPublicKeysForEmailQueryVariables>;
export declare const GetEmailAddressBlocklistDocument: DocumentNode<GetEmailAddressBlocklistQuery, GetEmailAddressBlocklistQueryVariables>;
export declare const ListScheduledDraftMessagesForEmailAddressIdDocument: DocumentNode<ListScheduledDraftMessagesForEmailAddressIdQuery, ListScheduledDraftMessagesForEmailAddressIdQueryVariables>;
export declare const OnEmailMessageDeletedDocument: DocumentNode<OnEmailMessageDeletedSubscription, OnEmailMessageDeletedSubscriptionVariables>;
export declare const OnEmailMessageCreatedDocument: DocumentNode<OnEmailMessageCreatedSubscription, OnEmailMessageCreatedSubscriptionVariables>;
export declare const OnEmailMessageUpdatedDocument: DocumentNode<OnEmailMessageUpdatedSubscription, OnEmailMessageUpdatedSubscriptionVariables>;