signald-types.ts

// doc_version: v1
// signald version: 0.14.1
// signald commit: 227706969ee084c4e06b424bdf0a95a43bdeb051

// v1 protocol
export namespace v1 {
    /**
     * Accept a v2 group invitation. Note that you must have a profile name set to join groups.
     */
    export interface AcceptInvitationRequest {
        account: string;
        groupID: string;
    }

    /**
     * A local account in signald
     */
    export interface Account {
        address?: JsonAddress;
        device_id?: number;
        account_id?: string;
    }

    /**
     * v1.AccountList
     */
    export interface AccountList {
        accounts?: (Account)[];
    }

    /**
     * Link a new device to a local Signal account
     */
    export interface AddLinkedDeviceRequest {
        account: string;
        uri: string;
    }

    /**
     * add a new server to connect to. Returns the new server's UUID.
     */
    export interface AddServerRequest {
        server: Server;
    }

    /**
     * v1.AllIdentityKeyList
     */
    export interface AllIdentityKeyList {
        identity_keys?: (IdentityKeyList)[];
    }

    /**
     * v1.AnswerMessage
     */
    export interface AnswerMessage {
        id?: number;
        sdp?: string;
        opaque?: string;
    }

    /**
     * approve a request to join a group
     */
    export interface ApproveMembershipRequest {
        account: string;
        groupID: string;
        members: (JsonAddress)[];
    }

    /**
     * v1.BusyMessage
     */
    export interface BusyMessage {
        id?: number;
    }

    /**
     * v1.CallMessage
     */
    export interface CallMessage {
        offer_message?: OfferMessage;
        answer_message?: AnswerMessage;
        busy_message?: BusyMessage;
        hangup_message?: HangupMessage;
        ice_update_message?: (IceUpdateMessage)[];
        destination_device_id?: number;
        multi_ring?: boolean;
    }

    /**
     * v1.Capabilities
     */
    export interface Capabilities {
        gv2?: boolean;
        storage?: boolean;
        "gv1-migration"?: boolean;
    }

    /**
     * Wraps all incoming messages after a v1 subscribe request is issued
     */
    export interface ClientMessageWrapper {
        type?: string;
        version?: string;
        data?: object;
        error?: boolean;
    }

    /**
     * v1.CreateGroupRequest
     */
    export interface CreateGroupRequest {
        account: string;
        title: string;
        avatar?: string;
        members: (JsonAddress)[];
        timer?: number;
        member_role?: string;
    }

    /**
     * delete all account data signald has on disk, and optionally delete the account from the server as well. Note that this is not "unlink" and will delete the entire account, even from a linked device.
     */
    export interface DeleteAccountRequest {
        account: string;
        server?: boolean;
    }

    /**
     * v1.DeviceInfo
     */
    export interface DeviceInfo {
        id?: number;
        name?: string;
        created?: number;
        lastSeen?: number;
    }

    /**
     * After a linking URI has been requested, finish_link must be called with the session_id provided with the URI. it will return information about the new account once the linking process is completed by the other device.
     */
    export interface FinishLinkRequest {
        device_name?: string;
        session_id?: string;
    }

    /**
     * Generate a linking URI. Typically this is QR encoded and scanned by the primary device. Submit the returned session_id with a finish_link request.
     */
    export interface GenerateLinkingURIRequest {
        server?: string;
    }

    /**
     * get all known identity keys
     */
    export interface GetAllIdentities {
        account: string;
    }

    /**
     * Query the server for the latest state of a known group. If no account in signald is a member of the group (anymore), an error with error_type: 'UnknownGroupException' is returned.
     */
    export interface GetGroupRequest {
        account: string;
        groupID: string;
        revision?: number;
    }

    /**
     * Get information about a known keys for a particular address
     */
    export interface GetIdentitiesRequest {
        account: string;
        address: JsonAddress;
    }

    /**
     * list all linked devices on a Signal account
     */
    export interface GetLinkedDevicesRequest {
        account: string;
    }

    /**
     * Get all information available about a user
     */
    export interface GetProfileRequest {
        account: string;
        async?: boolean;
        address: JsonAddress;
    }

    /**
     * v1.GetServersRequest
     */
    export interface GetServersRequest {
    }

    /**
     * group access control settings. Options for each controlled action are: UNKNOWN, ANY, MEMBER, ADMINISTRATOR, UNSATISFIABLE and UNRECOGNIZED
     */
    export interface GroupAccessControl {
        link?: string;
        attributes?: string;
        members?: string;
    }

    /**
     * A generic type that is used when the group version is not known
     */
    export interface GroupInfo {
        v1?: JsonGroupInfo;
        v2?: JsonGroupV2Info;
    }

    /**
     * Get information about a group from a signal.group link
     */
    export interface GroupLinkInfoRequest {
        account: string;
        uri: string;
    }

    /**
     * v1.GroupList
     */
    export interface GroupList {
        groups?: (JsonGroupV2Info)[];
        legacyGroups?: (JsonGroupInfo)[];
    }

    /**
     * v1.GroupMember
     */
    export interface GroupMember {
        uuid?: string;
        role?: string;
        joined_revision?: number;
    }

    /**
     * v1.HangupMessage
     */
    export interface HangupMessage {
        id?: number;
        type?: string;
        legacy?: boolean;
        device_id?: number;
    }

    /**
     * v1.IceUpdateMessage
     */
    export interface IceUpdateMessage {
        id?: number;
        opaque?: string;
        sdp?: string;
    }

    /**
     * v1.IdentityKey
     */
    export interface IdentityKey {
        added?: number;
        safety_number?: string;
        qr_code_data?: string;
        trust_level?: string;
    }

    /**
     * a list of identity keys associated with a particular address
     */
    export interface IdentityKeyList {
        address?: JsonAddress;
        identities?: (IdentityKey)[];
    }

    /**
     * v1.IncomingMessage
     */
    export interface IncomingMessage {
        account?: string;
        source?: JsonAddress;
        type?: string;
        timestamp?: number;
        source_device?: number;
        server_receiver_timestamp?: number;
        server_deliver_timestamp?: number;
        has_legacy_message?: boolean;
        has_content?: boolean;
        unidentified_sender?: boolean;
        data_message?: JsonDataMessage;
        sync_message?: JsonSyncMessage;
        call_message?: CallMessage;
        receipt_message?: ReceiptMessage;
        typing_message?: TypingMessage;
        server_guid?: string;
    }

    /**
     * Join a group using the a signal.group URL. Note that you must have a profile name set to join groups.
     */
    export interface JoinGroupRequest {
        account: string;
        uri: string;
    }

    /**
     * v1.JsonAddress
     */
    export interface JsonAddress {
        number?: string;
        uuid?: string;
        relay?: string;
    }

    /**
     * v1.JsonBlockedListMessage
     */
    export interface JsonBlockedListMessage {
        addresses?: (JsonAddress)[];
        groupIds?: string[];
    }

    /**
     * v1.JsonDataMessage
     */
    export interface JsonDataMessage {
        timestamp?: number;
        attachments?: (v0.JsonAttachment)[];
        body?: string;
        group?: JsonGroupInfo;
        groupV2?: JsonGroupV2Info;
        endSession?: boolean;
        expiresInSeconds?: number;
        profileKeyUpdate?: boolean;
        quote?: JsonQuote;
        contacts?: (v0.SharedContact)[];
        previews?: (v0.JsonPreview)[];
        sticker?: v0.JsonSticker;
        viewOnce?: boolean;
        reaction?: JsonReaction;
        remoteDelete?: RemoteDelete;
        mentions?: (JsonMention)[];
        payment?: Payment;
        group_call_update?: string;
    }

    /**
     * information about a legacy group
     */
    export interface JsonGroupInfo {
        groupId?: string;
        members?: (JsonAddress)[];
        name?: string;
        type?: string;
        avatarId?: number;
    }

    /**
     * v1.JsonGroupJoinInfo
     */
    export interface JsonGroupJoinInfo {
        groupID?: string;
        title?: string;
        memberCount?: number;
        addFromInviteLink?: number;
        revision?: number;
        pendingAdminApproval?: boolean;
    }

    /**
     * Information about a Signal group
     */
    export interface JsonGroupV2Info {
        id?: string;
        revision?: number;
        title?: string;
        description?: string;
        avatar?: string;
        timer?: number;
        members?: (JsonAddress)[];
        pendingMembers?: (JsonAddress)[];
        requestingMembers?: (JsonAddress)[];
        inviteLink?: string;
        accessControl?: GroupAccessControl;
        memberDetail?: (GroupMember)[];
        pendingMemberDetail?: (GroupMember)[];
    }

    /**
     * v1.JsonMention
     */
    export interface JsonMention {
        uuid?: string;
        start?: number;
        length?: number;
    }

    /**
     * v1.JsonMessageEnvelope
     */
    export interface JsonMessageEnvelope {
        username?: string;
        uuid?: string;
        source?: JsonAddress;
        sourceDevice?: number;
        type?: string;
        relay?: string;
        timestamp?: number;
        timestampISO?: string;
        serverTimestamp?: number;
        serverDeliveredTimestamp?: number;
        hasLegacyMessage?: boolean;
        hasContent?: boolean;
        isUnidentifiedSender?: boolean;
        dataMessage?: JsonDataMessage;
        syncMessage?: JsonSyncMessage;
        callMessage?: v0.JsonCallMessage;
        receipt?: v0.JsonReceiptMessage;
        typing?: v0.JsonTypingMessage;
    }

    /**
     * v1.JsonMessageRequestResponseMessage
     */
    export interface JsonMessageRequestResponseMessage {
        person?: JsonAddress;
        groupId?: string;
        type?: string;
    }

    /**
     * A quote is a reply to a previous message. ID is the sent time of the message being replied to
     */
    export interface JsonQuote {
        id?: number;
        author?: JsonAddress;
        text?: string;
        attachments?: (v0.JsonQuotedAttachment)[];
        mentions?: (JsonMention)[];
    }

    /**
     * v1.JsonReaction
     */
    export interface JsonReaction {
        emoji?: string;
        remove?: boolean;
        targetAuthor?: JsonAddress;
        targetSentTimestamp?: number;
    }

    /**
     * v1.JsonReadMessage
     */
    export interface JsonReadMessage {
        sender?: JsonAddress;
        timestamp?: number;
    }

    /**
     * v1.JsonSendMessageResult
     */
    export interface JsonSendMessageResult {
        address?: JsonAddress;
        success?: v0.Success;
        networkFailure?: boolean;
        unregisteredFailure?: boolean;
        identityFailure?: string;
    }

    /**
     * v1.JsonSentTranscriptMessage
     */
    export interface JsonSentTranscriptMessage {
        destination?: JsonAddress;
        timestamp?: number;
        expirationStartTimestamp?: number;
        message?: JsonDataMessage;
        unidentifiedStatus?: string;
        isRecipientUpdate?: boolean;
    }

    /**
     * v1.JsonSyncMessage
     */
    export interface JsonSyncMessage {
        sent?: JsonSentTranscriptMessage;
        contacts?: v0.JsonAttachment;
        contactsComplete?: boolean;
        groups?: v0.JsonAttachment;
        blockedList?: JsonBlockedListMessage;
        request?: string;
        readMessages?: (JsonReadMessage)[];
        viewOnceOpen?: JsonViewOnceOpenMessage;
        verified?: JsonVerifiedMessage;
        configuration?: v0.ConfigurationMessage;
        stickerPackOperations?: (v0.JsonStickerPackOperationMessage)[];
        fetchType?: string;
        messageRequestResponse?: JsonMessageRequestResponseMessage;
    }

    /**
     * v1.JsonVerifiedMessage
     */
    export interface JsonVerifiedMessage {
        destination?: JsonAddress;
        identityKey?: string;
        verified?: string;
        timestamp?: number;
    }

    /**
     * v1.JsonVersionMessage
     */
    export interface JsonVersionMessage {
        name?: string;
        version?: string;
        branch?: string;
        commit?: string;
    }

    /**
     * v1.JsonViewOnceOpenMessage
     */
    export interface JsonViewOnceOpenMessage {
        sender?: JsonAddress;
        timestamp?: number;
    }

    /**
     * v1.LeaveGroupRequest
     */
    export interface LeaveGroupRequest {
        account: string;
        groupID: string;
    }

    /**
     * v1.LinkedDevices
     */
    export interface LinkedDevices {
        devices?: (DeviceInfo)[];
    }

    /**
     * v1.LinkingURI
     */
    export interface LinkingURI {
        uri?: string;
        session_id?: string;
    }

    /**
     * return all local accounts
     */
    export interface ListAccountsRequest {
    }

    /**
     * v1.ListContactsRequest
     */
    export interface ListContactsRequest {
        account: string;
        async?: boolean;
    }

    /**
     * v1.ListGroupsRequest
     */
    export interface ListGroupsRequest {
        account: string;
    }

    /**
     * indicates when the incoming connection to the signal server has started or stopped
     */
    export interface ListenerState {
        connected?: boolean;
    }

    /**
     * v1.MarkReadRequest
     */
    export interface MarkReadRequest {
        account: string;
        to: JsonAddress;
        timestamps: number[];
        when?: number;
    }

    /**
     * v1.OfferMessage
     */
    export interface OfferMessage {
        id?: number;
        sdp?: string;
        type?: string;
        opaque?: string;
    }

    /**
     * details about a MobileCoin payment
     */
    export interface Payment {
        receipt?: string;
        note?: string;
    }

    /**
     * Information about a Signal user
     */
    export interface Profile {
        name?: string;
        avatar?: string;
        address?: JsonAddress;
        capabilities?: Capabilities;
        color?: string;
        about?: string;
        emoji?: string;
        profile_name?: string;
        inbox_position?: number;
        expiration_time?: number;
    }

    /**
     * v1.ProfileList
     */
    export interface ProfileList {
        profiles?: (Profile)[];
    }

    /**
     * react to a previous message
     */
    export interface ReactRequest {
        username: string;
        recipientAddress?: JsonAddress;
        recipientGroupId?: string;
        reaction: JsonReaction;
        timestamp?: number;
    }

    /**
     * v1.ReceiptMessage
     */
    export interface ReceiptMessage {
        type?: string;
        timestamps?: number[];
        when?: number;
    }

    /**
     * begin the account registration process by requesting a phone number verification code. when the code is received, submit it with a verify request
     */
    export interface RegisterRequest {
        account: string;
        voice?: boolean;
        captcha?: string;
        server?: string;
    }

    /**
     * v1.RemoteDelete
     */
    export interface RemoteDelete {
        target_sent_timestamp?: number;
    }

    /**
     * delete a message previously sent
     */
    export interface RemoteDeleteRequest {
        account: string;
        address?: JsonAddress;
        group?: string;
        timestamp: number;
    }

    /**
     * Remove a linked device from the Signal account. Only allowed when the local device id is 1
     */
    export interface RemoveLinkedDeviceRequest {
        account: string;
        deviceId: number;
    }

    /**
     * v1.RemoveServerRequest
     */
    export interface RemoveServerRequest {
        uuid?: string;
    }

    /**
     * Request other devices on the account send us their group list, syncable config and contact list.
     */
    export interface RequestSyncRequest {
        account: string;
        groups?: boolean;
        configuration?: boolean;
        contacts?: boolean;
        blocked?: boolean;
    }

    /**
     * reset a session with a particular user
     */
    export interface ResetSessionRequest {
        account: string;
        address: JsonAddress;
        timestamp?: number;
    }

    /**
     * Resolve a partial JsonAddress with only a number or UUID to one with both. Anywhere that signald accepts a JsonAddress will except a partial, this is a convenience function for client authors, mostly because signald doesn't resolve all the partials it returns
     */
    export interface ResolveAddressRequest {
        account: string;
        partial: JsonAddress;
    }

    /**
     * v1.SendRequest
     */
    export interface SendRequest {
        username: string;
        recipientAddress?: JsonAddress;
        recipientGroupId?: string;
        messageBody?: string;
        attachments?: (v0.JsonAttachment)[];
        quote?: JsonQuote;
        timestamp?: number;
        mentions?: (JsonMention)[];
    }

    /**
     * v1.SendResponse
     */
    export interface SendResponse {
        results?: (JsonSendMessageResult)[];
        timestamp?: number;
    }

    /**
     * a Signal server
     */
    export interface Server {
        uuid?: string;
        proxy?: string;
        ca?: string;
        service_url?: string;
        cdn_urls?: (ServerCDN)[];
        contact_discovery_url?: string;
        key_backup_url?: string;
        storage_url?: string;
        zk_param?: string;
        unidentified_sender_root?: string;
    }

    /**
     * v1.ServerCDN
     */
    export interface ServerCDN {
        number?: number;
        url?: string;
    }

    /**
     * v1.ServerList
     */
    export interface ServerList {
        servers?: (Server)[];
    }

    /**
     * set this device's name. This will show up on the mobile device on the same account under 
     */
    export interface SetDeviceNameRequest {
        account: string;
        device_name?: string;
    }

    /**
     * Set the message expiration timer for a thread. Expiration must be specified in seconds, set to 0 to disable timer
     */
    export interface SetExpirationRequest {
        account: string;
        address?: JsonAddress;
        group?: string;
        expiration: number;
    }

    /**
     * v1.SetProfile
     */
    export interface SetProfile {
        account: string;
        name: string;
        avatarFile?: string;
        about?: string;
        emoji?: string;
    }

    /**
     * receive incoming messages. After making a subscribe request, incoming messages will be sent to the client encoded as ClientMessageWrapper. Send an unsubscribe request or disconnect from the socket to stop receiving messages.
     */
    export interface SubscribeRequest {
        account: string;
    }

    /**
     * Trust another user's safety number using either the QR code data or the safety number text
     */
    export interface TrustRequest {
        account: string;
        address: JsonAddress;
        safety_number?: string;
        qr_code_data?: string;
        trust_level?: string;
    }

    /**
     * v1.TypingMessage
     */
    export interface TypingMessage {
        action?: string;
        timestamp?: number;
        group_id?: string;
    }

    /**
     * send a typing started or stopped message
     */
    export interface TypingRequest {
        account: string;
        address?: JsonAddress;
        group?: string;
        typing: boolean;
        when?: number;
    }

    /**
     * See subscribe for more info
     */
    export interface UnsubscribeRequest {
        account: string;
    }

    /**
     * update information about a local contact
     */
    export interface UpdateContactRequest {
        account: string;
        address: JsonAddress;
        name?: string;
        color?: string;
        inbox_position?: number;
    }

    /**
     * modify a group. Note that only one modification action may be preformed at once
     */
    export interface UpdateGroupRequest {
        account: string;
        groupID: string;
        title?: string;
        avatar?: string;
        updateTimer?: number;
        addMembers?: (JsonAddress)[];
        removeMembers?: (JsonAddress)[];
        updateRole?: GroupMember;
        updateAccessControl?: GroupAccessControl;
        resetLink?: boolean;
    }

    /**
     * verify an account's phone number with a code after registering, completing the account creation process
     */
    export interface VerifyRequest {
        account: string;
        code: string;
    }

    /**
     * v1.VersionRequest
     */
    export interface VersionRequest {
    }

    export type ActionRequest = SendRequest | ReactRequest | VersionRequest | AcceptInvitationRequest | ApproveMembershipRequest | GetGroupRequest | GetLinkedDevicesRequest | JoinGroupRequest | RemoveLinkedDeviceRequest | UpdateGroupRequest | SetProfile | ResolveAddressRequest | MarkReadRequest | GetProfileRequest | ListGroupsRequest | ListContactsRequest | CreateGroupRequest | LeaveGroupRequest | GenerateLinkingURIRequest | FinishLinkRequest | AddLinkedDeviceRequest | RegisterRequest | VerifyRequest | GetIdentitiesRequest | TrustRequest | DeleteAccountRequest | TypingRequest | ResetSessionRequest | RequestSyncRequest | ListAccountsRequest | GroupLinkInfoRequest | UpdateContactRequest | SetExpirationRequest | SetDeviceNameRequest | GetAllIdentities | SubscribeRequest | UnsubscribeRequest | RemoteDeleteRequest | AddServerRequest | GetServersRequest | RemoveServerRequest;

    export type ActionResponse = SendResponse | JsonVersionMessage | JsonGroupV2Info | LinkedDevices | JsonGroupJoinInfo | GroupInfo | JsonAddress | Profile | GroupList | ProfileList | LinkingURI | Account | IdentityKeyList | AccountList | AllIdentityKeyList | ServerList;

}


export abstract class BaseClientV1 {
        static readonly signaldVersion = "0.14.1";
        static readonly protocolVersion = "v1";
        protected abstract sendActionToSocket<T>(actionName: string, request: v1.ActionRequest, outOnly?: boolean): Promise<T>;

        send(request: v1.SendRequest) {
            return this.sendActionToSocket<v1.SendResponse>("send", request);
        }

        react(request: v1.ReactRequest) {
            return this.sendActionToSocket<v1.SendResponse>("react", request);
        }

        version(request: v1.VersionRequest) {
            return this.sendActionToSocket<v1.JsonVersionMessage>("version", request);
        }

        acceptInvitation(request: v1.AcceptInvitationRequest) {
            return this.sendActionToSocket<v1.JsonGroupV2Info>("accept_invitation", request);
        }

        approveMembership(request: v1.ApproveMembershipRequest) {
            return this.sendActionToSocket<v1.JsonGroupV2Info>("approve_membership", request);
        }

        getGroup(request: v1.GetGroupRequest) {
            return this.sendActionToSocket<v1.JsonGroupV2Info>("get_group", request);
        }

        getLinkedDevices(request: v1.GetLinkedDevicesRequest) {
            return this.sendActionToSocket<v1.LinkedDevices>("get_linked_devices", request);
        }

        joinGroup(request: v1.JoinGroupRequest) {
            return this.sendActionToSocket<v1.JsonGroupJoinInfo>("join_group", request);
        }

        removeLinkedDevice(request: v1.RemoveLinkedDeviceRequest) {
            return this.sendActionToSocket<void>("remove_linked_device", request, true);
        }

        updateGroup(request: v1.UpdateGroupRequest) {
            return this.sendActionToSocket<v1.GroupInfo>("update_group", request);
        }

        setProfile(request: v1.SetProfile) {
            return this.sendActionToSocket<void>("set_profile", request, true);
        }

        resolveAddress(request: v1.ResolveAddressRequest) {
            return this.sendActionToSocket<v1.JsonAddress>("resolve_address", request);
        }

        markRead(request: v1.MarkReadRequest) {
            return this.sendActionToSocket<void>("mark_read", request, true);
        }

        getProfile(request: v1.GetProfileRequest) {
            return this.sendActionToSocket<v1.Profile>("get_profile", request);
        }

        listGroups(request: v1.ListGroupsRequest) {
            return this.sendActionToSocket<v1.GroupList>("list_groups", request);
        }

        listContacts(request: v1.ListContactsRequest) {
            return this.sendActionToSocket<v1.ProfileList>("list_contacts", request);
        }

        createGroup(request: v1.CreateGroupRequest) {
            return this.sendActionToSocket<v1.JsonGroupV2Info>("create_group", request);
        }

        leaveGroup(request: v1.LeaveGroupRequest) {
            return this.sendActionToSocket<v1.GroupInfo>("leave_group", request);
        }

        generateLinkingUri(request: v1.GenerateLinkingURIRequest) {
            return this.sendActionToSocket<v1.LinkingURI>("generate_linking_uri", request);
        }

        finishLink(request: v1.FinishLinkRequest) {
            return this.sendActionToSocket<v1.Account>("finish_link", request);
        }

        addDevice(request: v1.AddLinkedDeviceRequest) {
            return this.sendActionToSocket<void>("add_device", request, true);
        }

        register(request: v1.RegisterRequest) {
            return this.sendActionToSocket<v1.Account>("register", request);
        }

        verify(request: v1.VerifyRequest) {
            return this.sendActionToSocket<v1.Account>("verify", request);
        }

        getIdentities(request: v1.GetIdentitiesRequest) {
            return this.sendActionToSocket<v1.IdentityKeyList>("get_identities", request);
        }

        trust(request: v1.TrustRequest) {
            return this.sendActionToSocket<void>("trust", request, true);
        }

        deleteAccount(request: v1.DeleteAccountRequest) {
            return this.sendActionToSocket<void>("delete_account", request, true);
        }

        typing(request: v1.TypingRequest) {
            return this.sendActionToSocket<void>("typing", request, true);
        }

        resetSession(request: v1.ResetSessionRequest) {
            return this.sendActionToSocket<v1.SendResponse>("reset_session", request);
        }

        requestSync(request: v1.RequestSyncRequest) {
            return this.sendActionToSocket<void>("request_sync", request, true);
        }

        listAccounts(request: v1.ListAccountsRequest) {
            return this.sendActionToSocket<v1.AccountList>("list_accounts", request);
        }

        groupLinkInfo(request: v1.GroupLinkInfoRequest) {
            return this.sendActionToSocket<v1.JsonGroupJoinInfo>("group_link_info", request);
        }

        updateContact(request: v1.UpdateContactRequest) {
            return this.sendActionToSocket<v1.Profile>("update_contact", request);
        }

        setExpiration(request: v1.SetExpirationRequest) {
            return this.sendActionToSocket<v1.SendResponse>("set_expiration", request);
        }

        setDeviceName(request: v1.SetDeviceNameRequest) {
            return this.sendActionToSocket<void>("set_device_name", request, true);
        }

        getAllIdentities(request: v1.GetAllIdentities) {
            return this.sendActionToSocket<v1.AllIdentityKeyList>("get_all_identities", request);
        }

        subscribe(request: v1.SubscribeRequest) {
            return this.sendActionToSocket<void>("subscribe", request, true);
        }

        unsubscribe(request: v1.UnsubscribeRequest) {
            return this.sendActionToSocket<void>("unsubscribe", request, true);
        }

        remoteDelete(request: v1.RemoteDeleteRequest) {
            return this.sendActionToSocket<v1.SendResponse>("remote_delete", request);
        }

        addServer(request: v1.AddServerRequest) {
            return this.sendActionToSocket<string>("add_server", request);
        }

        getServers(request: v1.GetServersRequest) {
            return this.sendActionToSocket<v1.ServerList>("get_servers", request);
        }

        deleteServer(request: v1.RemoveServerRequest) {
            return this.sendActionToSocket<void>("delete_server", request, true);
        }
}

// v0 protocol
export namespace v0 {
    /**
     * v0.AnswerMessage
     */
    export interface AnswerMessage {
        id?: number;
        sdp?: string;
        opaque?: string;
    }

    /**
     * v0.BusyMessage
     */
    export interface BusyMessage {
        id?: number;
    }

    /**
     * v0.ConfigurationMessage
     */
    export interface ConfigurationMessage {
        readReceipts?: Optional;
        unidentifiedDeliveryIndicators?: Optional;
        typingIndicators?: Optional;
        linkPreviews?: Optional;
    }

    /**
     * group access control settings. Options for each controlled action are: UNKNOWN, ANY, MEMBER, ADMINISTRATOR, UNSATISFIABLE and UNRECOGNIZED
     * @deprecated
     */
    export interface GroupAccessControl {
        link?: string;
        attributes?: string;
        members?: string;
    }

    /**
     * v0.GroupMember
     * @deprecated
     */
    export interface GroupMember {
        uuid?: string;
        role?: string;
        joined_revision?: number;
    }

    /**
     * v0.HangupMessage
     */
    export interface HangupMessage {
        id?: number;
        type?: Type;
        deviceId?: number;
        legacy?: boolean;
    }

    /**
     * v0.IceUpdateMessage
     */
    export interface IceUpdateMessage {
        id?: number;
        opaque?: string;
        sdp?: string;
    }

    /**
     * v0.JsonAccount
     * @deprecated
     */
    export interface JsonAccount {
        deviceId?: number;
        username?: string;
        filename?: string;
        uuid?: string;
        registered?: boolean;
        has_keys?: boolean;
        subscribed?: boolean;
    }

    /**
     * v0.JsonAccountList
     * @deprecated
     */
    export interface JsonAccountList {
        accounts?: (JsonAccount)[];
    }

    /**
     * v0.JsonAddress
     * @deprecated
     */
    export interface JsonAddress {
        number?: string;
        uuid?: string;
        relay?: string;
    }

    /**
     * v0.JsonAttachment
     * @deprecated
     */
    export interface JsonAttachment {
        contentType?: string;
        id?: string;
        size?: number;
        storedFilename?: string;
        filename?: string;
        customFilename?: string;
        caption?: string;
        width?: number;
        height?: number;
        voiceNote?: boolean;
        key?: string;
        digest?: string;
        blurhash?: string;
    }

    /**
     * v0.JsonBlockedListMessage
     * @deprecated
     */
    export interface JsonBlockedListMessage {
        addresses?: (JsonAddress)[];
        groupIds?: string[];
    }

    /**
     * v0.JsonCallMessage
     * @deprecated
     */
    export interface JsonCallMessage {
        offerMessage?: OfferMessage;
        answerMessage?: AnswerMessage;
        busyMessage?: BusyMessage;
        hangupMessage?: HangupMessage;
        iceUpdateMessages?: (IceUpdateMessage)[];
        destinationDeviceId?: number;
        isMultiRing?: boolean;
    }

    /**
     * v0.JsonDataMessage
     * @deprecated
     */
    export interface JsonDataMessage {
        timestamp?: number;
        attachments?: (JsonAttachment)[];
        body?: string;
        group?: JsonGroupInfo;
        groupV2?: JsonGroupV2Info;
        endSession?: boolean;
        expiresInSeconds?: number;
        profileKeyUpdate?: boolean;
        quote?: JsonQuote;
        contacts?: (SharedContact)[];
        previews?: (JsonPreview)[];
        sticker?: JsonSticker;
        viewOnce?: boolean;
        reaction?: JsonReaction;
        remoteDelete?: RemoteDelete;
        mentions?: (JsonMention)[];
    }

    /**
     * v0.JsonGroupInfo
     * @deprecated
     */
    export interface JsonGroupInfo {
        groupId?: string;
        members?: (JsonAddress)[];
        name?: string;
        type?: string;
        avatarId?: number;
    }

    /**
     * v0.JsonGroupV2Info
     * @deprecated
     */
    export interface JsonGroupV2Info {
        id?: string;
        revision?: number;
        title?: string;
        description?: string;
        avatar?: string;
        timer?: number;
        members?: (JsonAddress)[];
        pendingMembers?: (JsonAddress)[];
        requestingMembers?: (JsonAddress)[];
        inviteLink?: string;
        accessControl?: GroupAccessControl;
        memberDetail?: (GroupMember)[];
        pendingMemberDetail?: (GroupMember)[];
    }

    /**
     * v0.JsonMention
     * @deprecated
     */
    export interface JsonMention {
        uuid?: string;
        start?: number;
        length?: number;
    }

    /**
     * v0.JsonMessageEnvelope
     * @deprecated
     */
    export interface JsonMessageEnvelope {
        username?: string;
        uuid?: string;
        source?: JsonAddress;
        sourceDevice?: number;
        type?: string;
        relay?: string;
        timestamp?: number;
        timestampISO?: string;
        serverTimestamp?: number;
        serverDeliveredTimestamp?: number;
        hasLegacyMessage?: boolean;
        hasContent?: boolean;
        isUnidentifiedSender?: boolean;
        dataMessage?: JsonDataMessage;
        syncMessage?: JsonSyncMessage;
        callMessage?: JsonCallMessage;
        receipt?: JsonReceiptMessage;
        typing?: JsonTypingMessage;
    }

    /**
     * v0.JsonMessageRequestResponseMessage
     * @deprecated
     */
    export interface JsonMessageRequestResponseMessage {
        person?: JsonAddress;
        groupId?: string;
        type?: string;
    }

    /**
     * v0.JsonPreview
     * @deprecated
     */
    export interface JsonPreview {
        url?: string;
        title?: string;
        attachment?: JsonAttachment;
    }

    /**
     * A quote is a reply to a previous message. ID is the sent time of the message being replied to
     * @deprecated
     */
    export interface JsonQuote {
        id?: number;
        author?: JsonAddress;
        text?: string;
        attachments?: (JsonQuotedAttachment)[];
        mentions?: (JsonMention)[];
    }

    /**
     * v0.JsonQuotedAttachment
     * @deprecated
     */
    export interface JsonQuotedAttachment {
        contentType?: string;
        fileName?: string;
        thumbnail?: JsonAttachment;
    }

    /**
     * v0.JsonReaction
     * @deprecated
     */
    export interface JsonReaction {
        emoji?: string;
        remove?: boolean;
        targetAuthor?: JsonAddress;
        targetSentTimestamp?: number;
    }

    /**
     * v0.JsonReadMessage
     * @deprecated
     */
    export interface JsonReadMessage {
        sender?: JsonAddress;
        timestamp?: number;
    }

    /**
     * v0.JsonReceiptMessage
     * @deprecated
     */
    export interface JsonReceiptMessage {
        type?: string;
        timestamps?: number[];
        when?: number;
    }

    /**
     * v0.JsonSentTranscriptMessage
     * @deprecated
     */
    export interface JsonSentTranscriptMessage {
        destination?: JsonAddress;
        timestamp?: number;
        expirationStartTimestamp?: number;
        message?: JsonDataMessage;
        unidentifiedStatus?: string;
        isRecipientUpdate?: boolean;
    }

    /**
     * v0.JsonSticker
     * @deprecated
     */
    export interface JsonSticker {
        packID?: string;
        packKey?: string;
        stickerID?: number;
        attachment?: JsonAttachment;
        image?: string;
    }

    /**
     * v0.JsonStickerPackOperationMessage
     * @deprecated
     */
    export interface JsonStickerPackOperationMessage {
        packID?: string;
        packKey?: string;
        type?: string;
    }

    /**
     * v0.JsonSyncMessage
     * @deprecated
     */
    export interface JsonSyncMessage {
        sent?: JsonSentTranscriptMessage;
        contacts?: JsonAttachment;
        contactsComplete?: boolean;
        groups?: JsonAttachment;
        blockedList?: JsonBlockedListMessage;
        request?: string;
        readMessages?: (JsonReadMessage)[];
        viewOnceOpen?: JsonViewOnceOpenMessage;
        verified?: JsonVerifiedMessage;
        configuration?: ConfigurationMessage;
        stickerPackOperations?: (JsonStickerPackOperationMessage)[];
        fetchType?: string;
        messageRequestResponse?: JsonMessageRequestResponseMessage;
    }

    /**
     * v0.JsonTypingMessage
     * @deprecated
     */
    export interface JsonTypingMessage {
        action?: string;
        timestamp?: number;
        groupId?: string;
    }

    /**
     * v0.JsonVerifiedMessage
     * @deprecated
     */
    export interface JsonVerifiedMessage {
        destination?: JsonAddress;
        identityKey?: string;
        verified?: string;
        timestamp?: number;
    }

    /**
     * v0.JsonViewOnceOpenMessage
     * @deprecated
     */
    export interface JsonViewOnceOpenMessage {
        sender?: JsonAddress;
        timestamp?: number;
    }

    /**
     * v0.Name
     */
    export interface Name {
        display?: Optional;
        given?: Optional;
        family?: Optional;
        prefix?: Optional;
        suffix?: Optional;
        middle?: Optional;
    }

    /**
     * v0.OfferMessage
     */
    export interface OfferMessage {
        id?: number;
        sdp?: string;
        type?: Type;
        opaque?: string;
    }

    /**
     * v0.Optional
     */
    export interface Optional {
        present?: boolean;
    }

    /**
     * v0.RemoteDelete
     */
    export interface RemoteDelete {
        targetSentTimestamp?: number;
    }

    /**
     * v0.SharedContact
     */
    export interface SharedContact {
        name?: Name;
        avatar?: Optional;
        phone?: Optional;
        email?: Optional;
        address?: Optional;
        organization?: Optional;
    }

    /**
     * v0.Success
     */
    export interface Success {
        unidentified?: boolean;
        needsSync?: boolean;
        duration?: number;
    }

    /**
     * v0.Type
     */
    export interface Type {
    }

}




export default v1;