@xmtp/proto/ts/dist/esm/keystore_api/v1/keystore.pb.js

Protobuf client and generated classes for GRPC API

/* eslint-disable */
import Long from "long";
import { Ciphertext } from "../../message_contents/ciphertext.pb";
import { PublicKeyBundle, SignedPublicKeyBundle, } from "../../message_contents/public_key.pb";
import { InvitationV1_Context, ConsentProofPayload, InvitationV1, } from "../../message_contents/invitation.pb";
import { ConversationReference } from "../../message_contents/conversation_reference.pb";
import { PrivateKeyBundleV1 } from "../../message_contents/private_key.pb";
import { PrivatePreferencesAction } from "../../message_contents/private_preferences.pb";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "xmtp.keystore_api.v1";
/** Message content encoding structures */
/** Application-specific error codes for the Keystore API. */
export var ErrorCode;
(function (ErrorCode) {
    ErrorCode[ErrorCode["ERROR_CODE_UNSPECIFIED"] = 0] = "ERROR_CODE_UNSPECIFIED";
    ErrorCode[ErrorCode["ERROR_CODE_INVALID_INPUT"] = 1] = "ERROR_CODE_INVALID_INPUT";
    ErrorCode[ErrorCode["ERROR_CODE_NO_MATCHING_PREKEY"] = 2] = "ERROR_CODE_NO_MATCHING_PREKEY";
    ErrorCode[ErrorCode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ErrorCode || (ErrorCode = {}));
export function errorCodeFromJSON(object) {
    switch (object) {
        case 0:
        case "ERROR_CODE_UNSPECIFIED":
            return ErrorCode.ERROR_CODE_UNSPECIFIED;
        case 1:
        case "ERROR_CODE_INVALID_INPUT":
            return ErrorCode.ERROR_CODE_INVALID_INPUT;
        case 2:
        case "ERROR_CODE_NO_MATCHING_PREKEY":
            return ErrorCode.ERROR_CODE_NO_MATCHING_PREKEY;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ErrorCode.UNRECOGNIZED;
    }
}
export function errorCodeToJSON(object) {
    switch (object) {
        case ErrorCode.ERROR_CODE_UNSPECIFIED:
            return "ERROR_CODE_UNSPECIFIED";
        case ErrorCode.ERROR_CODE_INVALID_INPUT:
            return "ERROR_CODE_INVALID_INPUT";
        case ErrorCode.ERROR_CODE_NO_MATCHING_PREKEY:
            return "ERROR_CODE_NO_MATCHING_PREKEY";
        case ErrorCode.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
/** JobType is used to specify the type of job the caller would like info on */
export var JobType;
(function (JobType) {
    JobType[JobType["JOB_TYPE_UNSPECIFIED"] = 0] = "JOB_TYPE_UNSPECIFIED";
    JobType[JobType["JOB_TYPE_REFRESH_V1"] = 1] = "JOB_TYPE_REFRESH_V1";
    JobType[JobType["JOB_TYPE_REFRESH_V2"] = 2] = "JOB_TYPE_REFRESH_V2";
    JobType[JobType["JOB_TYPE_REFRESH_PPPP"] = 3] = "JOB_TYPE_REFRESH_PPPP";
    JobType[JobType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(JobType || (JobType = {}));
export function jobTypeFromJSON(object) {
    switch (object) {
        case 0:
        case "JOB_TYPE_UNSPECIFIED":
            return JobType.JOB_TYPE_UNSPECIFIED;
        case 1:
        case "JOB_TYPE_REFRESH_V1":
            return JobType.JOB_TYPE_REFRESH_V1;
        case 2:
        case "JOB_TYPE_REFRESH_V2":
            return JobType.JOB_TYPE_REFRESH_V2;
        case 3:
        case "JOB_TYPE_REFRESH_PPPP":
            return JobType.JOB_TYPE_REFRESH_PPPP;
        case -1:
        case "UNRECOGNIZED":
        default:
            return JobType.UNRECOGNIZED;
    }
}
export function jobTypeToJSON(object) {
    switch (object) {
        case JobType.JOB_TYPE_UNSPECIFIED:
            return "JOB_TYPE_UNSPECIFIED";
        case JobType.JOB_TYPE_REFRESH_V1:
            return "JOB_TYPE_REFRESH_V1";
        case JobType.JOB_TYPE_REFRESH_V2:
            return "JOB_TYPE_REFRESH_V2";
        case JobType.JOB_TYPE_REFRESH_PPPP:
            return "JOB_TYPE_REFRESH_PPPP";
        case JobType.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
/** Status of the Keystore for the specified wallet address */
export var GetKeystoreStatusResponse_KeystoreStatus;
(function (GetKeystoreStatusResponse_KeystoreStatus) {
    GetKeystoreStatusResponse_KeystoreStatus[GetKeystoreStatusResponse_KeystoreStatus["KEYSTORE_STATUS_UNSPECIFIED"] = 0] = "KEYSTORE_STATUS_UNSPECIFIED";
    GetKeystoreStatusResponse_KeystoreStatus[GetKeystoreStatusResponse_KeystoreStatus["KEYSTORE_STATUS_UNINITIALIZED"] = 1] = "KEYSTORE_STATUS_UNINITIALIZED";
    GetKeystoreStatusResponse_KeystoreStatus[GetKeystoreStatusResponse_KeystoreStatus["KEYSTORE_STATUS_INITIALIZED"] = 2] = "KEYSTORE_STATUS_INITIALIZED";
    GetKeystoreStatusResponse_KeystoreStatus[GetKeystoreStatusResponse_KeystoreStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(GetKeystoreStatusResponse_KeystoreStatus || (GetKeystoreStatusResponse_KeystoreStatus = {}));
export function getKeystoreStatusResponse_KeystoreStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "KEYSTORE_STATUS_UNSPECIFIED":
            return GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_UNSPECIFIED;
        case 1:
        case "KEYSTORE_STATUS_UNINITIALIZED":
            return GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_UNINITIALIZED;
        case 2:
        case "KEYSTORE_STATUS_INITIALIZED":
            return GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_INITIALIZED;
        case -1:
        case "UNRECOGNIZED":
        default:
            return GetKeystoreStatusResponse_KeystoreStatus.UNRECOGNIZED;
    }
}
export function getKeystoreStatusResponse_KeystoreStatusToJSON(object) {
    switch (object) {
        case GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_UNSPECIFIED:
            return "KEYSTORE_STATUS_UNSPECIFIED";
        case GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_UNINITIALIZED:
            return "KEYSTORE_STATUS_UNINITIALIZED";
        case GetKeystoreStatusResponse_KeystoreStatus.KEYSTORE_STATUS_INITIALIZED:
            return "KEYSTORE_STATUS_INITIALIZED";
        case GetKeystoreStatusResponse_KeystoreStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
function createBaseKeystoreError() {
    return { message: "", code: 0 };
}
export const KeystoreError = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.message !== "") {
            writer.uint32(10).string(message.message);
        }
        if (message.code !== 0) {
            writer.uint32(16).int32(message.code);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseKeystoreError();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.message = reader.string();
                    break;
                case 2:
                    message.code = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            message: isSet(object.message) ? String(object.message) : "",
            code: isSet(object.code) ? errorCodeFromJSON(object.code) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.message !== undefined && (obj.message = message.message);
        message.code !== undefined && (obj.code = errorCodeToJSON(message.code));
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseKeystoreError();
        message.message = (_a = object.message) !== null && _a !== void 0 ? _a : "";
        message.code = (_b = object.code) !== null && _b !== void 0 ? _b : 0;
        return message;
    },
};
function createBaseDecryptV1Request() {
    return { requests: [] };
}
export const DecryptV1Request = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            DecryptV1Request_Request.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptV1Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(DecryptV1Request_Request.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            requests: Array.isArray(object === null || object === void 0 ? void 0 : object.requests)
                ? object.requests.map((e) => DecryptV1Request_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? DecryptV1Request_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseDecryptV1Request();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => DecryptV1Request_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseDecryptV1Request_Request() {
    return {
        payload: undefined,
        peerKeys: undefined,
        headerBytes: new Uint8Array(),
        isSender: false,
    };
}
export const DecryptV1Request_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.payload !== undefined) {
            Ciphertext.encode(message.payload, writer.uint32(10).fork()).ldelim();
        }
        if (message.peerKeys !== undefined) {
            PublicKeyBundle.encode(message.peerKeys, writer.uint32(18).fork()).ldelim();
        }
        if (message.headerBytes.length !== 0) {
            writer.uint32(26).bytes(message.headerBytes);
        }
        if (message.isSender === true) {
            writer.uint32(32).bool(message.isSender);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptV1Request_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.payload = Ciphertext.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.peerKeys = PublicKeyBundle.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.headerBytes = reader.bytes();
                    break;
                case 4:
                    message.isSender = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            payload: isSet(object.payload)
                ? Ciphertext.fromJSON(object.payload)
                : undefined,
            peerKeys: isSet(object.peerKeys)
                ? PublicKeyBundle.fromJSON(object.peerKeys)
                : undefined,
            headerBytes: isSet(object.headerBytes)
                ? bytesFromBase64(object.headerBytes)
                : new Uint8Array(),
            isSender: isSet(object.isSender) ? Boolean(object.isSender) : false,
        };
    },
    toJSON(message) {
        const obj = {};
        message.payload !== undefined &&
            (obj.payload = message.payload
                ? Ciphertext.toJSON(message.payload)
                : undefined);
        message.peerKeys !== undefined &&
            (obj.peerKeys = message.peerKeys
                ? PublicKeyBundle.toJSON(message.peerKeys)
                : undefined);
        message.headerBytes !== undefined &&
            (obj.headerBytes = base64FromBytes(message.headerBytes !== undefined
                ? message.headerBytes
                : new Uint8Array()));
        message.isSender !== undefined && (obj.isSender = message.isSender);
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseDecryptV1Request_Request();
        message.payload =
            object.payload !== undefined && object.payload !== null
                ? Ciphertext.fromPartial(object.payload)
                : undefined;
        message.peerKeys =
            object.peerKeys !== undefined && object.peerKeys !== null
                ? PublicKeyBundle.fromPartial(object.peerKeys)
                : undefined;
        message.headerBytes = (_a = object.headerBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.isSender = (_b = object.isSender) !== null && _b !== void 0 ? _b : false;
        return message;
    },
};
function createBaseDecryptResponse() {
    return { responses: [] };
}
export const DecryptResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            DecryptResponse_Response.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(DecryptResponse_Response.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            responses: Array.isArray(object === null || object === void 0 ? void 0 : object.responses)
                ? object.responses.map((e) => DecryptResponse_Response.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e ? DecryptResponse_Response.toJSON(e) : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseDecryptResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => DecryptResponse_Response.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseDecryptResponse_Response() {
    return { result: undefined, error: undefined };
}
export const DecryptResponse_Response = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.result !== undefined) {
            DecryptResponse_Response_Success.encode(message.result, writer.uint32(10).fork()).ldelim();
        }
        if (message.error !== undefined) {
            KeystoreError.encode(message.error, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptResponse_Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.result = DecryptResponse_Response_Success.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.error = KeystoreError.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            result: isSet(object.result)
                ? DecryptResponse_Response_Success.fromJSON(object.result)
                : undefined,
            error: isSet(object.error)
                ? KeystoreError.fromJSON(object.error)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.result !== undefined &&
            (obj.result = message.result
                ? DecryptResponse_Response_Success.toJSON(message.result)
                : undefined);
        message.error !== undefined &&
            (obj.error = message.error
                ? KeystoreError.toJSON(message.error)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseDecryptResponse_Response();
        message.result =
            object.result !== undefined && object.result !== null
                ? DecryptResponse_Response_Success.fromPartial(object.result)
                : undefined;
        message.error =
            object.error !== undefined && object.error !== null
                ? KeystoreError.fromPartial(object.error)
                : undefined;
        return message;
    },
};
function createBaseDecryptResponse_Response_Success() {
    return { decrypted: new Uint8Array() };
}
export const DecryptResponse_Response_Success = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.decrypted.length !== 0) {
            writer.uint32(10).bytes(message.decrypted);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptResponse_Response_Success();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.decrypted = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            decrypted: isSet(object.decrypted)
                ? bytesFromBase64(object.decrypted)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.decrypted !== undefined &&
            (obj.decrypted = base64FromBytes(message.decrypted !== undefined ? message.decrypted : new Uint8Array()));
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseDecryptResponse_Response_Success();
        message.decrypted = (_a = object.decrypted) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    },
};
function createBaseDecryptV2Request() {
    return { requests: [] };
}
export const DecryptV2Request = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            DecryptV2Request_Request.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptV2Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(DecryptV2Request_Request.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            requests: Array.isArray(object === null || object === void 0 ? void 0 : object.requests)
                ? object.requests.map((e) => DecryptV2Request_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? DecryptV2Request_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseDecryptV2Request();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => DecryptV2Request_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseDecryptV2Request_Request() {
    return {
        payload: undefined,
        headerBytes: new Uint8Array(),
        contentTopic: "",
    };
}
export const DecryptV2Request_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.payload !== undefined) {
            Ciphertext.encode(message.payload, writer.uint32(10).fork()).ldelim();
        }
        if (message.headerBytes.length !== 0) {
            writer.uint32(18).bytes(message.headerBytes);
        }
        if (message.contentTopic !== "") {
            writer.uint32(26).string(message.contentTopic);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDecryptV2Request_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.payload = Ciphertext.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.headerBytes = reader.bytes();
                    break;
                case 3:
                    message.contentTopic = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            payload: isSet(object.payload)
                ? Ciphertext.fromJSON(object.payload)
                : undefined,
            headerBytes: isSet(object.headerBytes)
                ? bytesFromBase64(object.headerBytes)
                : new Uint8Array(),
            contentTopic: isSet(object.contentTopic)
                ? String(object.contentTopic)
                : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.payload !== undefined &&
            (obj.payload = message.payload
                ? Ciphertext.toJSON(message.payload)
                : undefined);
        message.headerBytes !== undefined &&
            (obj.headerBytes = base64FromBytes(message.headerBytes !== undefined
                ? message.headerBytes
                : new Uint8Array()));
        message.contentTopic !== undefined &&
            (obj.contentTopic = message.contentTopic);
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseDecryptV2Request_Request();
        message.payload =
            object.payload !== undefined && object.payload !== null
                ? Ciphertext.fromPartial(object.payload)
                : undefined;
        message.headerBytes = (_a = object.headerBytes) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.contentTopic = (_b = object.contentTopic) !== null && _b !== void 0 ? _b : "";
        return message;
    },
};
function createBaseEncryptV1Request() {
    return { requests: [] };
}
export const EncryptV1Request = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            EncryptV1Request_Request.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptV1Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(EncryptV1Request_Request.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            requests: Array.isArray(object === null || object === void 0 ? void 0 : object.requests)
                ? object.requests.map((e) => EncryptV1Request_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? EncryptV1Request_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseEncryptV1Request();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => EncryptV1Request_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseEncryptV1Request_Request() {
    return {
        recipient: undefined,
        payload: new Uint8Array(),
        headerBytes: new Uint8Array(),
    };
}
export const EncryptV1Request_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.recipient !== undefined) {
            PublicKeyBundle.encode(message.recipient, writer.uint32(10).fork()).ldelim();
        }
        if (message.payload.length !== 0) {
            writer.uint32(18).bytes(message.payload);
        }
        if (message.headerBytes.length !== 0) {
            writer.uint32(26).bytes(message.headerBytes);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptV1Request_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.recipient = PublicKeyBundle.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.payload = reader.bytes();
                    break;
                case 3:
                    message.headerBytes = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            recipient: isSet(object.recipient)
                ? PublicKeyBundle.fromJSON(object.recipient)
                : undefined,
            payload: isSet(object.payload)
                ? bytesFromBase64(object.payload)
                : new Uint8Array(),
            headerBytes: isSet(object.headerBytes)
                ? bytesFromBase64(object.headerBytes)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.recipient !== undefined &&
            (obj.recipient = message.recipient
                ? PublicKeyBundle.toJSON(message.recipient)
                : undefined);
        message.payload !== undefined &&
            (obj.payload = base64FromBytes(message.payload !== undefined ? message.payload : new Uint8Array()));
        message.headerBytes !== undefined &&
            (obj.headerBytes = base64FromBytes(message.headerBytes !== undefined
                ? message.headerBytes
                : new Uint8Array()));
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseEncryptV1Request_Request();
        message.recipient =
            object.recipient !== undefined && object.recipient !== null
                ? PublicKeyBundle.fromPartial(object.recipient)
                : undefined;
        message.payload = (_a = object.payload) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.headerBytes = (_b = object.headerBytes) !== null && _b !== void 0 ? _b : new Uint8Array();
        return message;
    },
};
function createBaseEncryptResponse() {
    return { responses: [] };
}
export const EncryptResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            EncryptResponse_Response.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(EncryptResponse_Response.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            responses: Array.isArray(object === null || object === void 0 ? void 0 : object.responses)
                ? object.responses.map((e) => EncryptResponse_Response.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e ? EncryptResponse_Response.toJSON(e) : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseEncryptResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => EncryptResponse_Response.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseEncryptResponse_Response() {
    return { result: undefined, error: undefined };
}
export const EncryptResponse_Response = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.result !== undefined) {
            EncryptResponse_Response_Success.encode(message.result, writer.uint32(10).fork()).ldelim();
        }
        if (message.error !== undefined) {
            KeystoreError.encode(message.error, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptResponse_Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.result = EncryptResponse_Response_Success.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.error = KeystoreError.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            result: isSet(object.result)
                ? EncryptResponse_Response_Success.fromJSON(object.result)
                : undefined,
            error: isSet(object.error)
                ? KeystoreError.fromJSON(object.error)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.result !== undefined &&
            (obj.result = message.result
                ? EncryptResponse_Response_Success.toJSON(message.result)
                : undefined);
        message.error !== undefined &&
            (obj.error = message.error
                ? KeystoreError.toJSON(message.error)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseEncryptResponse_Response();
        message.result =
            object.result !== undefined && object.result !== null
                ? EncryptResponse_Response_Success.fromPartial(object.result)
                : undefined;
        message.error =
            object.error !== undefined && object.error !== null
                ? KeystoreError.fromPartial(object.error)
                : undefined;
        return message;
    },
};
function createBaseEncryptResponse_Response_Success() {
    return { encrypted: undefined, senderHmac: new Uint8Array() };
}
export const EncryptResponse_Response_Success = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.encrypted !== undefined) {
            Ciphertext.encode(message.encrypted, writer.uint32(10).fork()).ldelim();
        }
        if (message.senderHmac.length !== 0) {
            writer.uint32(18).bytes(message.senderHmac);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptResponse_Response_Success();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.encrypted = Ciphertext.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.senderHmac = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            encrypted: isSet(object.encrypted)
                ? Ciphertext.fromJSON(object.encrypted)
                : undefined,
            senderHmac: isSet(object.senderHmac)
                ? bytesFromBase64(object.senderHmac)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.encrypted !== undefined &&
            (obj.encrypted = message.encrypted
                ? Ciphertext.toJSON(message.encrypted)
                : undefined);
        message.senderHmac !== undefined &&
            (obj.senderHmac = base64FromBytes(message.senderHmac !== undefined ? message.senderHmac : new Uint8Array()));
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseEncryptResponse_Response_Success();
        message.encrypted =
            object.encrypted !== undefined && object.encrypted !== null
                ? Ciphertext.fromPartial(object.encrypted)
                : undefined;
        message.senderHmac = (_a = object.senderHmac) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    },
};
function createBaseEncryptV2Request() {
    return { requests: [] };
}
export const EncryptV2Request = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            EncryptV2Request_Request.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptV2Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(EncryptV2Request_Request.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            requests: Array.isArray(object === null || object === void 0 ? void 0 : object.requests)
                ? object.requests.map((e) => EncryptV2Request_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? EncryptV2Request_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseEncryptV2Request();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => EncryptV2Request_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseEncryptV2Request_Request() {
    return {
        payload: new Uint8Array(),
        headerBytes: new Uint8Array(),
        contentTopic: "",
    };
}
export const EncryptV2Request_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.payload.length !== 0) {
            writer.uint32(10).bytes(message.payload);
        }
        if (message.headerBytes.length !== 0) {
            writer.uint32(18).bytes(message.headerBytes);
        }
        if (message.contentTopic !== "") {
            writer.uint32(26).string(message.contentTopic);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncryptV2Request_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.payload = reader.bytes();
                    break;
                case 2:
                    message.headerBytes = reader.bytes();
                    break;
                case 3:
                    message.contentTopic = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            payload: isSet(object.payload)
                ? bytesFromBase64(object.payload)
                : new Uint8Array(),
            headerBytes: isSet(object.headerBytes)
                ? bytesFromBase64(object.headerBytes)
                : new Uint8Array(),
            contentTopic: isSet(object.contentTopic)
                ? String(object.contentTopic)
                : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.payload !== undefined &&
            (obj.payload = base64FromBytes(message.payload !== undefined ? message.payload : new Uint8Array()));
        message.headerBytes !== undefined &&
            (obj.headerBytes = base64FromBytes(message.headerBytes !== undefined
                ? message.headerBytes
                : new Uint8Array()));
        message.contentTopic !== undefined &&
            (obj.contentTopic = message.contentTopic);
        return obj;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseEncryptV2Request_Request();
        message.payload = (_a = object.payload) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.headerBytes = (_b = object.headerBytes) !== null && _b !== void 0 ? _b : new Uint8Array();
        message.contentTopic = (_c = object.contentTopic) !== null && _c !== void 0 ? _c : "";
        return message;
    },
};
function createBaseSelfEncryptRequest() {
    return { requests: [] };
}
export const SelfEncryptRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            SelfEncryptRequest_Request.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSelfEncryptRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(SelfEncryptRequest_Request.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            requests: Array.isArray(object === null || object === void 0 ? void 0 : object.requests)
                ? object.requests.map((e) => SelfEncryptRequest_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? SelfEncryptRequest_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseSelfEncryptRequest();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => SelfEncryptRequest_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseSelfEncryptRequest_Request() {
    return { payload: new Uint8Array() };
}
export const SelfEncryptRequest_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.payload.length !== 0) {
            writer.uint32(10).bytes(message.payload);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSelfEncryptRequest_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.payload = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            payload: isSet(object.payload)
                ? bytesFromBase64(object.payload)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.payload !== undefined &&
            (obj.payload = base64FromBytes(message.payload !== undefined ? message.payload : new Uint8Array()));
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseSelfEncryptRequest_Request();
        message.payload = (_a = object.payload) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    },
};
function createBaseSelfEncryptResponse() {
    return { responses: [] };
}
export const SelfEncryptResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            SelfEncryptResponse_Response.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSelfEncryptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(SelfEncryptResponse_Response.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            responses: Array.isArray(object === null || object === void 0 ? void 0 : object.responses)
                ? object.responses.map((e) => SelfEncryptResponse_Response.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e ? SelfEncryptResponse_Response.toJSON(e) : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseSelfEncryptResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => SelfEncryptResponse_Response.fromPartial(e))) || [];
        return message;
    },
};
function createBaseSelfEncryptResponse_Response() {
    return { result: undefined, error: undefined };
}
export const SelfEncryptResponse_Response = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.result !== undefined) {
            SelfEncryptResponse_Response_Success.encode(message.result, writer.uint32(10).fork()).ldelim();
        }
        if (message.error !== undefined) {
            KeystoreError.encode(message.error, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSelfEncryptResponse_Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.result = SelfEncryptResponse_Response_Success.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.error = KeystoreError.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            result: isSet(object.result)
                ? SelfEncryptResponse_Response_Success.fromJSON(object.result)
                : undefined,
            error: isSet(object.error)
                ? KeystoreError.fromJSON(object.error)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.result !== undefined &&
            (obj.result = message.result
                ? SelfEncryptResponse_Response_Success.toJSON(message.result)
                : undefined);
        message.error !== undefined &&
            (obj.error = message.error
                ? KeystoreError.toJSON(message.error)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSelfEncryptResponse_Response();
        message.result =
            object.result !== undefined && object.result !== null
                ? SelfEncryptResponse_Response_Success.fromPartial(object.result)
                : undefined;
        message.error =
            object.error !== undefined && object.error !== null
                ? KeystoreError.fromPartial(object.error)
                : undefined;
        return message;
    },
};
function createBaseSelfEncryptResponse_Response_Success() {
    return { encrypted: new Uint8Array() };
}
export const SelfEncryptResponse_Response_Success = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.encrypted.length !== 0) {
            writer.uint32(10).bytes(message.encrypted);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSelfEncryptResponse_Response_Success();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.encrypted = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            encrypted: isSet(object.encrypted)
                ? bytesFromBase64(object.encrypted)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.encrypted !== undefined &&