@xmtp/proto/ts/dist/esm/identity/api/v1/identity.pb.js

Protobuf client and generated classes for GRPC API

/* eslint-disable */
import { IdentityUpdate, identifierKindFromJSON, identifierKindToJSON, } from "../../associations/association.pb";
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "xmtp.identity.api.v1";
function createBaseVerifySmartContractWalletSignaturesRequest() {
    return { signatures: [] };
}
export const VerifySmartContractWalletSignaturesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.signatures) {
            VerifySmartContractWalletSignatureRequestSignature.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 = createBaseVerifySmartContractWalletSignaturesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signatures.push(VerifySmartContractWalletSignatureRequestSignature.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            signatures: Array.isArray(object === null || object === void 0 ? void 0 : object.signatures)
                ? object.signatures.map((e) => VerifySmartContractWalletSignatureRequestSignature.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.signatures) {
            obj.signatures = message.signatures.map((e) => e
                ? VerifySmartContractWalletSignatureRequestSignature.toJSON(e)
                : undefined);
        }
        else {
            obj.signatures = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseVerifySmartContractWalletSignaturesRequest();
        message.signatures =
            ((_a = object.signatures) === null || _a === void 0 ? void 0 : _a.map((e) => VerifySmartContractWalletSignatureRequestSignature.fromPartial(e))) || [];
        return message;
    },
};
function createBaseVerifySmartContractWalletSignatureRequestSignature() {
    return {
        accountId: "",
        blockNumber: undefined,
        signature: new Uint8Array(),
        hash: new Uint8Array(),
    };
}
export const VerifySmartContractWalletSignatureRequestSignature = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.accountId !== "") {
            writer.uint32(10).string(message.accountId);
        }
        if (message.blockNumber !== undefined) {
            writer.uint32(16).uint64(message.blockNumber);
        }
        if (message.signature.length !== 0) {
            writer.uint32(26).bytes(message.signature);
        }
        if (message.hash.length !== 0) {
            writer.uint32(34).bytes(message.hash);
        }
        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 = createBaseVerifySmartContractWalletSignatureRequestSignature();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.string();
                    break;
                case 2:
                    message.blockNumber = reader.uint64();
                    break;
                case 3:
                    message.signature = reader.bytes();
                    break;
                case 4:
                    message.hash = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            accountId: isSet(object.accountId) ? String(object.accountId) : "",
            blockNumber: isSet(object.blockNumber)
                ? Long.fromValue(object.blockNumber)
                : undefined,
            signature: isSet(object.signature)
                ? bytesFromBase64(object.signature)
                : new Uint8Array(),
            hash: isSet(object.hash)
                ? bytesFromBase64(object.hash)
                : new Uint8Array(),
        };
    },
    toJSON(message) {
        const obj = {};
        message.accountId !== undefined && (obj.accountId = message.accountId);
        message.blockNumber !== undefined &&
            (obj.blockNumber = (message.blockNumber || undefined).toString());
        message.signature !== undefined &&
            (obj.signature = base64FromBytes(message.signature !== undefined ? message.signature : new Uint8Array()));
        message.hash !== undefined &&
            (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
        return obj;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseVerifySmartContractWalletSignatureRequestSignature();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : "";
        message.blockNumber =
            object.blockNumber !== undefined && object.blockNumber !== null
                ? Long.fromValue(object.blockNumber)
                : undefined;
        message.signature = (_b = object.signature) !== null && _b !== void 0 ? _b : new Uint8Array();
        message.hash = (_c = object.hash) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    },
};
function createBaseVerifySmartContractWalletSignaturesResponse() {
    return { responses: [] };
}
export const VerifySmartContractWalletSignaturesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            VerifySmartContractWalletSignaturesResponse_ValidationResponse.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 = createBaseVerifySmartContractWalletSignaturesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(VerifySmartContractWalletSignaturesResponse_ValidationResponse.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) => VerifySmartContractWalletSignaturesResponse_ValidationResponse.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e
                ? VerifySmartContractWalletSignaturesResponse_ValidationResponse.toJSON(e)
                : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseVerifySmartContractWalletSignaturesResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => VerifySmartContractWalletSignaturesResponse_ValidationResponse.fromPartial(e))) || [];
        return message;
    },
};
function createBaseVerifySmartContractWalletSignaturesResponse_ValidationResponse() {
    return { isValid: false, blockNumber: undefined, error: undefined };
}
export const VerifySmartContractWalletSignaturesResponse_ValidationResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.isValid === true) {
            writer.uint32(8).bool(message.isValid);
        }
        if (message.blockNumber !== undefined) {
            writer.uint32(16).uint64(message.blockNumber);
        }
        if (message.error !== undefined) {
            writer.uint32(26).string(message.error);
        }
        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 = createBaseVerifySmartContractWalletSignaturesResponse_ValidationResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isValid = reader.bool();
                    break;
                case 2:
                    message.blockNumber = reader.uint64();
                    break;
                case 3:
                    message.error = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            isValid: isSet(object.isValid) ? Boolean(object.isValid) : false,
            blockNumber: isSet(object.blockNumber)
                ? Long.fromValue(object.blockNumber)
                : undefined,
            error: isSet(object.error) ? String(object.error) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.isValid !== undefined && (obj.isValid = message.isValid);
        message.blockNumber !== undefined &&
            (obj.blockNumber = (message.blockNumber || undefined).toString());
        message.error !== undefined && (obj.error = message.error);
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseVerifySmartContractWalletSignaturesResponse_ValidationResponse();
        message.isValid = (_a = object.isValid) !== null && _a !== void 0 ? _a : false;
        message.blockNumber =
            object.blockNumber !== undefined && object.blockNumber !== null
                ? Long.fromValue(object.blockNumber)
                : undefined;
        message.error = (_b = object.error) !== null && _b !== void 0 ? _b : undefined;
        return message;
    },
};
function createBasePublishIdentityUpdateRequest() {
    return { identityUpdate: undefined };
}
export const PublishIdentityUpdateRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.identityUpdate !== undefined) {
            IdentityUpdate.encode(message.identityUpdate, 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 = createBasePublishIdentityUpdateRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.identityUpdate = IdentityUpdate.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            identityUpdate: isSet(object.identityUpdate)
                ? IdentityUpdate.fromJSON(object.identityUpdate)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.identityUpdate !== undefined &&
            (obj.identityUpdate = message.identityUpdate
                ? IdentityUpdate.toJSON(message.identityUpdate)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBasePublishIdentityUpdateRequest();
        message.identityUpdate =
            object.identityUpdate !== undefined && object.identityUpdate !== null
                ? IdentityUpdate.fromPartial(object.identityUpdate)
                : undefined;
        return message;
    },
};
function createBasePublishIdentityUpdateResponse() {
    return {};
}
export const PublishIdentityUpdateResponse = {
    encode(_, writer = _m0.Writer.create()) {
        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 = createBasePublishIdentityUpdateResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    fromPartial(_) {
        const message = createBasePublishIdentityUpdateResponse();
        return message;
    },
};
function createBaseGetIdentityUpdatesRequest() {
    return { requests: [] };
}
export const GetIdentityUpdatesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            GetIdentityUpdatesRequest_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 = createBaseGetIdentityUpdatesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(GetIdentityUpdatesRequest_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) => GetIdentityUpdatesRequest_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? GetIdentityUpdatesRequest_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetIdentityUpdatesRequest();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => GetIdentityUpdatesRequest_Request.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetIdentityUpdatesRequest_Request() {
    return { inboxId: "", sequenceId: Long.UZERO };
}
export const GetIdentityUpdatesRequest_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.inboxId !== "") {
            writer.uint32(10).string(message.inboxId);
        }
        if (!message.sequenceId.isZero()) {
            writer.uint32(16).uint64(message.sequenceId);
        }
        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 = createBaseGetIdentityUpdatesRequest_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.inboxId = reader.string();
                    break;
                case 2:
                    message.sequenceId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            inboxId: isSet(object.inboxId) ? String(object.inboxId) : "",
            sequenceId: isSet(object.sequenceId)
                ? Long.fromValue(object.sequenceId)
                : Long.UZERO,
        };
    },
    toJSON(message) {
        const obj = {};
        message.inboxId !== undefined && (obj.inboxId = message.inboxId);
        message.sequenceId !== undefined &&
            (obj.sequenceId = (message.sequenceId || Long.UZERO).toString());
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetIdentityUpdatesRequest_Request();
        message.inboxId = (_a = object.inboxId) !== null && _a !== void 0 ? _a : "";
        message.sequenceId =
            object.sequenceId !== undefined && object.sequenceId !== null
                ? Long.fromValue(object.sequenceId)
                : Long.UZERO;
        return message;
    },
};
function createBaseGetIdentityUpdatesResponse() {
    return { responses: [] };
}
export const GetIdentityUpdatesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            GetIdentityUpdatesResponse_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 = createBaseGetIdentityUpdatesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(GetIdentityUpdatesResponse_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) => GetIdentityUpdatesResponse_Response.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e ? GetIdentityUpdatesResponse_Response.toJSON(e) : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetIdentityUpdatesResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => GetIdentityUpdatesResponse_Response.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetIdentityUpdatesResponse_IdentityUpdateLog() {
    return {
        sequenceId: Long.UZERO,
        serverTimestampNs: Long.UZERO,
        update: undefined,
    };
}
export const GetIdentityUpdatesResponse_IdentityUpdateLog = {
    encode(message, writer = _m0.Writer.create()) {
        if (!message.sequenceId.isZero()) {
            writer.uint32(8).uint64(message.sequenceId);
        }
        if (!message.serverTimestampNs.isZero()) {
            writer.uint32(16).uint64(message.serverTimestampNs);
        }
        if (message.update !== undefined) {
            IdentityUpdate.encode(message.update, writer.uint32(26).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 = createBaseGetIdentityUpdatesResponse_IdentityUpdateLog();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sequenceId = reader.uint64();
                    break;
                case 2:
                    message.serverTimestampNs = reader.uint64();
                    break;
                case 3:
                    message.update = IdentityUpdate.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            sequenceId: isSet(object.sequenceId)
                ? Long.fromValue(object.sequenceId)
                : Long.UZERO,
            serverTimestampNs: isSet(object.serverTimestampNs)
                ? Long.fromValue(object.serverTimestampNs)
                : Long.UZERO,
            update: isSet(object.update)
                ? IdentityUpdate.fromJSON(object.update)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.sequenceId !== undefined &&
            (obj.sequenceId = (message.sequenceId || Long.UZERO).toString());
        message.serverTimestampNs !== undefined &&
            (obj.serverTimestampNs = (message.serverTimestampNs || Long.UZERO).toString());
        message.update !== undefined &&
            (obj.update = message.update
                ? IdentityUpdate.toJSON(message.update)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGetIdentityUpdatesResponse_IdentityUpdateLog();
        message.sequenceId =
            object.sequenceId !== undefined && object.sequenceId !== null
                ? Long.fromValue(object.sequenceId)
                : Long.UZERO;
        message.serverTimestampNs =
            object.serverTimestampNs !== undefined &&
                object.serverTimestampNs !== null
                ? Long.fromValue(object.serverTimestampNs)
                : Long.UZERO;
        message.update =
            object.update !== undefined && object.update !== null
                ? IdentityUpdate.fromPartial(object.update)
                : undefined;
        return message;
    },
};
function createBaseGetIdentityUpdatesResponse_Response() {
    return { inboxId: "", updates: [] };
}
export const GetIdentityUpdatesResponse_Response = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.inboxId !== "") {
            writer.uint32(10).string(message.inboxId);
        }
        for (const v of message.updates) {
            GetIdentityUpdatesResponse_IdentityUpdateLog.encode(v, 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 = createBaseGetIdentityUpdatesResponse_Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.inboxId = reader.string();
                    break;
                case 2:
                    message.updates.push(GetIdentityUpdatesResponse_IdentityUpdateLog.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            inboxId: isSet(object.inboxId) ? String(object.inboxId) : "",
            updates: Array.isArray(object === null || object === void 0 ? void 0 : object.updates)
                ? object.updates.map((e) => GetIdentityUpdatesResponse_IdentityUpdateLog.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.inboxId !== undefined && (obj.inboxId = message.inboxId);
        if (message.updates) {
            obj.updates = message.updates.map((e) => e ? GetIdentityUpdatesResponse_IdentityUpdateLog.toJSON(e) : undefined);
        }
        else {
            obj.updates = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseGetIdentityUpdatesResponse_Response();
        message.inboxId = (_a = object.inboxId) !== null && _a !== void 0 ? _a : "";
        message.updates =
            ((_b = object.updates) === null || _b === void 0 ? void 0 : _b.map((e) => GetIdentityUpdatesResponse_IdentityUpdateLog.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetInboxIdsRequest() {
    return { requests: [] };
}
export const GetInboxIdsRequest = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.requests) {
            GetInboxIdsRequest_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 = createBaseGetInboxIdsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requests.push(GetInboxIdsRequest_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) => GetInboxIdsRequest_Request.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requests) {
            obj.requests = message.requests.map((e) => e ? GetInboxIdsRequest_Request.toJSON(e) : undefined);
        }
        else {
            obj.requests = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetInboxIdsRequest();
        message.requests =
            ((_a = object.requests) === null || _a === void 0 ? void 0 : _a.map((e) => GetInboxIdsRequest_Request.fromPartial(e))) ||
                [];
        return message;
    },
};
function createBaseGetInboxIdsRequest_Request() {
    return { identifier: "", identifierKind: 0 };
}
export const GetInboxIdsRequest_Request = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.identifier !== "") {
            writer.uint32(10).string(message.identifier);
        }
        if (message.identifierKind !== 0) {
            writer.uint32(16).int32(message.identifierKind);
        }
        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 = createBaseGetInboxIdsRequest_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.identifier = reader.string();
                    break;
                case 2:
                    message.identifierKind = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            identifier: isSet(object.identifier) ? String(object.identifier) : "",
            identifierKind: isSet(object.identifierKind)
                ? identifierKindFromJSON(object.identifierKind)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.identifier !== undefined && (obj.identifier = message.identifier);
        message.identifierKind !== undefined &&
            (obj.identifierKind = identifierKindToJSON(message.identifierKind));
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseGetInboxIdsRequest_Request();
        message.identifier = (_a = object.identifier) !== null && _a !== void 0 ? _a : "";
        message.identifierKind = (_b = object.identifierKind) !== null && _b !== void 0 ? _b : 0;
        return message;
    },
};
function createBaseGetInboxIdsResponse() {
    return { responses: [] };
}
export const GetInboxIdsResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.responses) {
            GetInboxIdsResponse_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 = createBaseGetInboxIdsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.responses.push(GetInboxIdsResponse_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) => GetInboxIdsResponse_Response.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.responses) {
            obj.responses = message.responses.map((e) => e ? GetInboxIdsResponse_Response.toJSON(e) : undefined);
        }
        else {
            obj.responses = [];
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseGetInboxIdsResponse();
        message.responses =
            ((_a = object.responses) === null || _a === void 0 ? void 0 : _a.map((e) => GetInboxIdsResponse_Response.fromPartial(e))) || [];
        return message;
    },
};
function createBaseGetInboxIdsResponse_Response() {
    return { identifier: "", inboxId: undefined, identifierKind: 0 };
}
export const GetInboxIdsResponse_Response = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.identifier !== "") {
            writer.uint32(10).string(message.identifier);
        }
        if (message.inboxId !== undefined) {
            writer.uint32(18).string(message.inboxId);
        }
        if (message.identifierKind !== 0) {
            writer.uint32(24).int32(message.identifierKind);
        }
        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 = createBaseGetInboxIdsResponse_Response();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.identifier = reader.string();
                    break;
                case 2:
                    message.inboxId = reader.string();
                    break;
                case 3:
                    message.identifierKind = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            identifier: isSet(object.identifier) ? String(object.identifier) : "",
            inboxId: isSet(object.inboxId) ? String(object.inboxId) : undefined,
            identifierKind: isSet(object.identifierKind)
                ? identifierKindFromJSON(object.identifierKind)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.identifier !== undefined && (obj.identifier = message.identifier);
        message.inboxId !== undefined && (obj.inboxId = message.inboxId);
        message.identifierKind !== undefined &&
            (obj.identifierKind = identifierKindToJSON(message.identifierKind));
        return obj;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseGetInboxIdsResponse_Response();
        message.identifier = (_a = object.identifier) !== null && _a !== void 0 ? _a : "";
        message.inboxId = (_b = object.inboxId) !== null && _b !== void 0 ? _b : undefined;
        message.identifierKind = (_c = object.identifierKind) !== null && _c !== void 0 ? _c : 0;
        return message;
    },
};
export class IdentityApiClientImpl {
    constructor(rpc) {
        this.rpc = rpc;
        this.PublishIdentityUpdate = this.PublishIdentityUpdate.bind(this);
        this.GetIdentityUpdates = this.GetIdentityUpdates.bind(this);
        this.GetInboxIds = this.GetInboxIds.bind(this);
        this.VerifySmartContractWalletSignatures =
            this.VerifySmartContractWalletSignatures.bind(this);
    }
    PublishIdentityUpdate(request) {
        const data = PublishIdentityUpdateRequest.encode(request).finish();
        const promise = this.rpc.request("xmtp.identity.api.v1.IdentityApi", "PublishIdentityUpdate", data);
        return promise.then((data) => PublishIdentityUpdateResponse.decode(new _m0.Reader(data)));
    }
    GetIdentityUpdates(request) {
        const data = GetIdentityUpdatesRequest.encode(request).finish();
        const promise = this.rpc.request("xmtp.identity.api.v1.IdentityApi", "GetIdentityUpdates", data);
        return promise.then((data) => GetIdentityUpdatesResponse.decode(new _m0.Reader(data)));
    }
    GetInboxIds(request) {
        const data = GetInboxIdsRequest.encode(request).finish();
        const promise = this.rpc.request("xmtp.identity.api.v1.IdentityApi", "GetInboxIds", data);
        return promise.then((data) => GetInboxIdsResponse.decode(new _m0.Reader(data)));
    }
    VerifySmartContractWalletSignatures(request) {
        const data = VerifySmartContractWalletSignaturesRequest.encode(request).finish();
        const promise = this.rpc.request("xmtp.identity.api.v1.IdentityApi", "VerifySmartContractWalletSignatures", data);
        return promise.then((data) => VerifySmartContractWalletSignaturesResponse.decode(new _m0.Reader(data)));
    }
}
var globalThis = (() => {
    if (typeof globalThis !== "undefined")
        return globalThis;
    if (typeof self !== "undefined")
        return self;
    if (typeof window !== "undefined")
        return window;
    if (typeof global !== "undefined")
        return global;
    throw "Unable to locate global object";
})();
function bytesFromBase64(b64) {
    if (globalThis.Buffer) {
        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
    }
    else {
        const bin = globalThis.atob(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
            arr[i] = bin.charCodeAt(i);
        }
        return arr;
    }
}
function base64FromBytes(arr) {
    if (globalThis.Buffer) {
        return globalThis.Buffer.from(arr).toString("base64");
    }
    else {
        const bin = [];
        arr.forEach((byte) => {
            bin.push(String.fromCharCode(byte));
        });
        return globalThis.btoa(bin.join(""));
    }
}
if (_m0.util.Long !== Long) {
    _m0.util.Long = Long;
    _m0.configure();
}
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=identity.pb.js.map