Variable snapKeystoreApiDefsConst

snapKeystoreApiDefs: {
    createAuthToken: {
        req: {
            decode(input, length?) => CreateAuthTokenRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateAuthTokenRequest;
            fromPartial<I>(object) => CreateAuthTokenRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => Token;
            encode(message, writer?) => Writer;
            fromJSON(object) => Token;
            fromPartial<I>(object) => Token;
            toJSON(message) => unknown;
        };
    };
    createInvite: {
        req: {
            decode(input, length?) => CreateInviteRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateInviteRequest;
            fromPartial<I>(object) => CreateInviteRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => CreateInviteResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateInviteResponse;
            fromPartial<I>(object) => CreateInviteResponse;
            toJSON(message) => unknown;
        };
    };
    decryptV1: {
        req: {
            decode(input, length?) => DecryptV1Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptV1Request;
            fromPartial<I>(object) => DecryptV1Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    };
    decryptV2: {
        req: {
            decode(input, length?) => DecryptV2Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptV2Request;
            fromPartial<I>(object) => DecryptV2Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    };
    encryptV1: {
        req: {
            decode(input, length?) => EncryptV1Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptV1Request;
            fromPartial<I>(object) => EncryptV1Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => EncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptResponse;
            fromPartial<I>(object) => EncryptResponse;
            toJSON(message) => unknown;
        };
    };
    encryptV2: {
        req: {
            decode(input, length?) => EncryptV2Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptV2Request;
            fromPartial<I>(object) => EncryptV2Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => EncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptResponse;
            fromPartial<I>(object) => EncryptResponse;
            toJSON(message) => unknown;
        };
    };
    getKeystoreStatus: {
        req: {
            decode(input, length?) => GetKeystoreStatusRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetKeystoreStatusRequest;
            fromPartial<I>(object) => GetKeystoreStatusRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => GetKeystoreStatusResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetKeystoreStatusResponse;
            fromPartial<I>(object) => GetKeystoreStatusResponse;
            toJSON(message) => unknown;
        };
    };
    getPrivateKeyBundle: {
        req: null;
        res: {
            decode(input, length?) => PrivateKeyBundleV1;
            encode(message, writer?) => Writer;
            fromJSON(object) => PrivateKeyBundleV1;
            fromPartial<I>(object) => PrivateKeyBundleV1;
            toJSON(message) => unknown;
        };
    };
    getPrivatePreferencesTopicIdentifier: {
        req: null;
        res: {
            decode(input, length?) => GetPrivatePreferencesTopicIdentifierResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetPrivatePreferencesTopicIdentifierResponse;
            fromPartial<I>(object) => GetPrivatePreferencesTopicIdentifierResponse;
            toJSON(message) => unknown;
        };
    };
    getPublicKeyBundle: {
        req: null;
        res: {
            decode(input, length?) => PublicKeyBundle;
            encode(message, writer?) => Writer;
            fromJSON(object) => PublicKeyBundle;
            fromPartial<I>(object) => PublicKeyBundle;
            toJSON(message) => unknown;
        };
    };
    getRefreshJob: {
        req: {
            decode(input, length?) => GetRefreshJobRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetRefreshJobRequest;
            fromPartial<I>(object) => GetRefreshJobRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => GetRefreshJobResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetRefreshJobResponse;
            fromPartial<I>(object) => GetRefreshJobResponse;
            toJSON(message) => unknown;
        };
    };
    getV1Conversations: {
        req: null;
        res: {
            decode(input, length?) => GetConversationsResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetConversationsResponse;
            fromPartial<I>(object) => GetConversationsResponse;
            toJSON(message) => unknown;
        };
    };
    getV2Conversations: {
        req: null;
        res: {
            decode(input, length?) => GetConversationsResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetConversationsResponse;
            fromPartial<I>(object) => GetConversationsResponse;
            toJSON(message) => unknown;
        };
    };
    initKeystore: {
        req: {
            decode(input, length?) => InitKeystoreRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => InitKeystoreRequest;
            fromPartial<I>(object) => InitKeystoreRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => InitKeystoreResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => InitKeystoreResponse;
            fromPartial<I>(object) => InitKeystoreResponse;
            toJSON(message) => unknown;
        };
    };
    saveInvites: {
        req: {
            decode(input, length?) => SaveInvitesRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveInvitesRequest;
            fromPartial<I>(object) => SaveInvitesRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SaveInvitesResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveInvitesResponse;
            fromPartial<I>(object) => SaveInvitesResponse;
            toJSON(message) => unknown;
        };
    };
    saveV1Conversations: {
        req: {
            decode(input, length?) => SaveV1ConversationsRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveV1ConversationsRequest;
            fromPartial<I>(object) => SaveV1ConversationsRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SaveV1ConversationsResponse;
            encode(_, writer?) => Writer;
            fromJSON(_) => SaveV1ConversationsResponse;
            fromPartial<I>(_) => SaveV1ConversationsResponse;
            toJSON(_) => unknown;
        };
    };
    selfDecrypt: {
        req: {
            decode(input, length?) => SelfDecryptRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfDecryptRequest;
            fromPartial<I>(object) => SelfDecryptRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    };
    selfEncrypt: {
        req: {
            decode(input, length?) => SelfEncryptRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfEncryptRequest;
            fromPartial<I>(object) => SelfEncryptRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SelfEncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfEncryptResponse;
            fromPartial<I>(object) => SelfEncryptResponse;
            toJSON(message) => unknown;
        };
    };
    setRefreshJob: {
        req: {
            decode(input, length?) => SetRefeshJobRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SetRefeshJobRequest;
            fromPartial<I>(object) => SetRefeshJobRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SetRefreshJobResponse;
            encode(_, writer?) => Writer;
            fromJSON(_) => SetRefreshJobResponse;
            fromPartial<I>(_) => SetRefreshJobResponse;
            toJSON(_) => unknown;
        };
    };
    signDigest: {
        req: {
            decode(input, length?) => SignDigestRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SignDigestRequest;
            fromPartial<I>(object) => SignDigestRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => Signature;
            encode(message, writer?) => Writer;
            fromJSON(object) => Signature;
            fromPartial<I>(object) => Signature;
            toJSON(message) => unknown;
        };
    };
} = ...

Type declaration

  • createAuthToken: {
        req: {
            decode(input, length?) => CreateAuthTokenRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateAuthTokenRequest;
            fromPartial<I>(object) => CreateAuthTokenRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => Token;
            encode(message, writer?) => Writer;
            fromJSON(object) => Token;
            fromPartial<I>(object) => Token;
            toJSON(message) => unknown;
        };
    }

    Create an XMTP auth token to be used as a header on XMTP API requests

    • req: {
          decode(input, length?) => CreateAuthTokenRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => CreateAuthTokenRequest;
          fromPartial<I>(object) => CreateAuthTokenRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns CreateAuthTokenRequest

      • encode:function
        • Parameters

          • message: CreateAuthTokenRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns CreateAuthTokenRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                timestampNs?: string | number | Long;
            } & {
                timestampNs?: string | number | Long & {
                    add: ((addend) => Long);
                    and: ((other) => Long);
                    clz: (() => number);
                    comp: ((other) => number);
                    compare: ((other) => number);
                    countLeadingZeros: (() => number);
                    countTrailingZeros: (() => number);
                    ctz: (() => number);
                    div: ((divisor) => Long);
                    divide: ((divisor) => Long);
                    eq: ((other) => boolean);
                    equals: ((other) => boolean);
                    eqz: (() => boolean);
                    ge: ((other) => boolean);
                    getHighBits: (() => number);
                    getHighBitsUnsigned: (() => number);
                    getLowBits: (() => number);
                    getLowBitsUnsigned: (() => number);
                    getNumBitsAbs: (() => number);
                    greaterThan: ((other) => boolean);
                    greaterThanOrEqual: ((other) => boolean);
                    gt: ((other) => boolean);
                    gte: ((other) => boolean);
                    high: number;
                    isEven: (() => boolean);
                    isNegative: (() => boolean);
                    isOdd: (() => boolean);
                    isPositive: (() => boolean);
                    isZero: (() => boolean);
                    le: ((other) => boolean);
                    lessThan: ((other) => boolean);
                    lessThanOrEqual: ((other) => boolean);
                    low: number;
                    lt: ((other) => boolean);
                    lte: ((other) => boolean);
                    mod: ((other) => Long);
                    modulo: ((other) => Long);
                    mul: ((multiplier) => Long);
                    multiply: ((multiplier) => Long);
                    ne: ((other) => boolean);
                    neg: (() => Long);
                    negate: (() => Long);
                    neq: ((other) => boolean);
                    not: (() => Long);
                    notEquals: ((other) => boolean);
                    or: ((other) => Long);
                    rem: ((other) => Long);
                    rotateLeft: ((numBits) => Long);
                    rotateRight: ((numBits) => Long);
                    rotl: ((numBits) => Long);
                    rotr: ((numBits) => Long);
                    shiftLeft: ((numBits) => Long);
                    shiftRight: ((numBits) => Long);
                    shiftRightUnsigned: ((numBits) => Long);
                    shl: ((numBits) => Long);
                    shr: ((numBits) => Long);
                    shr_u: ((numBits) => Long);
                    shru: ((numBits) => Long);
                    sub: ((subtrahend) => Long);
                    subtract: ((subtrahend) => Long);
                    toBytes: ((le?) => number[]);
                    toBytesBE: (() => number[]);
                    toBytesLE: (() => number[]);
                    toInt: (() => number);
                    toNumber: (() => number);
                    toSigned: (() => Long);
                    toString: ((radix?) => string);
                    toUnsigned: (() => Long);
                    unsigned: boolean;
                    xor: ((other) => Long);
                } & {
                    [K in string | number | symbol]: never
                };
            } & {
                [K_1 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns CreateAuthTokenRequest

      • toJSON:function
        • Parameters

          • message: CreateAuthTokenRequest

          Returns unknown

    • res: {
          decode(input, length?) => Token;
          encode(message, writer?) => Writer;
          fromJSON(object) => Token;
          fromPartial<I>(object) => Token;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns Token

      • encode:function
        • Parameters

          • message: Token
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns Token

      • fromPartial:function
        • Type Parameters

          • I extends {
                authDataBytes?: Uint8Array;
                authDataSignature?: {
                    ecdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    };
                    walletEcdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    };
                };
                identityKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                };
            } & {
                authDataBytes?: Uint8Array;
                authDataSignature?: {
                    ecdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    };
                    walletEcdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    };
                } & {
                    ecdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    } & {
                        bytes?: Uint8Array;
                        recovery?: number;
                    } & {
                        [K_6 in string | number | symbol]: never
                    };
                    walletEcdsaCompact?: {
                        bytes?: Uint8Array;
                        recovery?: number;
                    } & {
                        bytes?: Uint8Array;
                        recovery?: number;
                    } & {
                        [K_7 in string | number | symbol]: never
                    };
                } & {
                    [K_8 in string | number | symbol]: never
                };
                identityKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                } & {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    } & {
                        bytes?: Uint8Array;
                    } & {
                        [K_4 in string | number | symbol]: never
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    } & {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_1 in string | number | symbol]: never
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_2 in string | number | symbol]: never
                        };
                    } & {
                        [K_3 in string | number | symbol]: never
                    };
                    timestamp?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_5 in string | number | symbol]: never
                };
            } & {
                [K_9 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns Token

      • toJSON:function
        • Parameters

          • message: Token

          Returns unknown

  • createInvite: {
        req: {
            decode(input, length?) => CreateInviteRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateInviteRequest;
            fromPartial<I>(object) => CreateInviteRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => CreateInviteResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => CreateInviteResponse;
            fromPartial<I>(object) => CreateInviteResponse;
            toJSON(message) => unknown;
        };
    }

    Create a sealed/encrypted invite and store the Topic keys in the Keystore for later use. The returned invite payload must be sent to the network for the other party to be able to communicate.

    • req: {
          decode(input, length?) => CreateInviteRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => CreateInviteRequest;
          fromPartial<I>(object) => CreateInviteRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns CreateInviteRequest

      • encode:function
        • Parameters

          • message: CreateInviteRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns CreateInviteRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                context?: {
                    conversationId?: string;
                    metadata?: {
                        [x: string]: string | undefined;
                    };
                };
                createdNs?: string | number | Long;
                recipient?: {
                    identityKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    };
                    preKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    };
                };
            } & {
                context?: {
                    conversationId?: string;
                    metadata?: {
                        [x: string]: string | undefined;
                    };
                } & {
                    conversationId?: string;
                    metadata?: {
                        [x: string]: string | undefined;
                    } & {
                        [x: string]: string | undefined;
                    } & {
                        [K in symbol]: never
                    };
                } & {
                    [K_1 in string | number | symbol]: never
                };
                createdNs?: string | number | Long & {
                    add: ((addend) => Long);
                    and: ((other) => Long);
                    clz: (() => number);
                    comp: ((other) => number);
                    compare: ((other) => number);
                    countLeadingZeros: (() => number);
                    countTrailingZeros: (() => number);
                    ctz: (() => number);
                    div: ((divisor) => Long);
                    divide: ((divisor) => Long);
                    eq: ((other) => boolean);
                    equals: ((other) => boolean);
                    eqz: (() => boolean);
                    ge: ((other) => boolean);
                    getHighBits: (() => number);
                    getHighBitsUnsigned: (() => number);
                    getLowBits: (() => number);
                    getLowBitsUnsigned: (() => number);
                    getNumBitsAbs: (() => number);
                    greaterThan: ((other) => boolean);
                    greaterThanOrEqual: ((other) => boolean);
                    gt: ((other) => boolean);
                    gte: ((other) => boolean);
                    high: number;
                    isEven: (() => boolean);
                    isNegative: (() => boolean);
                    isOdd: (() => boolean);
                    isPositive: (() => boolean);
                    isZero: (() => boolean);
                    le: ((other) => boolean);
                    lessThan: ((other) => boolean);
                    lessThanOrEqual: ((other) => boolean);
                    low: number;
                    lt: ((other) => boolean);
                    lte: ((other) => boolean);
                    mod: ((other) => Long);
                    modulo: ((other) => Long);
                    mul: ((multiplier) => Long);
                    multiply: ((multiplier) => Long);
                    ne: ((other) => boolean);
                    neg: (() => Long);
                    negate: (() => Long);
                    neq: ((other) => boolean);
                    not: (() => Long);
                    notEquals: ((other) => boolean);
                    or: ((other) => Long);
                    rem: ((other) => Long);
                    rotateLeft: ((numBits) => Long);
                    rotateRight: ((numBits) => Long);
                    rotl: ((numBits) => Long);
                    rotr: ((numBits) => Long);
                    shiftLeft: ((numBits) => Long);
                    shiftRight: ((numBits) => Long);
                    shiftRightUnsigned: ((numBits) => Long);
                    shl: ((numBits) => Long);
                    shr: ((numBits) => Long);
                    shr_u: ((numBits) => Long);
                    shru: ((numBits) => Long);
                    sub: ((subtrahend) => Long);
                    subtract: ((subtrahend) => Long);
                    toBytes: ((le?) => number[]);
                    toBytesBE: (() => number[]);
                    toBytesLE: (() => number[]);
                    toInt: (() => number);
                    toNumber: (() => number);
                    toSigned: (() => Long);
                    toString: ((radix?) => string);
                    toUnsigned: (() => Long);
                    unsigned: boolean;
                    xor: ((other) => Long);
                } & {
                    [K_11 in string | number | symbol]: never
                };
                recipient?: {
                    identityKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    };
                    preKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    };
                } & {
                    identityKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    } & {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        } & {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_2 in string | number | symbol]: never
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_3 in string | number | symbol]: never
                            };
                        } & {
                            [K_4 in string | number | symbol]: never
                        };
                    } & {
                        [K_5 in string | number | symbol]: never
                    };
                    preKey?: {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                    } & {
                        keyBytes?: Uint8Array;
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        } & {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_6 in string | number | symbol]: never
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_7 in string | number | symbol]: never
                            };
                        } & {
                            [K_8 in string | number | symbol]: never
                        };
                    } & {
                        [K_9 in string | number | symbol]: never
                    };
                } & {
                    [K_10 in string | number | symbol]: never
                };
            } & {
                [K_12 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns CreateInviteRequest

      • toJSON:function
        • Parameters

          • message: CreateInviteRequest

          Returns unknown

    • res: {
          decode(input, length?) => CreateInviteResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => CreateInviteResponse;
          fromPartial<I>(object) => CreateInviteResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns CreateInviteResponse

      • encode:function
        • Parameters

          • message: CreateInviteResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns CreateInviteResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                conversation?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                };
                payload?: Uint8Array;
            } & {
                conversation?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                } & {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    } & {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        } & {
                            [x: string]: string | undefined;
                        } & {
                            [K_1 in symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                    createdNs?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                    peerAddress?: string;
                    topic?: string;
                } & {
                    [K_3 in string | number | symbol]: never
                };
                payload?: Uint8Array;
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns CreateInviteResponse

      • toJSON:function
        • Parameters

          • message: CreateInviteResponse

          Returns unknown

  • decryptV1: {
        req: {
            decode(input, length?) => DecryptV1Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptV1Request;
            fromPartial<I>(object) => DecryptV1Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    }

    Decrypt a batch of V1 messages

    • req: {
          decode(input, length?) => DecryptV1Request;
          encode(message, writer?) => Writer;
          fromJSON(object) => DecryptV1Request;
          fromPartial<I>(object) => DecryptV1Request;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns DecryptV1Request

      • encode:function
        • Parameters

          • message: DecryptV1Request
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns DecryptV1Request

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    headerBytes?: Uint8Array;
                    isSender?: boolean;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                    peerKeys?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                }[];
            } & {
                requests?: {
                    headerBytes?: Uint8Array;
                    isSender?: boolean;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                    peerKeys?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                }[] & ({
                    headerBytes?: Uint8Array;
                    isSender?: boolean;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                    peerKeys?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                } & {
                    headerBytes?: Uint8Array;
                    isSender?: boolean;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    } & {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        } & {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        } & {
                            [K in string | number | symbol]: never
                        };
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    peerKeys?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    } & {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_6 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_3 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_4 in string | number | symbol]: never
                                };
                            } & {
                                [K_5 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K_2 in string | number | symbol]: never
                            };
                        } & {
                            [K_7 in string | number | symbol]: never
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_12 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_9 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_10 in string | number | symbol]: never
                                };
                            } & {
                                [K_11 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K_8 in string | number | symbol]: never
                            };
                        } & {
                            [K_13 in string | number | symbol]: never
                        };
                    } & {
                        [K_14 in string | number | symbol]: never
                    };
                } & {
                    [K_15 in string | number | symbol]: never
                })[] & {
                    [K_16 in string | symbol]: never
                };
            } & {
                [K_17 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns DecryptV1Request

      • toJSON:function
        • Parameters

          • message: DecryptV1Request

          Returns unknown

    • res: {
          decode(input, length?) => DecryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => DecryptResponse;
          fromPartial<I>(object) => DecryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns DecryptResponse

      • encode:function
        • Parameters

          • message: DecryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns DecryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    } & {
                        decrypted?: Uint8Array;
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_2 in string | number | symbol]: never
                })[] & {
                    [K_3 in string | symbol]: never
                };
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns DecryptResponse

      • toJSON:function
        • Parameters

          • message: DecryptResponse

          Returns unknown

  • decryptV2: {
        req: {
            decode(input, length?) => DecryptV2Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptV2Request;
            fromPartial<I>(object) => DecryptV2Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    }

    Decrypt a batch of V2 messages

    • req: {
          decode(input, length?) => DecryptV2Request;
          encode(message, writer?) => Writer;
          fromJSON(object) => DecryptV2Request;
          fromPartial<I>(object) => DecryptV2Request;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns DecryptV2Request

      • encode:function
        • Parameters

          • message: DecryptV2Request
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns DecryptV2Request

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                }[];
            } & {
                requests?: {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                }[] & ({
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    };
                } & {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        };
                    } & {
                        aes256GcmHkdfSha256?: {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        } & {
                            gcmNonce?: Uint8Array;
                            hkdfSalt?: Uint8Array;
                            payload?: Uint8Array;
                        } & {
                            [K in string | number | symbol]: never
                        };
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                } & {
                    [K_2 in string | number | symbol]: never
                })[] & {
                    [K_3 in string | symbol]: never
                };
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns DecryptV2Request

      • toJSON:function
        • Parameters

          • message: DecryptV2Request

          Returns unknown

    • res: {
          decode(input, length?) => DecryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => DecryptResponse;
          fromPartial<I>(object) => DecryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns DecryptResponse

      • encode:function
        • Parameters

          • message: DecryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns DecryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    } & {
                        decrypted?: Uint8Array;
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_2 in string | number | symbol]: never
                })[] & {
                    [K_3 in string | symbol]: never
                };
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns DecryptResponse

      • toJSON:function
        • Parameters

          • message: DecryptResponse

          Returns unknown

  • encryptV1: {
        req: {
            decode(input, length?) => EncryptV1Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptV1Request;
            fromPartial<I>(object) => EncryptV1Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => EncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptResponse;
            fromPartial<I>(object) => EncryptResponse;
            toJSON(message) => unknown;
        };
    }

    Encrypt a batch of V1 messages

    • req: {
          decode(input, length?) => EncryptV1Request;
          encode(message, writer?) => Writer;
          fromJSON(object) => EncryptV1Request;
          fromPartial<I>(object) => EncryptV1Request;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns EncryptV1Request

      • encode:function
        • Parameters

          • message: EncryptV1Request
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns EncryptV1Request

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                    recipient?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                }[];
            } & {
                requests?: {
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                    recipient?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                }[] & ({
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                    recipient?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    };
                } & {
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                    recipient?: {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                    } & {
                        identityKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_4 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_1 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_2 in string | number | symbol]: never
                                };
                            } & {
                                [K_3 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K in string | number | symbol]: never
                            };
                        } & {
                            [K_5 in string | number | symbol]: never
                        };
                        preKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_10 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_7 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_8 in string | number | symbol]: never
                                };
                            } & {
                                [K_9 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K_6 in string | number | symbol]: never
                            };
                        } & {
                            [K_11 in string | number | symbol]: never
                        };
                    } & {
                        [K_12 in string | number | symbol]: never
                    };
                } & {
                    [K_13 in string | number | symbol]: never
                })[] & {
                    [K_14 in string | symbol]: never
                };
            } & {
                [K_15 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns EncryptV1Request

      • toJSON:function
        • Parameters

          • message: EncryptV1Request

          Returns unknown

    • res: {
          decode(input, length?) => EncryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => EncryptResponse;
          fromPartial<I>(object) => EncryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns EncryptResponse

      • encode:function
        • Parameters

          • message: EncryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns EncryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_3 in string | number | symbol]: never
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    } & {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        } & {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            } & {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            } & {
                                [K in string | number | symbol]: never
                            };
                        } & {
                            [K_1 in string | number | symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                } & {
                    [K_4 in string | number | symbol]: never
                })[] & {
                    [K_5 in string | symbol]: never
                };
            } & {
                [K_6 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns EncryptResponse

      • toJSON:function
        • Parameters

          • message: EncryptResponse

          Returns unknown

  • encryptV2: {
        req: {
            decode(input, length?) => EncryptV2Request;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptV2Request;
            fromPartial<I>(object) => EncryptV2Request;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => EncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => EncryptResponse;
            fromPartial<I>(object) => EncryptResponse;
            toJSON(message) => unknown;
        };
    }

    Encrypt a batch of V2 messages

    • req: {
          decode(input, length?) => EncryptV2Request;
          encode(message, writer?) => Writer;
          fromJSON(object) => EncryptV2Request;
          fromPartial<I>(object) => EncryptV2Request;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns EncryptV2Request

      • encode:function
        • Parameters

          • message: EncryptV2Request
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns EncryptV2Request

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                }[];
            } & {
                requests?: {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                }[] & ({
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                } & {
                    contentTopic?: string;
                    headerBytes?: Uint8Array;
                    payload?: Uint8Array;
                } & {
                    [K in string | number | symbol]: never
                })[] & {
                    [K_1 in string | symbol]: never
                };
            } & {
                [K_2 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns EncryptV2Request

      • toJSON:function
        • Parameters

          • message: EncryptV2Request

          Returns unknown

    • res: {
          decode(input, length?) => EncryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => EncryptResponse;
          fromPartial<I>(object) => EncryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns EncryptResponse

      • encode:function
        • Parameters

          • message: EncryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns EncryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_3 in string | number | symbol]: never
                    };
                    result?: {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        };
                    } & {
                        encrypted?: {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            };
                        } & {
                            aes256GcmHkdfSha256?: {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            } & {
                                gcmNonce?: Uint8Array;
                                hkdfSalt?: Uint8Array;
                                payload?: Uint8Array;
                            } & {
                                [K in string | number | symbol]: never
                            };
                        } & {
                            [K_1 in string | number | symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                } & {
                    [K_4 in string | number | symbol]: never
                })[] & {
                    [K_5 in string | symbol]: never
                };
            } & {
                [K_6 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns EncryptResponse

      • toJSON:function
        • Parameters

          • message: EncryptResponse

          Returns unknown

  • getKeystoreStatus: {
        req: {
            decode(input, length?) => GetKeystoreStatusRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetKeystoreStatusRequest;
            fromPartial<I>(object) => GetKeystoreStatusRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => GetKeystoreStatusResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetKeystoreStatusResponse;
            fromPartial<I>(object) => GetKeystoreStatusResponse;
            toJSON(message) => unknown;
        };
    }
    • req: {
          decode(input, length?) => GetKeystoreStatusRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetKeystoreStatusRequest;
          fromPartial<I>(object) => GetKeystoreStatusRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetKeystoreStatusRequest

      • encode:function
        • Parameters

          • message: GetKeystoreStatusRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetKeystoreStatusRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                walletAddress?: string;
            } & {
                walletAddress?: string;
            } & {
                [K in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetKeystoreStatusRequest

      • toJSON:function
        • Parameters

          • message: GetKeystoreStatusRequest

          Returns unknown

    • res: {
          decode(input, length?) => GetKeystoreStatusResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetKeystoreStatusResponse;
          fromPartial<I>(object) => GetKeystoreStatusResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetKeystoreStatusResponse

      • encode:function
        • Parameters

          • message: GetKeystoreStatusResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetKeystoreStatusResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                status?: GetKeystoreStatusResponse_KeystoreStatus;
            } & {
                status?: GetKeystoreStatusResponse_KeystoreStatus;
            } & {
                [K in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetKeystoreStatusResponse

      • toJSON:function
        • Parameters

          • message: GetKeystoreStatusResponse

          Returns unknown

  • getPrivateKeyBundle: {
        req: null;
        res: {
            decode(input, length?) => PrivateKeyBundleV1;
            encode(message, writer?) => Writer;
            fromJSON(object) => PrivateKeyBundleV1;
            fromPartial<I>(object) => PrivateKeyBundleV1;
            toJSON(message) => unknown;
        };
    }

    Export the private keys. May throw an error if the keystore implementation does not allow this operation

    • req: null
    • res: {
          decode(input, length?) => PrivateKeyBundleV1;
          encode(message, writer?) => Writer;
          fromJSON(object) => PrivateKeyBundleV1;
          fromPartial<I>(object) => PrivateKeyBundleV1;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns PrivateKeyBundleV1

      • encode:function
        • Parameters

          • message: PrivateKeyBundleV1
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns PrivateKeyBundleV1

      • fromPartial:function
        • Type Parameters

          • I extends {
                identityKey?: {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    };
                    timestamp?: string | number | Long;
                };
                preKeys?: {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    };
                    timestamp?: string | number | Long;
                }[];
            } & {
                identityKey?: {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    };
                    timestamp?: string | number | Long;
                } & {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    } & {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        } & {
                            bytes?: Uint8Array;
                        } & {
                            [K_6 in string | number | symbol]: never
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        } & {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_3 in string | number | symbol]: never
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_4 in string | number | symbol]: never
                            };
                        } & {
                            [K_5 in string | number | symbol]: never
                        };
                        timestamp?: string | number | Long & {
                            add: ((addend) => Long);
                            and: ((other) => Long);
                            clz: (() => number);
                            comp: ((other) => number);
                            compare: ((other) => number);
                            countLeadingZeros: (() => number);
                            countTrailingZeros: (() => number);
                            ctz: (() => number);
                            div: ((divisor) => Long);
                            divide: ((divisor) => Long);
                            eq: ((other) => boolean);
                            equals: ((other) => boolean);
                            eqz: (() => boolean);
                            ge: ((other) => boolean);
                            getHighBits: (() => number);
                            getHighBitsUnsigned: (() => number);
                            getLowBits: (() => number);
                            getLowBitsUnsigned: (() => number);
                            getNumBitsAbs: (() => number);
                            greaterThan: ((other) => boolean);
                            greaterThanOrEqual: ((other) => boolean);
                            gt: ((other) => boolean);
                            gte: ((other) => boolean);
                            high: number;
                            isEven: (() => boolean);
                            isNegative: (() => boolean);
                            isOdd: (() => boolean);
                            isPositive: (() => boolean);
                            isZero: (() => boolean);
                            le: ((other) => boolean);
                            lessThan: ((other) => boolean);
                            lessThanOrEqual: ((other) => boolean);
                            low: number;
                            lt: ((other) => boolean);
                            lte: ((other) => boolean);
                            mod: ((other) => Long);
                            modulo: ((other) => Long);
                            mul: ((multiplier) => Long);
                            multiply: ((multiplier) => Long);
                            ne: ((other) => boolean);
                            neg: (() => Long);
                            negate: (() => Long);
                            neq: ((other) => boolean);
                            not: (() => Long);
                            notEquals: ((other) => boolean);
                            or: ((other) => Long);
                            rem: ((other) => Long);
                            rotateLeft: ((numBits) => Long);
                            rotateRight: ((numBits) => Long);
                            rotl: ((numBits) => Long);
                            rotr: ((numBits) => Long);
                            shiftLeft: ((numBits) => Long);
                            shiftRight: ((numBits) => Long);
                            shiftRightUnsigned: ((numBits) => Long);
                            shl: ((numBits) => Long);
                            shr: ((numBits) => Long);
                            shr_u: ((numBits) => Long);
                            shru: ((numBits) => Long);
                            sub: ((subtrahend) => Long);
                            subtract: ((subtrahend) => Long);
                            toBytes: ((le?) => number[]);
                            toBytesBE: (() => number[]);
                            toBytesLE: (() => number[]);
                            toInt: (() => number);
                            toNumber: (() => number);
                            toSigned: (() => Long);
                            toString: ((radix?) => string);
                            toUnsigned: (() => Long);
                            unsigned: boolean;
                            xor: ((other) => Long);
                        } & {
                            [K_2 in string | number | symbol]: never
                        };
                    } & {
                        [K_7 in string | number | symbol]: never
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    } & {
                        bytes?: Uint8Array;
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    timestamp?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_8 in string | number | symbol]: never
                };
                preKeys?: {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    };
                    timestamp?: string | number | Long;
                }[] & ({
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    };
                    timestamp?: string | number | Long;
                } & {
                    publicKey?: {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        };
                        timestamp?: string | number | Long;
                    } & {
                        secp256k1Uncompressed?: {
                            bytes?: Uint8Array;
                        } & {
                            bytes?: Uint8Array;
                        } & {
                            [K_15 in string | number | symbol]: never
                        };
                        signature?: {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            };
                        } & {
                            ecdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_12 in string | number | symbol]: never
                            };
                            walletEcdsaCompact?: {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                bytes?: Uint8Array;
                                recovery?: number;
                            } & {
                                [K_13 in string | number | symbol]: never
                            };
                        } & {
                            [K_14 in string | number | symbol]: never
                        };
                        timestamp?: string | number | Long & {
                            add: ((addend) => Long);
                            and: ((other) => Long);
                            clz: (() => number);
                            comp: ((other) => number);
                            compare: ((other) => number);
                            countLeadingZeros: (() => number);
                            countTrailingZeros: (() => number);
                            ctz: (() => number);
                            div: ((divisor) => Long);
                            divide: ((divisor) => Long);
                            eq: ((other) => boolean);
                            equals: ((other) => boolean);
                            eqz: (() => boolean);
                            ge: ((other) => boolean);
                            getHighBits: (() => number);
                            getHighBitsUnsigned: (() => number);
                            getLowBits: (() => number);
                            getLowBitsUnsigned: (() => number);
                            getNumBitsAbs: (() => number);
                            greaterThan: ((other) => boolean);
                            greaterThanOrEqual: ((other) => boolean);
                            gt: ((other) => boolean);
                            gte: ((other) => boolean);
                            high: number;
                            isEven: (() => boolean);
                            isNegative: (() => boolean);
                            isOdd: (() => boolean);
                            isPositive: (() => boolean);
                            isZero: (() => boolean);
                            le: ((other) => boolean);
                            lessThan: ((other) => boolean);
                            lessThanOrEqual: ((other) => boolean);
                            low: number;
                            lt: ((other) => boolean);
                            lte: ((other) => boolean);
                            mod: ((other) => Long);
                            modulo: ((other) => Long);
                            mul: ((multiplier) => Long);
                            multiply: ((multiplier) => Long);
                            ne: ((other) => boolean);
                            neg: (() => Long);
                            negate: (() => Long);
                            neq: ((other) => boolean);
                            not: (() => Long);
                            notEquals: ((other) => boolean);
                            or: ((other) => Long);
                            rem: ((other) => Long);
                            rotateLeft: ((numBits) => Long);
                            rotateRight: ((numBits) => Long);
                            rotl: ((numBits) => Long);
                            rotr: ((numBits) => Long);
                            shiftLeft: ((numBits) => Long);
                            shiftRight: ((numBits) => Long);
                            shiftRightUnsigned: ((numBits) => Long);
                            shl: ((numBits) => Long);
                            shr: ((numBits) => Long);
                            shr_u: ((numBits) => Long);
                            shru: ((numBits) => Long);
                            sub: ((subtrahend) => Long);
                            subtract: ((subtrahend) => Long);
                            toBytes: ((le?) => number[]);
                            toBytesBE: (() => number[]);
                            toBytesLE: (() => number[]);
                            toInt: (() => number);
                            toNumber: (() => number);
                            toSigned: (() => Long);
                            toString: ((radix?) => string);
                            toUnsigned: (() => Long);
                            unsigned: boolean;
                            xor: ((other) => Long);
                        } & {
                            [K_11 in string | number | symbol]: never
                        };
                    } & {
                        [K_16 in string | number | symbol]: never
                    };
                    secp256k1?: {
                        bytes?: Uint8Array;
                    } & {
                        bytes?: Uint8Array;
                    } & {
                        [K_10 in string | number | symbol]: never
                    };
                    timestamp?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K_9 in string | number | symbol]: never
                    };
                } & {
                    [K_17 in string | number | symbol]: never
                })[] & {
                    [K_18 in string | symbol]: never
                };
            } & {
                [K_19 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns PrivateKeyBundleV1

      • toJSON:function
        • Parameters

          • message: PrivateKeyBundleV1

          Returns unknown

  • getPrivatePreferencesTopicIdentifier: {
        req: null;
        res: {
            decode(input, length?) => GetPrivatePreferencesTopicIdentifierResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetPrivatePreferencesTopicIdentifierResponse;
            fromPartial<I>(object) => GetPrivatePreferencesTopicIdentifierResponse;
            toJSON(message) => unknown;
        };
    }

    Get the private preferences topic identifier

    • req: null
    • res: {
          decode(input, length?) => GetPrivatePreferencesTopicIdentifierResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetPrivatePreferencesTopicIdentifierResponse;
          fromPartial<I>(object) => GetPrivatePreferencesTopicIdentifierResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetPrivatePreferencesTopicIdentifierResponse

      • encode:function
        • Parameters

          • message: GetPrivatePreferencesTopicIdentifierResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetPrivatePreferencesTopicIdentifierResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                identifier?: string;
            } & {
                identifier?: string;
            } & {
                [K in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetPrivatePreferencesTopicIdentifierResponse

      • toJSON:function
        • Parameters

          • message: GetPrivatePreferencesTopicIdentifierResponse

          Returns unknown

  • getPublicKeyBundle: {
        req: null;
        res: {
            decode(input, length?) => PublicKeyBundle;
            encode(message, writer?) => Writer;
            fromJSON(object) => PublicKeyBundle;
            fromPartial<I>(object) => PublicKeyBundle;
            toJSON(message) => unknown;
        };
    }

    Get the PublicKeyBundle associated with the Keystore's private keys

    • req: null
    • res: {
          decode(input, length?) => PublicKeyBundle;
          encode(message, writer?) => Writer;
          fromJSON(object) => PublicKeyBundle;
          fromPartial<I>(object) => PublicKeyBundle;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns PublicKeyBundle

      • encode:function
        • Parameters

          • message: PublicKeyBundle
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns PublicKeyBundle

      • fromPartial:function
        • Type Parameters

          • I extends {
                identityKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                };
                preKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                };
            } & {
                identityKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                } & {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    } & {
                        bytes?: Uint8Array;
                    } & {
                        [K_4 in string | number | symbol]: never
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    } & {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_1 in string | number | symbol]: never
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_2 in string | number | symbol]: never
                        };
                    } & {
                        [K_3 in string | number | symbol]: never
                    };
                    timestamp?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_5 in string | number | symbol]: never
                };
                preKey?: {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    };
                    timestamp?: string | number | Long;
                } & {
                    secp256k1Uncompressed?: {
                        bytes?: Uint8Array;
                    } & {
                        bytes?: Uint8Array;
                    } & {
                        [K_10 in string | number | symbol]: never
                    };
                    signature?: {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        };
                    } & {
                        ecdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_7 in string | number | symbol]: never
                        };
                        walletEcdsaCompact?: {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            bytes?: Uint8Array;
                            recovery?: number;
                        } & {
                            [K_8 in string | number | symbol]: never
                        };
                    } & {
                        [K_9 in string | number | symbol]: never
                    };
                    timestamp?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K_6 in string | number | symbol]: never
                    };
                } & {
                    [K_11 in string | number | symbol]: never
                };
            } & {
                [K_12 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns PublicKeyBundle

      • toJSON:function
        • Parameters

          • message: PublicKeyBundle

          Returns unknown

  • getRefreshJob: {
        req: {
            decode(input, length?) => GetRefreshJobRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetRefreshJobRequest;
            fromPartial<I>(object) => GetRefreshJobRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => GetRefreshJobResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetRefreshJobResponse;
            fromPartial<I>(object) => GetRefreshJobResponse;
            toJSON(message) => unknown;
        };
    }

    Get a refresh job from the persistence

    • req: {
          decode(input, length?) => GetRefreshJobRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetRefreshJobRequest;
          fromPartial<I>(object) => GetRefreshJobRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetRefreshJobRequest

      • encode:function
        • Parameters

          • message: GetRefreshJobRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetRefreshJobRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                jobType?: JobType;
            } & {
                jobType?: JobType;
            } & {
                [K in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetRefreshJobRequest

      • toJSON:function
        • Parameters

          • message: GetRefreshJobRequest

          Returns unknown

    • res: {
          decode(input, length?) => GetRefreshJobResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetRefreshJobResponse;
          fromPartial<I>(object) => GetRefreshJobResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetRefreshJobResponse

      • encode:function
        • Parameters

          • message: GetRefreshJobResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetRefreshJobResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                lastRunNs?: string | number | Long;
            } & {
                lastRunNs?: string | number | Long & {
                    add: ((addend) => Long);
                    and: ((other) => Long);
                    clz: (() => number);
                    comp: ((other) => number);
                    compare: ((other) => number);
                    countLeadingZeros: (() => number);
                    countTrailingZeros: (() => number);
                    ctz: (() => number);
                    div: ((divisor) => Long);
                    divide: ((divisor) => Long);
                    eq: ((other) => boolean);
                    equals: ((other) => boolean);
                    eqz: (() => boolean);
                    ge: ((other) => boolean);
                    getHighBits: (() => number);
                    getHighBitsUnsigned: (() => number);
                    getLowBits: (() => number);
                    getLowBitsUnsigned: (() => number);
                    getNumBitsAbs: (() => number);
                    greaterThan: ((other) => boolean);
                    greaterThanOrEqual: ((other) => boolean);
                    gt: ((other) => boolean);
                    gte: ((other) => boolean);
                    high: number;
                    isEven: (() => boolean);
                    isNegative: (() => boolean);
                    isOdd: (() => boolean);
                    isPositive: (() => boolean);
                    isZero: (() => boolean);
                    le: ((other) => boolean);
                    lessThan: ((other) => boolean);
                    lessThanOrEqual: ((other) => boolean);
                    low: number;
                    lt: ((other) => boolean);
                    lte: ((other) => boolean);
                    mod: ((other) => Long);
                    modulo: ((other) => Long);
                    mul: ((multiplier) => Long);
                    multiply: ((multiplier) => Long);
                    ne: ((other) => boolean);
                    neg: (() => Long);
                    negate: (() => Long);
                    neq: ((other) => boolean);
                    not: (() => Long);
                    notEquals: ((other) => boolean);
                    or: ((other) => Long);
                    rem: ((other) => Long);
                    rotateLeft: ((numBits) => Long);
                    rotateRight: ((numBits) => Long);
                    rotl: ((numBits) => Long);
                    rotr: ((numBits) => Long);
                    shiftLeft: ((numBits) => Long);
                    shiftRight: ((numBits) => Long);
                    shiftRightUnsigned: ((numBits) => Long);
                    shl: ((numBits) => Long);
                    shr: ((numBits) => Long);
                    shr_u: ((numBits) => Long);
                    shru: ((numBits) => Long);
                    sub: ((subtrahend) => Long);
                    subtract: ((subtrahend) => Long);
                    toBytes: ((le?) => number[]);
                    toBytesBE: (() => number[]);
                    toBytesLE: (() => number[]);
                    toInt: (() => number);
                    toNumber: (() => number);
                    toSigned: (() => Long);
                    toString: ((radix?) => string);
                    toUnsigned: (() => Long);
                    unsigned: boolean;
                    xor: ((other) => Long);
                } & {
                    [K in string | number | symbol]: never
                };
            } & {
                [K_1 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetRefreshJobResponse

      • toJSON:function
        • Parameters

          • message: GetRefreshJobResponse

          Returns unknown

  • getV1Conversations: {
        req: null;
        res: {
            decode(input, length?) => GetConversationsResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetConversationsResponse;
            fromPartial<I>(object) => GetConversationsResponse;
            toJSON(message) => unknown;
        };
    }

    Get a list of V1 conversations

    • req: null
    • res: {
          decode(input, length?) => GetConversationsResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetConversationsResponse;
          fromPartial<I>(object) => GetConversationsResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetConversationsResponse

      • encode:function
        • Parameters

          • message: GetConversationsResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetConversationsResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[];
            } & {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[] & ({
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                } & {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    } & {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        } & {
                            [x: string]: string | undefined;
                        } & {
                            [K_1 in symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                    createdNs?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                    peerAddress?: string;
                    topic?: string;
                } & {
                    [K_3 in string | number | symbol]: never
                })[] & {
                    [K_4 in string | symbol]: never
                };
            } & {
                [K_5 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetConversationsResponse

      • toJSON:function
        • Parameters

          • message: GetConversationsResponse

          Returns unknown

  • getV2Conversations: {
        req: null;
        res: {
            decode(input, length?) => GetConversationsResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => GetConversationsResponse;
            fromPartial<I>(object) => GetConversationsResponse;
            toJSON(message) => unknown;
        };
    }

    Get a list of V2 conversations

    • req: null
    • res: {
          decode(input, length?) => GetConversationsResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => GetConversationsResponse;
          fromPartial<I>(object) => GetConversationsResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns GetConversationsResponse

      • encode:function
        • Parameters

          • message: GetConversationsResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns GetConversationsResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[];
            } & {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[] & ({
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                } & {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    } & {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        } & {
                            [x: string]: string | undefined;
                        } & {
                            [K_1 in symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                    createdNs?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                    peerAddress?: string;
                    topic?: string;
                } & {
                    [K_3 in string | number | symbol]: never
                })[] & {
                    [K_4 in string | symbol]: never
                };
            } & {
                [K_5 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns GetConversationsResponse

      • toJSON:function
        • Parameters

          • message: GetConversationsResponse

          Returns unknown

  • initKeystore: {
        req: {
            decode(input, length?) => InitKeystoreRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => InitKeystoreRequest;
            fromPartial<I>(object) => InitKeystoreRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => InitKeystoreResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => InitKeystoreResponse;
            fromPartial<I>(object) => InitKeystoreResponse;
            toJSON(message) => unknown;
        };
    }
    • req: {
          decode(input, length?) => InitKeystoreRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => InitKeystoreRequest;
          fromPartial<I>(object) => InitKeystoreRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns InitKeystoreRequest

      • encode:function
        • Parameters

          • message: InitKeystoreRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns InitKeystoreRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                v1?: {
                    identityKey?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    };
                    preKeys?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    }[];
                };
            } & {
                v1?: {
                    identityKey?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    };
                    preKeys?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    }[];
                } & {
                    identityKey?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    } & {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_6 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_3 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_4 in string | number | symbol]: never
                                };
                            } & {
                                [K_5 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K_2 in string | number | symbol]: never
                            };
                        } & {
                            [K_7 in string | number | symbol]: never
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        } & {
                            bytes?: Uint8Array;
                        } & {
                            [K_1 in string | number | symbol]: never
                        };
                        timestamp?: string | number | Long & {
                            add: ((addend) => Long);
                            and: ((other) => Long);
                            clz: (() => number);
                            comp: ((other) => number);
                            compare: ((other) => number);
                            countLeadingZeros: (() => number);
                            countTrailingZeros: (() => number);
                            ctz: (() => number);
                            div: ((divisor) => Long);
                            divide: ((divisor) => Long);
                            eq: ((other) => boolean);
                            equals: ((other) => boolean);
                            eqz: (() => boolean);
                            ge: ((other) => boolean);
                            getHighBits: (() => number);
                            getHighBitsUnsigned: (() => number);
                            getLowBits: (() => number);
                            getLowBitsUnsigned: (() => number);
                            getNumBitsAbs: (() => number);
                            greaterThan: ((other) => boolean);
                            greaterThanOrEqual: ((other) => boolean);
                            gt: ((other) => boolean);
                            gte: ((other) => boolean);
                            high: number;
                            isEven: (() => boolean);
                            isNegative: (() => boolean);
                            isOdd: (() => boolean);
                            isPositive: (() => boolean);
                            isZero: (() => boolean);
                            le: ((other) => boolean);
                            lessThan: ((other) => boolean);
                            lessThanOrEqual: ((other) => boolean);
                            low: number;
                            lt: ((other) => boolean);
                            lte: ((other) => boolean);
                            mod: ((other) => Long);
                            modulo: ((other) => Long);
                            mul: ((multiplier) => Long);
                            multiply: ((multiplier) => Long);
                            ne: ((other) => boolean);
                            neg: (() => Long);
                            negate: (() => Long);
                            neq: ((other) => boolean);
                            not: (() => Long);
                            notEquals: ((other) => boolean);
                            or: ((other) => Long);
                            rem: ((other) => Long);
                            rotateLeft: ((numBits) => Long);
                            rotateRight: ((numBits) => Long);
                            rotl: ((numBits) => Long);
                            rotr: ((numBits) => Long);
                            shiftLeft: ((numBits) => Long);
                            shiftRight: ((numBits) => Long);
                            shiftRightUnsigned: ((numBits) => Long);
                            shl: ((numBits) => Long);
                            shr: ((numBits) => Long);
                            shr_u: ((numBits) => Long);
                            shru: ((numBits) => Long);
                            sub: ((subtrahend) => Long);
                            subtract: ((subtrahend) => Long);
                            toBytes: ((le?) => number[]);
                            toBytesBE: (() => number[]);
                            toBytesLE: (() => number[]);
                            toInt: (() => number);
                            toNumber: (() => number);
                            toSigned: (() => Long);
                            toString: ((radix?) => string);
                            toUnsigned: (() => Long);
                            unsigned: boolean;
                            xor: ((other) => Long);
                        } & {
                            [K in string | number | symbol]: never
                        };
                    } & {
                        [K_8 in string | number | symbol]: never
                    };
                    preKeys?: {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    }[] & ({
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        };
                        timestamp?: string | number | Long;
                    } & {
                        publicKey?: {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            };
                            timestamp?: string | number | Long;
                        } & {
                            secp256k1Uncompressed?: {
                                bytes?: Uint8Array;
                            } & {
                                bytes?: Uint8Array;
                            } & {
                                [K_15 in string | number | symbol]: never
                            };
                            signature?: {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                };
                            } & {
                                ecdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_12 in string | number | symbol]: never
                                };
                                walletEcdsaCompact?: {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    bytes?: Uint8Array;
                                    recovery?: number;
                                } & {
                                    [K_13 in string | number | symbol]: never
                                };
                            } & {
                                [K_14 in string | number | symbol]: never
                            };
                            timestamp?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K_11 in string | number | symbol]: never
                            };
                        } & {
                            [K_16 in string | number | symbol]: never
                        };
                        secp256k1?: {
                            bytes?: Uint8Array;
                        } & {
                            bytes?: Uint8Array;
                        } & {
                            [K_10 in string | number | symbol]: never
                        };
                        timestamp?: string | number | Long & {
                            add: ((addend) => Long);
                            and: ((other) => Long);
                            clz: (() => number);
                            comp: ((other) => number);
                            compare: ((other) => number);
                            countLeadingZeros: (() => number);
                            countTrailingZeros: (() => number);
                            ctz: (() => number);
                            div: ((divisor) => Long);
                            divide: ((divisor) => Long);
                            eq: ((other) => boolean);
                            equals: ((other) => boolean);
                            eqz: (() => boolean);
                            ge: ((other) => boolean);
                            getHighBits: (() => number);
                            getHighBitsUnsigned: (() => number);
                            getLowBits: (() => number);
                            getLowBitsUnsigned: (() => number);
                            getNumBitsAbs: (() => number);
                            greaterThan: ((other) => boolean);
                            greaterThanOrEqual: ((other) => boolean);
                            gt: ((other) => boolean);
                            gte: ((other) => boolean);
                            high: number;
                            isEven: (() => boolean);
                            isNegative: (() => boolean);
                            isOdd: (() => boolean);
                            isPositive: (() => boolean);
                            isZero: (() => boolean);
                            le: ((other) => boolean);
                            lessThan: ((other) => boolean);
                            lessThanOrEqual: ((other) => boolean);
                            low: number;
                            lt: ((other) => boolean);
                            lte: ((other) => boolean);
                            mod: ((other) => Long);
                            modulo: ((other) => Long);
                            mul: ((multiplier) => Long);
                            multiply: ((multiplier) => Long);
                            ne: ((other) => boolean);
                            neg: (() => Long);
                            negate: (() => Long);
                            neq: ((other) => boolean);
                            not: (() => Long);
                            notEquals: ((other) => boolean);
                            or: ((other) => Long);
                            rem: ((other) => Long);
                            rotateLeft: ((numBits) => Long);
                            rotateRight: ((numBits) => Long);
                            rotl: ((numBits) => Long);
                            rotr: ((numBits) => Long);
                            shiftLeft: ((numBits) => Long);
                            shiftRight: ((numBits) => Long);
                            shiftRightUnsigned: ((numBits) => Long);
                            shl: ((numBits) => Long);
                            shr: ((numBits) => Long);
                            shr_u: ((numBits) => Long);
                            shru: ((numBits) => Long);
                            sub: ((subtrahend) => Long);
                            subtract: ((subtrahend) => Long);
                            toBytes: ((le?) => number[]);
                            toBytesBE: (() => number[]);
                            toBytesLE: (() => number[]);
                            toInt: (() => number);
                            toNumber: (() => number);
                            toSigned: (() => Long);
                            toString: ((radix?) => string);
                            toUnsigned: (() => Long);
                            unsigned: boolean;
                            xor: ((other) => Long);
                        } & {
                            [K_9 in string | number | symbol]: never
                        };
                    } & {
                        [K_17 in string | number | symbol]: never
                    })[] & {
                        [K_18 in string | symbol]: never
                    };
                } & {
                    [K_19 in string | number | symbol]: never
                };
            } & {
                [K_20 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns InitKeystoreRequest

      • toJSON:function
        • Parameters

          • message: InitKeystoreRequest

          Returns unknown

    • res: {
          decode(input, length?) => InitKeystoreResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => InitKeystoreResponse;
          fromPartial<I>(object) => InitKeystoreResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns InitKeystoreResponse

      • encode:function
        • Parameters

          • message: InitKeystoreResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns InitKeystoreResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                error?: {
                    code?: ErrorCode;
                    message?: string;
                };
            } & {
                error?: {
                    code?: ErrorCode;
                    message?: string;
                } & {
                    code?: ErrorCode;
                    message?: string;
                } & {
                    [K in string | number | symbol]: never
                };
            } & {
                [K_1 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns InitKeystoreResponse

      • toJSON:function
        • Parameters

          • message: InitKeystoreResponse

          Returns unknown

  • saveInvites: {
        req: {
            decode(input, length?) => SaveInvitesRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveInvitesRequest;
            fromPartial<I>(object) => SaveInvitesRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SaveInvitesResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveInvitesResponse;
            fromPartial<I>(object) => SaveInvitesResponse;
            toJSON(message) => unknown;
        };
    }

    Take a batch of invite messages and store the TopicKeys for later use in decrypting messages

    • req: {
          decode(input, length?) => SaveInvitesRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SaveInvitesRequest;
          fromPartial<I>(object) => SaveInvitesRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SaveInvitesRequest

      • encode:function
        • Parameters

          • message: SaveInvitesRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SaveInvitesRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    contentTopic?: string;
                    payload?: Uint8Array;
                    timestampNs?: string | number | Long;
                }[];
            } & {
                requests?: {
                    contentTopic?: string;
                    payload?: Uint8Array;
                    timestampNs?: string | number | Long;
                }[] & ({
                    contentTopic?: string;
                    payload?: Uint8Array;
                    timestampNs?: string | number | Long;
                } & {
                    contentTopic?: string;
                    payload?: Uint8Array;
                    timestampNs?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_1 in string | number | symbol]: never
                })[] & {
                    [K_2 in string | symbol]: never
                };
            } & {
                [K_3 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SaveInvitesRequest

      • toJSON:function
        • Parameters

          • message: SaveInvitesRequest

          Returns unknown

    • res: {
          decode(input, length?) => SaveInvitesResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => SaveInvitesResponse;
          fromPartial<I>(object) => SaveInvitesResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SaveInvitesResponse

      • encode:function
        • Parameters

          • message: SaveInvitesResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SaveInvitesResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        conversation?: {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            };
                            createdNs?: string | number | Long;
                            peerAddress?: string;
                            topic?: string;
                        };
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        conversation?: {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            };
                            createdNs?: string | number | Long;
                            peerAddress?: string;
                            topic?: string;
                        };
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        conversation?: {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            };
                            createdNs?: string | number | Long;
                            peerAddress?: string;
                            topic?: string;
                        };
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_5 in string | number | symbol]: never
                    };
                    result?: {
                        conversation?: {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            };
                            createdNs?: string | number | Long;
                            peerAddress?: string;
                            topic?: string;
                        };
                    } & {
                        conversation?: {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            };
                            createdNs?: string | number | Long;
                            peerAddress?: string;
                            topic?: string;
                        } & {
                            context?: {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                };
                            } & {
                                conversationId?: string;
                                metadata?: {
                                    [x: string]: string | undefined;
                                } & {
                                    [x: string]: string | undefined;
                                } & {
                                    [K_1 in symbol]: never
                                };
                            } & {
                                [K_2 in string | number | symbol]: never
                            };
                            createdNs?: string | number | Long & {
                                add: ((addend) => Long);
                                and: ((other) => Long);
                                clz: (() => number);
                                comp: ((other) => number);
                                compare: ((other) => number);
                                countLeadingZeros: (() => number);
                                countTrailingZeros: (() => number);
                                ctz: (() => number);
                                div: ((divisor) => Long);
                                divide: ((divisor) => Long);
                                eq: ((other) => boolean);
                                equals: ((other) => boolean);
                                eqz: (() => boolean);
                                ge: ((other) => boolean);
                                getHighBits: (() => number);
                                getHighBitsUnsigned: (() => number);
                                getLowBits: (() => number);
                                getLowBitsUnsigned: (() => number);
                                getNumBitsAbs: (() => number);
                                greaterThan: ((other) => boolean);
                                greaterThanOrEqual: ((other) => boolean);
                                gt: ((other) => boolean);
                                gte: ((other) => boolean);
                                high: number;
                                isEven: (() => boolean);
                                isNegative: (() => boolean);
                                isOdd: (() => boolean);
                                isPositive: (() => boolean);
                                isZero: (() => boolean);
                                le: ((other) => boolean);
                                lessThan: ((other) => boolean);
                                lessThanOrEqual: ((other) => boolean);
                                low: number;
                                lt: ((other) => boolean);
                                lte: ((other) => boolean);
                                mod: ((other) => Long);
                                modulo: ((other) => Long);
                                mul: ((multiplier) => Long);
                                multiply: ((multiplier) => Long);
                                ne: ((other) => boolean);
                                neg: (() => Long);
                                negate: (() => Long);
                                neq: ((other) => boolean);
                                not: (() => Long);
                                notEquals: ((other) => boolean);
                                or: ((other) => Long);
                                rem: ((other) => Long);
                                rotateLeft: ((numBits) => Long);
                                rotateRight: ((numBits) => Long);
                                rotl: ((numBits) => Long);
                                rotr: ((numBits) => Long);
                                shiftLeft: ((numBits) => Long);
                                shiftRight: ((numBits) => Long);
                                shiftRightUnsigned: ((numBits) => Long);
                                shl: ((numBits) => Long);
                                shr: ((numBits) => Long);
                                shr_u: ((numBits) => Long);
                                shru: ((numBits) => Long);
                                sub: ((subtrahend) => Long);
                                subtract: ((subtrahend) => Long);
                                toBytes: ((le?) => number[]);
                                toBytesBE: (() => number[]);
                                toBytesLE: (() => number[]);
                                toInt: (() => number);
                                toNumber: (() => number);
                                toSigned: (() => Long);
                                toString: ((radix?) => string);
                                toUnsigned: (() => Long);
                                unsigned: boolean;
                                xor: ((other) => Long);
                            } & {
                                [K in string | number | symbol]: never
                            };
                            peerAddress?: string;
                            topic?: string;
                        } & {
                            [K_3 in string | number | symbol]: never
                        };
                    } & {
                        [K_4 in string | number | symbol]: never
                    };
                } & {
                    [K_6 in string | number | symbol]: never
                })[] & {
                    [K_7 in string | symbol]: never
                };
            } & {
                [K_8 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SaveInvitesResponse

      • toJSON:function
        • Parameters

          • message: SaveInvitesResponse

          Returns unknown

  • saveV1Conversations: {
        req: {
            decode(input, length?) => SaveV1ConversationsRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SaveV1ConversationsRequest;
            fromPartial<I>(object) => SaveV1ConversationsRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SaveV1ConversationsResponse;
            encode(_, writer?) => Writer;
            fromJSON(_) => SaveV1ConversationsResponse;
            fromPartial<I>(_) => SaveV1ConversationsResponse;
            toJSON(_) => unknown;
        };
    }

    Save V1 Conversations

    • req: {
          decode(input, length?) => SaveV1ConversationsRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SaveV1ConversationsRequest;
          fromPartial<I>(object) => SaveV1ConversationsRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SaveV1ConversationsRequest

      • encode:function
        • Parameters

          • message: SaveV1ConversationsRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SaveV1ConversationsRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[];
            } & {
                conversations?: {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                }[] & ({
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    };
                    createdNs?: string | number | Long;
                    peerAddress?: string;
                    topic?: string;
                } & {
                    context?: {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        };
                    } & {
                        conversationId?: string;
                        metadata?: {
                            [x: string]: string | undefined;
                        } & {
                            [x: string]: string | undefined;
                        } & {
                            [K_1 in symbol]: never
                        };
                    } & {
                        [K_2 in string | number | symbol]: never
                    };
                    createdNs?: string | number | Long & {
                        add: ((addend) => Long);
                        and: ((other) => Long);
                        clz: (() => number);
                        comp: ((other) => number);
                        compare: ((other) => number);
                        countLeadingZeros: (() => number);
                        countTrailingZeros: (() => number);
                        ctz: (() => number);
                        div: ((divisor) => Long);
                        divide: ((divisor) => Long);
                        eq: ((other) => boolean);
                        equals: ((other) => boolean);
                        eqz: (() => boolean);
                        ge: ((other) => boolean);
                        getHighBits: (() => number);
                        getHighBitsUnsigned: (() => number);
                        getLowBits: (() => number);
                        getLowBitsUnsigned: (() => number);
                        getNumBitsAbs: (() => number);
                        greaterThan: ((other) => boolean);
                        greaterThanOrEqual: ((other) => boolean);
                        gt: ((other) => boolean);
                        gte: ((other) => boolean);
                        high: number;
                        isEven: (() => boolean);
                        isNegative: (() => boolean);
                        isOdd: (() => boolean);
                        isPositive: (() => boolean);
                        isZero: (() => boolean);
                        le: ((other) => boolean);
                        lessThan: ((other) => boolean);
                        lessThanOrEqual: ((other) => boolean);
                        low: number;
                        lt: ((other) => boolean);
                        lte: ((other) => boolean);
                        mod: ((other) => Long);
                        modulo: ((other) => Long);
                        mul: ((multiplier) => Long);
                        multiply: ((multiplier) => Long);
                        ne: ((other) => boolean);
                        neg: (() => Long);
                        negate: (() => Long);
                        neq: ((other) => boolean);
                        not: (() => Long);
                        notEquals: ((other) => boolean);
                        or: ((other) => Long);
                        rem: ((other) => Long);
                        rotateLeft: ((numBits) => Long);
                        rotateRight: ((numBits) => Long);
                        rotl: ((numBits) => Long);
                        rotr: ((numBits) => Long);
                        shiftLeft: ((numBits) => Long);
                        shiftRight: ((numBits) => Long);
                        shiftRightUnsigned: ((numBits) => Long);
                        shl: ((numBits) => Long);
                        shr: ((numBits) => Long);
                        shr_u: ((numBits) => Long);
                        shru: ((numBits) => Long);
                        sub: ((subtrahend) => Long);
                        subtract: ((subtrahend) => Long);
                        toBytes: ((le?) => number[]);
                        toBytesBE: (() => number[]);
                        toBytesLE: (() => number[]);
                        toInt: (() => number);
                        toNumber: (() => number);
                        toSigned: (() => Long);
                        toString: ((radix?) => string);
                        toUnsigned: (() => Long);
                        unsigned: boolean;
                        xor: ((other) => Long);
                    } & {
                        [K in string | number | symbol]: never
                    };
                    peerAddress?: string;
                    topic?: string;
                } & {
                    [K_3 in string | number | symbol]: never
                })[] & {
                    [K_4 in string | symbol]: never
                };
            } & {
                [K_5 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SaveV1ConversationsRequest

      • toJSON:function
        • Parameters

          • message: SaveV1ConversationsRequest

          Returns unknown

    • res: {
          decode(input, length?) => SaveV1ConversationsResponse;
          encode(_, writer?) => Writer;
          fromJSON(_) => SaveV1ConversationsResponse;
          fromPartial<I>(_) => SaveV1ConversationsResponse;
          toJSON(_) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SaveV1ConversationsResponse

      • encode:function
        • Parameters

          • _: SaveV1ConversationsResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • _: any

          Returns SaveV1ConversationsResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                [K in string | number | symbol]: never
            }

          Parameters

          • _: I

          Returns SaveV1ConversationsResponse

      • toJSON:function
        • Parameters

          • _: SaveV1ConversationsResponse

          Returns unknown

  • selfDecrypt: {
        req: {
            decode(input, length?) => SelfDecryptRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfDecryptRequest;
            fromPartial<I>(object) => SelfDecryptRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => DecryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => DecryptResponse;
            fromPartial<I>(object) => DecryptResponse;
            toJSON(message) => unknown;
        };
    }

    Decrypt a batch of messages to yourself

    • req: {
          decode(input, length?) => SelfDecryptRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SelfDecryptRequest;
          fromPartial<I>(object) => SelfDecryptRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SelfDecryptRequest

      • encode:function
        • Parameters

          • message: SelfDecryptRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SelfDecryptRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    payload?: Uint8Array;
                }[];
            } & {
                requests?: {
                    payload?: Uint8Array;
                }[] & ({
                    payload?: Uint8Array;
                } & {
                    payload?: Uint8Array;
                } & {
                    [K in string | number | symbol]: never
                })[] & {
                    [K_1 in string | symbol]: never
                };
            } & {
                [K_2 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SelfDecryptRequest

      • toJSON:function
        • Parameters

          • message: SelfDecryptRequest

          Returns unknown

    • res: {
          decode(input, length?) => DecryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => DecryptResponse;
          fromPartial<I>(object) => DecryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns DecryptResponse

      • encode:function
        • Parameters

          • message: DecryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns DecryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    result?: {
                        decrypted?: Uint8Array;
                    } & {
                        decrypted?: Uint8Array;
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_2 in string | number | symbol]: never
                })[] & {
                    [K_3 in string | symbol]: never
                };
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns DecryptResponse

      • toJSON:function
        • Parameters

          • message: DecryptResponse

          Returns unknown

  • selfEncrypt: {
        req: {
            decode(input, length?) => SelfEncryptRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfEncryptRequest;
            fromPartial<I>(object) => SelfEncryptRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SelfEncryptResponse;
            encode(message, writer?) => Writer;
            fromJSON(object) => SelfEncryptResponse;
            fromPartial<I>(object) => SelfEncryptResponse;
            toJSON(message) => unknown;
        };
    }

    Encrypt a batch of messages to yourself

    • req: {
          decode(input, length?) => SelfEncryptRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SelfEncryptRequest;
          fromPartial<I>(object) => SelfEncryptRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SelfEncryptRequest

      • encode:function
        • Parameters

          • message: SelfEncryptRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SelfEncryptRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                requests?: {
                    payload?: Uint8Array;
                }[];
            } & {
                requests?: {
                    payload?: Uint8Array;
                }[] & ({
                    payload?: Uint8Array;
                } & {
                    payload?: Uint8Array;
                } & {
                    [K in string | number | symbol]: never
                })[] & {
                    [K_1 in string | symbol]: never
                };
            } & {
                [K_2 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SelfEncryptRequest

      • toJSON:function
        • Parameters

          • message: SelfEncryptRequest

          Returns unknown

    • res: {
          decode(input, length?) => SelfEncryptResponse;
          encode(message, writer?) => Writer;
          fromJSON(object) => SelfEncryptResponse;
          fromPartial<I>(object) => SelfEncryptResponse;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SelfEncryptResponse

      • encode:function
        • Parameters

          • message: SelfEncryptResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SelfEncryptResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: Uint8Array;
                    };
                }[];
            } & {
                responses?: {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: Uint8Array;
                    };
                }[] & ({
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    };
                    result?: {
                        encrypted?: Uint8Array;
                    };
                } & {
                    error?: {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        code?: ErrorCode;
                        message?: string;
                    } & {
                        [K_1 in string | number | symbol]: never
                    };
                    result?: {
                        encrypted?: Uint8Array;
                    } & {
                        encrypted?: Uint8Array;
                    } & {
                        [K in string | number | symbol]: never
                    };
                } & {
                    [K_2 in string | number | symbol]: never
                })[] & {
                    [K_3 in string | symbol]: never
                };
            } & {
                [K_4 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SelfEncryptResponse

      • toJSON:function
        • Parameters

          • message: SelfEncryptResponse

          Returns unknown

  • setRefreshJob: {
        req: {
            decode(input, length?) => SetRefeshJobRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SetRefeshJobRequest;
            fromPartial<I>(object) => SetRefeshJobRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => SetRefreshJobResponse;
            encode(_, writer?) => Writer;
            fromJSON(_) => SetRefreshJobResponse;
            fromPartial<I>(_) => SetRefreshJobResponse;
            toJSON(_) => unknown;
        };
    }

    Sets the time of a refresh job

    • req: {
          decode(input, length?) => SetRefeshJobRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SetRefeshJobRequest;
          fromPartial<I>(object) => SetRefeshJobRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SetRefeshJobRequest

      • encode:function
        • Parameters

          • message: SetRefeshJobRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SetRefeshJobRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                jobType?: JobType;
                lastRunNs?: string | number | Long;
            } & {
                jobType?: JobType;
                lastRunNs?: string | number | Long & {
                    add: ((addend) => Long);
                    and: ((other) => Long);
                    clz: (() => number);
                    comp: ((other) => number);
                    compare: ((other) => number);
                    countLeadingZeros: (() => number);
                    countTrailingZeros: (() => number);
                    ctz: (() => number);
                    div: ((divisor) => Long);
                    divide: ((divisor) => Long);
                    eq: ((other) => boolean);
                    equals: ((other) => boolean);
                    eqz: (() => boolean);
                    ge: ((other) => boolean);
                    getHighBits: (() => number);
                    getHighBitsUnsigned: (() => number);
                    getLowBits: (() => number);
                    getLowBitsUnsigned: (() => number);
                    getNumBitsAbs: (() => number);
                    greaterThan: ((other) => boolean);
                    greaterThanOrEqual: ((other) => boolean);
                    gt: ((other) => boolean);
                    gte: ((other) => boolean);
                    high: number;
                    isEven: (() => boolean);
                    isNegative: (() => boolean);
                    isOdd: (() => boolean);
                    isPositive: (() => boolean);
                    isZero: (() => boolean);
                    le: ((other) => boolean);
                    lessThan: ((other) => boolean);
                    lessThanOrEqual: ((other) => boolean);
                    low: number;
                    lt: ((other) => boolean);
                    lte: ((other) => boolean);
                    mod: ((other) => Long);
                    modulo: ((other) => Long);
                    mul: ((multiplier) => Long);
                    multiply: ((multiplier) => Long);
                    ne: ((other) => boolean);
                    neg: (() => Long);
                    negate: (() => Long);
                    neq: ((other) => boolean);
                    not: (() => Long);
                    notEquals: ((other) => boolean);
                    or: ((other) => Long);
                    rem: ((other) => Long);
                    rotateLeft: ((numBits) => Long);
                    rotateRight: ((numBits) => Long);
                    rotl: ((numBits) => Long);
                    rotr: ((numBits) => Long);
                    shiftLeft: ((numBits) => Long);
                    shiftRight: ((numBits) => Long);
                    shiftRightUnsigned: ((numBits) => Long);
                    shl: ((numBits) => Long);
                    shr: ((numBits) => Long);
                    shr_u: ((numBits) => Long);
                    shru: ((numBits) => Long);
                    sub: ((subtrahend) => Long);
                    subtract: ((subtrahend) => Long);
                    toBytes: ((le?) => number[]);
                    toBytesBE: (() => number[]);
                    toBytesLE: (() => number[]);
                    toInt: (() => number);
                    toNumber: (() => number);
                    toSigned: (() => Long);
                    toString: ((radix?) => string);
                    toUnsigned: (() => Long);
                    unsigned: boolean;
                    xor: ((other) => Long);
                } & {
                    [K in string | number | symbol]: never
                };
            } & {
                [K_1 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SetRefeshJobRequest

      • toJSON:function
        • Parameters

          • message: SetRefeshJobRequest

          Returns unknown

    • res: {
          decode(input, length?) => SetRefreshJobResponse;
          encode(_, writer?) => Writer;
          fromJSON(_) => SetRefreshJobResponse;
          fromPartial<I>(_) => SetRefreshJobResponse;
          toJSON(_) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SetRefreshJobResponse

      • encode:function
        • Parameters

          • _: SetRefreshJobResponse
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • _: any

          Returns SetRefreshJobResponse

      • fromPartial:function
        • Type Parameters

          • I extends {
                [K in string | number | symbol]: never
            }

          Parameters

          • _: I

          Returns SetRefreshJobResponse

      • toJSON:function
        • Parameters

          • _: SetRefreshJobResponse

          Returns unknown

  • signDigest: {
        req: {
            decode(input, length?) => SignDigestRequest;
            encode(message, writer?) => Writer;
            fromJSON(object) => SignDigestRequest;
            fromPartial<I>(object) => SignDigestRequest;
            toJSON(message) => unknown;
        };
        res: {
            decode(input, length?) => Signature;
            encode(message, writer?) => Writer;
            fromJSON(object) => Signature;
            fromPartial<I>(object) => Signature;
            toJSON(message) => unknown;
        };
    }

    Sign the provided digest with either the IdentityKey or a specified PreKey

    • req: {
          decode(input, length?) => SignDigestRequest;
          encode(message, writer?) => Writer;
          fromJSON(object) => SignDigestRequest;
          fromPartial<I>(object) => SignDigestRequest;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns SignDigestRequest

      • encode:function
        • Parameters

          • message: SignDigestRequest
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns SignDigestRequest

      • fromPartial:function
        • Type Parameters

          • I extends {
                digest?: Uint8Array;
                identityKey?: boolean;
                prekeyIndex?: number;
            } & {
                digest?: Uint8Array;
                identityKey?: boolean;
                prekeyIndex?: number;
            } & {
                [K in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns SignDigestRequest

      • toJSON:function
        • Parameters

          • message: SignDigestRequest

          Returns unknown

    • res: {
          decode(input, length?) => Signature;
          encode(message, writer?) => Writer;
          fromJSON(object) => Signature;
          fromPartial<I>(object) => Signature;
          toJSON(message) => unknown;
      }
      • decode:function
        • Parameters

          • input: Uint8Array | Reader
          • Optional length: number

          Returns Signature

      • encode:function
        • Parameters

          • message: Signature
          • Optional writer: Writer

          Returns Writer

      • fromJSON:function
        • Parameters

          • object: any

          Returns Signature

      • fromPartial:function
        • Type Parameters

          • I extends {
                ecdsaCompact?: {
                    bytes?: Uint8Array;
                    recovery?: number;
                };
                walletEcdsaCompact?: {
                    bytes?: Uint8Array;
                    recovery?: number;
                };
            } & {
                ecdsaCompact?: {
                    bytes?: Uint8Array;
                    recovery?: number;
                } & {
                    bytes?: Uint8Array;
                    recovery?: number;
                } & {
                    [K in string | number | symbol]: never
                };
                walletEcdsaCompact?: {
                    bytes?: Uint8Array;
                    recovery?: number;
                } & {
                    bytes?: Uint8Array;
                    recovery?: number;
                } & {
                    [K_1 in string | number | symbol]: never
                };
            } & {
                [K_2 in string | number | symbol]: never
            }

          Parameters

          • object: I

          Returns Signature

      • toJSON:function
        • Parameters

          • message: Signature

          Returns unknown

Generated using TypeDoc