@xmtp/proto/ts/dist/esm/identity/associations/association.pb.js

Protobuf client and generated classes for GRPC API

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v1.181.2
//   protoc               v3.21.12
// source: identity/associations/association.proto
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Signature } from "./signature.pb";
export const protobufPackage = "xmtp.identity.associations";
/** Payloads to be signed for identity associations */
/** List of identity kinds */
export var IdentifierKind;
(function (IdentifierKind) {
    /** IDENTIFIER_KIND_UNSPECIFIED - Ethereum on old clients */
    IdentifierKind[IdentifierKind["IDENTIFIER_KIND_UNSPECIFIED"] = 0] = "IDENTIFIER_KIND_UNSPECIFIED";
    IdentifierKind[IdentifierKind["IDENTIFIER_KIND_ETHEREUM"] = 1] = "IDENTIFIER_KIND_ETHEREUM";
    IdentifierKind[IdentifierKind["IDENTIFIER_KIND_PASSKEY"] = 2] = "IDENTIFIER_KIND_PASSKEY";
    IdentifierKind[IdentifierKind["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(IdentifierKind || (IdentifierKind = {}));
export function identifierKindFromJSON(object) {
    switch (object) {
        case 0:
        case "IDENTIFIER_KIND_UNSPECIFIED":
            return IdentifierKind.IDENTIFIER_KIND_UNSPECIFIED;
        case 1:
        case "IDENTIFIER_KIND_ETHEREUM":
            return IdentifierKind.IDENTIFIER_KIND_ETHEREUM;
        case 2:
        case "IDENTIFIER_KIND_PASSKEY":
            return IdentifierKind.IDENTIFIER_KIND_PASSKEY;
        case -1:
        case "UNRECOGNIZED":
        default:
            return IdentifierKind.UNRECOGNIZED;
    }
}
export function identifierKindToJSON(object) {
    switch (object) {
        case IdentifierKind.IDENTIFIER_KIND_UNSPECIFIED:
            return "IDENTIFIER_KIND_UNSPECIFIED";
        case IdentifierKind.IDENTIFIER_KIND_ETHEREUM:
            return "IDENTIFIER_KIND_ETHEREUM";
        case IdentifierKind.IDENTIFIER_KIND_PASSKEY:
            return "IDENTIFIER_KIND_PASSKEY";
        case IdentifierKind.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
function createBaseMemberIdentifier() {
    return { ethereumAddress: undefined, installationPublicKey: undefined, passkey: undefined };
}
export const MemberIdentifier = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.ethereumAddress !== undefined) {
            writer.uint32(10).string(message.ethereumAddress);
        }
        if (message.installationPublicKey !== undefined) {
            writer.uint32(18).bytes(message.installationPublicKey);
        }
        if (message.passkey !== undefined) {
            Passkey.encode(message.passkey, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMemberIdentifier();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.ethereumAddress = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.installationPublicKey = reader.bytes();
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.passkey = Passkey.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            ethereumAddress: isSet(object.ethereumAddress) ? globalThis.String(object.ethereumAddress) : undefined,
            installationPublicKey: isSet(object.installationPublicKey)
                ? bytesFromBase64(object.installationPublicKey)
                : undefined,
            passkey: isSet(object.passkey) ? Passkey.fromJSON(object.passkey) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.ethereumAddress !== undefined) {
            obj.ethereumAddress = message.ethereumAddress;
        }
        if (message.installationPublicKey !== undefined) {
            obj.installationPublicKey = base64FromBytes(message.installationPublicKey);
        }
        if (message.passkey !== undefined) {
            obj.passkey = Passkey.toJSON(message.passkey);
        }
        return obj;
    },
    create(base) {
        return MemberIdentifier.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseMemberIdentifier();
        message.ethereumAddress = object.ethereumAddress ?? undefined;
        message.installationPublicKey = object.installationPublicKey ?? undefined;
        message.passkey = (object.passkey !== undefined && object.passkey !== null)
            ? Passkey.fromPartial(object.passkey)
            : undefined;
        return message;
    },
};
function createBasePasskey() {
    return { key: new Uint8Array(0), relyingParty: undefined };
}
export const Passkey = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
        }
        if (message.relyingParty !== undefined) {
            writer.uint32(18).string(message.relyingParty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePasskey();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.key = reader.bytes();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.relyingParty = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
            relyingParty: isSet(object.relyingParty) ? globalThis.String(object.relyingParty) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.key.length !== 0) {
            obj.key = base64FromBytes(message.key);
        }
        if (message.relyingParty !== undefined) {
            obj.relyingParty = message.relyingParty;
        }
        return obj;
    },
    create(base) {
        return Passkey.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBasePasskey();
        message.key = object.key ?? new Uint8Array(0);
        message.relyingParty = object.relyingParty ?? undefined;
        return message;
    },
};
function createBaseMember() {
    return { identifier: undefined, addedByEntity: undefined, clientTimestampNs: undefined, addedOnChainId: undefined };
}
export const Member = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.identifier !== undefined) {
            MemberIdentifier.encode(message.identifier, writer.uint32(10).fork()).ldelim();
        }
        if (message.addedByEntity !== undefined) {
            MemberIdentifier.encode(message.addedByEntity, writer.uint32(18).fork()).ldelim();
        }
        if (message.clientTimestampNs !== undefined) {
            writer.uint32(24).uint64(message.clientTimestampNs);
        }
        if (message.addedOnChainId !== undefined) {
            writer.uint32(32).uint64(message.addedOnChainId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMember();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.identifier = MemberIdentifier.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.addedByEntity = MemberIdentifier.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.clientTimestampNs = reader.uint64();
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.addedOnChainId = reader.uint64();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            identifier: isSet(object.identifier) ? MemberIdentifier.fromJSON(object.identifier) : undefined,
            addedByEntity: isSet(object.addedByEntity) ? MemberIdentifier.fromJSON(object.addedByEntity) : undefined,
            clientTimestampNs: isSet(object.clientTimestampNs) ? Long.fromValue(object.clientTimestampNs) : undefined,
            addedOnChainId: isSet(object.addedOnChainId) ? Long.fromValue(object.addedOnChainId) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.identifier !== undefined) {
            obj.identifier = MemberIdentifier.toJSON(message.identifier);
        }
        if (message.addedByEntity !== undefined) {
            obj.addedByEntity = MemberIdentifier.toJSON(message.addedByEntity);
        }
        if (message.clientTimestampNs !== undefined) {
            obj.clientTimestampNs = (message.clientTimestampNs || Long.UZERO).toString();
        }
        if (message.addedOnChainId !== undefined) {
            obj.addedOnChainId = (message.addedOnChainId || Long.UZERO).toString();
        }
        return obj;
    },
    create(base) {
        return Member.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseMember();
        message.identifier = (object.identifier !== undefined && object.identifier !== null)
            ? MemberIdentifier.fromPartial(object.identifier)
            : undefined;
        message.addedByEntity = (object.addedByEntity !== undefined && object.addedByEntity !== null)
            ? MemberIdentifier.fromPartial(object.addedByEntity)
            : undefined;
        message.clientTimestampNs = (object.clientTimestampNs !== undefined && object.clientTimestampNs !== null)
            ? Long.fromValue(object.clientTimestampNs)
            : undefined;
        message.addedOnChainId = (object.addedOnChainId !== undefined && object.addedOnChainId !== null)
            ? Long.fromValue(object.addedOnChainId)
            : undefined;
        return message;
    },
};
function createBaseCreateInbox() {
    return {
        initialIdentifier: "",
        nonce: Long.UZERO,
        initialIdentifierSignature: undefined,
        initialIdentifierKind: 0,
        relyingParty: undefined,
    };
}
export const CreateInbox = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.initialIdentifier !== "") {
            writer.uint32(10).string(message.initialIdentifier);
        }
        if (!message.nonce.equals(Long.UZERO)) {
            writer.uint32(16).uint64(message.nonce);
        }
        if (message.initialIdentifierSignature !== undefined) {
            Signature.encode(message.initialIdentifierSignature, writer.uint32(26).fork()).ldelim();
        }
        if (message.initialIdentifierKind !== 0) {
            writer.uint32(32).int32(message.initialIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            writer.uint32(42).string(message.relyingParty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCreateInbox();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.initialIdentifier = reader.string();
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.nonce = reader.uint64();
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.initialIdentifierSignature = Signature.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.initialIdentifierKind = reader.int32();
                    continue;
                case 5:
                    if (tag !== 42) {
                        break;
                    }
                    message.relyingParty = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            initialIdentifier: isSet(object.initialIdentifier) ? globalThis.String(object.initialIdentifier) : "",
            nonce: isSet(object.nonce) ? Long.fromValue(object.nonce) : Long.UZERO,
            initialIdentifierSignature: isSet(object.initialIdentifierSignature)
                ? Signature.fromJSON(object.initialIdentifierSignature)
                : undefined,
            initialIdentifierKind: isSet(object.initialIdentifierKind)
                ? identifierKindFromJSON(object.initialIdentifierKind)
                : 0,
            relyingParty: isSet(object.relyingParty) ? globalThis.String(object.relyingParty) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.initialIdentifier !== "") {
            obj.initialIdentifier = message.initialIdentifier;
        }
        if (!message.nonce.equals(Long.UZERO)) {
            obj.nonce = (message.nonce || Long.UZERO).toString();
        }
        if (message.initialIdentifierSignature !== undefined) {
            obj.initialIdentifierSignature = Signature.toJSON(message.initialIdentifierSignature);
        }
        if (message.initialIdentifierKind !== 0) {
            obj.initialIdentifierKind = identifierKindToJSON(message.initialIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            obj.relyingParty = message.relyingParty;
        }
        return obj;
    },
    create(base) {
        return CreateInbox.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseCreateInbox();
        message.initialIdentifier = object.initialIdentifier ?? "";
        message.nonce = (object.nonce !== undefined && object.nonce !== null) ? Long.fromValue(object.nonce) : Long.UZERO;
        message.initialIdentifierSignature =
            (object.initialIdentifierSignature !== undefined && object.initialIdentifierSignature !== null)
                ? Signature.fromPartial(object.initialIdentifierSignature)
                : undefined;
        message.initialIdentifierKind = object.initialIdentifierKind ?? 0;
        message.relyingParty = object.relyingParty ?? undefined;
        return message;
    },
};
function createBaseAddAssociation() {
    return {
        newMemberIdentifier: undefined,
        existingMemberSignature: undefined,
        newMemberSignature: undefined,
        relyingParty: undefined,
    };
}
export const AddAssociation = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.newMemberIdentifier !== undefined) {
            MemberIdentifier.encode(message.newMemberIdentifier, writer.uint32(10).fork()).ldelim();
        }
        if (message.existingMemberSignature !== undefined) {
            Signature.encode(message.existingMemberSignature, writer.uint32(18).fork()).ldelim();
        }
        if (message.newMemberSignature !== undefined) {
            Signature.encode(message.newMemberSignature, writer.uint32(26).fork()).ldelim();
        }
        if (message.relyingParty !== undefined) {
            writer.uint32(34).string(message.relyingParty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAddAssociation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.newMemberIdentifier = MemberIdentifier.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.existingMemberSignature = Signature.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.newMemberSignature = Signature.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.relyingParty = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            newMemberIdentifier: isSet(object.newMemberIdentifier)
                ? MemberIdentifier.fromJSON(object.newMemberIdentifier)
                : undefined,
            existingMemberSignature: isSet(object.existingMemberSignature)
                ? Signature.fromJSON(object.existingMemberSignature)
                : undefined,
            newMemberSignature: isSet(object.newMemberSignature) ? Signature.fromJSON(object.newMemberSignature) : undefined,
            relyingParty: isSet(object.relyingParty) ? globalThis.String(object.relyingParty) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.newMemberIdentifier !== undefined) {
            obj.newMemberIdentifier = MemberIdentifier.toJSON(message.newMemberIdentifier);
        }
        if (message.existingMemberSignature !== undefined) {
            obj.existingMemberSignature = Signature.toJSON(message.existingMemberSignature);
        }
        if (message.newMemberSignature !== undefined) {
            obj.newMemberSignature = Signature.toJSON(message.newMemberSignature);
        }
        if (message.relyingParty !== undefined) {
            obj.relyingParty = message.relyingParty;
        }
        return obj;
    },
    create(base) {
        return AddAssociation.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseAddAssociation();
        message.newMemberIdentifier = (object.newMemberIdentifier !== undefined && object.newMemberIdentifier !== null)
            ? MemberIdentifier.fromPartial(object.newMemberIdentifier)
            : undefined;
        message.existingMemberSignature =
            (object.existingMemberSignature !== undefined && object.existingMemberSignature !== null)
                ? Signature.fromPartial(object.existingMemberSignature)
                : undefined;
        message.newMemberSignature = (object.newMemberSignature !== undefined && object.newMemberSignature !== null)
            ? Signature.fromPartial(object.newMemberSignature)
            : undefined;
        message.relyingParty = object.relyingParty ?? undefined;
        return message;
    },
};
function createBaseRevokeAssociation() {
    return { memberToRevoke: undefined, recoveryIdentifierSignature: undefined };
}
export const RevokeAssociation = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.memberToRevoke !== undefined) {
            MemberIdentifier.encode(message.memberToRevoke, writer.uint32(10).fork()).ldelim();
        }
        if (message.recoveryIdentifierSignature !== undefined) {
            Signature.encode(message.recoveryIdentifierSignature, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseRevokeAssociation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.memberToRevoke = MemberIdentifier.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.recoveryIdentifierSignature = Signature.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            memberToRevoke: isSet(object.memberToRevoke) ? MemberIdentifier.fromJSON(object.memberToRevoke) : undefined,
            recoveryIdentifierSignature: isSet(object.recoveryIdentifierSignature)
                ? Signature.fromJSON(object.recoveryIdentifierSignature)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.memberToRevoke !== undefined) {
            obj.memberToRevoke = MemberIdentifier.toJSON(message.memberToRevoke);
        }
        if (message.recoveryIdentifierSignature !== undefined) {
            obj.recoveryIdentifierSignature = Signature.toJSON(message.recoveryIdentifierSignature);
        }
        return obj;
    },
    create(base) {
        return RevokeAssociation.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseRevokeAssociation();
        message.memberToRevoke = (object.memberToRevoke !== undefined && object.memberToRevoke !== null)
            ? MemberIdentifier.fromPartial(object.memberToRevoke)
            : undefined;
        message.recoveryIdentifierSignature =
            (object.recoveryIdentifierSignature !== undefined && object.recoveryIdentifierSignature !== null)
                ? Signature.fromPartial(object.recoveryIdentifierSignature)
                : undefined;
        return message;
    },
};
function createBaseChangeRecoveryAddress() {
    return {
        newRecoveryIdentifier: "",
        existingRecoveryIdentifierSignature: undefined,
        newRecoveryIdentifierKind: 0,
        relyingParty: undefined,
    };
}
export const ChangeRecoveryAddress = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.newRecoveryIdentifier !== "") {
            writer.uint32(10).string(message.newRecoveryIdentifier);
        }
        if (message.existingRecoveryIdentifierSignature !== undefined) {
            Signature.encode(message.existingRecoveryIdentifierSignature, writer.uint32(18).fork()).ldelim();
        }
        if (message.newRecoveryIdentifierKind !== 0) {
            writer.uint32(24).int32(message.newRecoveryIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            writer.uint32(34).string(message.relyingParty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseChangeRecoveryAddress();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.newRecoveryIdentifier = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.existingRecoveryIdentifierSignature = Signature.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.newRecoveryIdentifierKind = reader.int32();
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.relyingParty = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            newRecoveryIdentifier: isSet(object.newRecoveryIdentifier) ? globalThis.String(object.newRecoveryIdentifier) : "",
            existingRecoveryIdentifierSignature: isSet(object.existingRecoveryIdentifierSignature)
                ? Signature.fromJSON(object.existingRecoveryIdentifierSignature)
                : undefined,
            newRecoveryIdentifierKind: isSet(object.newRecoveryIdentifierKind)
                ? identifierKindFromJSON(object.newRecoveryIdentifierKind)
                : 0,
            relyingParty: isSet(object.relyingParty) ? globalThis.String(object.relyingParty) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.newRecoveryIdentifier !== "") {
            obj.newRecoveryIdentifier = message.newRecoveryIdentifier;
        }
        if (message.existingRecoveryIdentifierSignature !== undefined) {
            obj.existingRecoveryIdentifierSignature = Signature.toJSON(message.existingRecoveryIdentifierSignature);
        }
        if (message.newRecoveryIdentifierKind !== 0) {
            obj.newRecoveryIdentifierKind = identifierKindToJSON(message.newRecoveryIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            obj.relyingParty = message.relyingParty;
        }
        return obj;
    },
    create(base) {
        return ChangeRecoveryAddress.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseChangeRecoveryAddress();
        message.newRecoveryIdentifier = object.newRecoveryIdentifier ?? "";
        message.existingRecoveryIdentifierSignature =
            (object.existingRecoveryIdentifierSignature !== undefined && object.existingRecoveryIdentifierSignature !== null)
                ? Signature.fromPartial(object.existingRecoveryIdentifierSignature)
                : undefined;
        message.newRecoveryIdentifierKind = object.newRecoveryIdentifierKind ?? 0;
        message.relyingParty = object.relyingParty ?? undefined;
        return message;
    },
};
function createBaseIdentityAction() {
    return { createInbox: undefined, add: undefined, revoke: undefined, changeRecoveryAddress: undefined };
}
export const IdentityAction = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.createInbox !== undefined) {
            CreateInbox.encode(message.createInbox, writer.uint32(10).fork()).ldelim();
        }
        if (message.add !== undefined) {
            AddAssociation.encode(message.add, writer.uint32(18).fork()).ldelim();
        }
        if (message.revoke !== undefined) {
            RevokeAssociation.encode(message.revoke, writer.uint32(26).fork()).ldelim();
        }
        if (message.changeRecoveryAddress !== undefined) {
            ChangeRecoveryAddress.encode(message.changeRecoveryAddress, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseIdentityAction();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.createInbox = CreateInbox.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.add = AddAssociation.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.revoke = RevokeAssociation.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.changeRecoveryAddress = ChangeRecoveryAddress.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            createInbox: isSet(object.createInbox) ? CreateInbox.fromJSON(object.createInbox) : undefined,
            add: isSet(object.add) ? AddAssociation.fromJSON(object.add) : undefined,
            revoke: isSet(object.revoke) ? RevokeAssociation.fromJSON(object.revoke) : undefined,
            changeRecoveryAddress: isSet(object.changeRecoveryAddress)
                ? ChangeRecoveryAddress.fromJSON(object.changeRecoveryAddress)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.createInbox !== undefined) {
            obj.createInbox = CreateInbox.toJSON(message.createInbox);
        }
        if (message.add !== undefined) {
            obj.add = AddAssociation.toJSON(message.add);
        }
        if (message.revoke !== undefined) {
            obj.revoke = RevokeAssociation.toJSON(message.revoke);
        }
        if (message.changeRecoveryAddress !== undefined) {
            obj.changeRecoveryAddress = ChangeRecoveryAddress.toJSON(message.changeRecoveryAddress);
        }
        return obj;
    },
    create(base) {
        return IdentityAction.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseIdentityAction();
        message.createInbox = (object.createInbox !== undefined && object.createInbox !== null)
            ? CreateInbox.fromPartial(object.createInbox)
            : undefined;
        message.add = (object.add !== undefined && object.add !== null)
            ? AddAssociation.fromPartial(object.add)
            : undefined;
        message.revoke = (object.revoke !== undefined && object.revoke !== null)
            ? RevokeAssociation.fromPartial(object.revoke)
            : undefined;
        message.changeRecoveryAddress =
            (object.changeRecoveryAddress !== undefined && object.changeRecoveryAddress !== null)
                ? ChangeRecoveryAddress.fromPartial(object.changeRecoveryAddress)
                : undefined;
        return message;
    },
};
function createBaseIdentityUpdate() {
    return { actions: [], clientTimestampNs: Long.UZERO, inboxId: "" };
}
export const IdentityUpdate = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.actions) {
            IdentityAction.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (!message.clientTimestampNs.equals(Long.UZERO)) {
            writer.uint32(16).uint64(message.clientTimestampNs);
        }
        if (message.inboxId !== "") {
            writer.uint32(26).string(message.inboxId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseIdentityUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.actions.push(IdentityAction.decode(reader, reader.uint32()));
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.clientTimestampNs = reader.uint64();
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.inboxId = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            actions: globalThis.Array.isArray(object?.actions)
                ? object.actions.map((e) => IdentityAction.fromJSON(e))
                : [],
            clientTimestampNs: isSet(object.clientTimestampNs) ? Long.fromValue(object.clientTimestampNs) : Long.UZERO,
            inboxId: isSet(object.inboxId) ? globalThis.String(object.inboxId) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.actions?.length) {
            obj.actions = message.actions.map((e) => IdentityAction.toJSON(e));
        }
        if (!message.clientTimestampNs.equals(Long.UZERO)) {
            obj.clientTimestampNs = (message.clientTimestampNs || Long.UZERO).toString();
        }
        if (message.inboxId !== "") {
            obj.inboxId = message.inboxId;
        }
        return obj;
    },
    create(base) {
        return IdentityUpdate.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseIdentityUpdate();
        message.actions = object.actions?.map((e) => IdentityAction.fromPartial(e)) || [];
        message.clientTimestampNs = (object.clientTimestampNs !== undefined && object.clientTimestampNs !== null)
            ? Long.fromValue(object.clientTimestampNs)
            : Long.UZERO;
        message.inboxId = object.inboxId ?? "";
        return message;
    },
};
function createBaseMemberMap() {
    return { key: undefined, value: undefined };
}
export const MemberMap = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.key !== undefined) {
            MemberIdentifier.encode(message.key, writer.uint32(10).fork()).ldelim();
        }
        if (message.value !== undefined) {
            Member.encode(message.value, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMemberMap();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.key = MemberIdentifier.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.value = Member.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            key: isSet(object.key) ? MemberIdentifier.fromJSON(object.key) : undefined,
            value: isSet(object.value) ? Member.fromJSON(object.value) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.key !== undefined) {
            obj.key = MemberIdentifier.toJSON(message.key);
        }
        if (message.value !== undefined) {
            obj.value = Member.toJSON(message.value);
        }
        return obj;
    },
    create(base) {
        return MemberMap.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseMemberMap();
        message.key = (object.key !== undefined && object.key !== null)
            ? MemberIdentifier.fromPartial(object.key)
            : undefined;
        message.value = (object.value !== undefined && object.value !== null)
            ? Member.fromPartial(object.value)
            : undefined;
        return message;
    },
};
function createBaseAssociationState() {
    return {
        inboxId: "",
        members: [],
        recoveryIdentifier: "",
        seenSignatures: [],
        recoveryIdentifierKind: 0,
        relyingParty: undefined,
    };
}
export const AssociationState = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.inboxId !== "") {
            writer.uint32(10).string(message.inboxId);
        }
        for (const v of message.members) {
            MemberMap.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.recoveryIdentifier !== "") {
            writer.uint32(26).string(message.recoveryIdentifier);
        }
        for (const v of message.seenSignatures) {
            writer.uint32(34).bytes(v);
        }
        if (message.recoveryIdentifierKind !== 0) {
            writer.uint32(40).int32(message.recoveryIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            writer.uint32(50).string(message.relyingParty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAssociationState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.inboxId = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.members.push(MemberMap.decode(reader, reader.uint32()));
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.recoveryIdentifier = reader.string();
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.seenSignatures.push(reader.bytes());
                    continue;
                case 5:
                    if (tag !== 40) {
                        break;
                    }
                    message.recoveryIdentifierKind = reader.int32();
                    continue;
                case 6:
                    if (tag !== 50) {
                        break;
                    }
                    message.relyingParty = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            inboxId: isSet(object.inboxId) ? globalThis.String(object.inboxId) : "",
            members: globalThis.Array.isArray(object?.members) ? object.members.map((e) => MemberMap.fromJSON(e)) : [],
            recoveryIdentifier: isSet(object.recoveryIdentifier) ? globalThis.String(object.recoveryIdentifier) : "",
            seenSignatures: globalThis.Array.isArray(object?.seenSignatures)
                ? object.seenSignatures.map((e) => bytesFromBase64(e))
                : [],
            recoveryIdentifierKind: isSet(object.recoveryIdentifierKind)
                ? identifierKindFromJSON(object.recoveryIdentifierKind)
                : 0,
            relyingParty: isSet(object.relyingParty) ? globalThis.String(object.relyingParty) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.inboxId !== "") {
            obj.inboxId = message.inboxId;
        }
        if (message.members?.length) {
            obj.members = message.members.map((e) => MemberMap.toJSON(e));
        }
        if (message.recoveryIdentifier !== "") {
            obj.recoveryIdentifier = message.recoveryIdentifier;
        }
        if (message.seenSignatures?.length) {
            obj.seenSignatures = message.seenSignatures.map((e) => base64FromBytes(e));
        }
        if (message.recoveryIdentifierKind !== 0) {
            obj.recoveryIdentifierKind = identifierKindToJSON(message.recoveryIdentifierKind);
        }
        if (message.relyingParty !== undefined) {
            obj.relyingParty = message.relyingParty;
        }
        return obj;
    },
    create(base) {
        return AssociationState.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseAssociationState();
        message.inboxId = object.inboxId ?? "";
        message.members = object.members?.map((e) => MemberMap.fromPartial(e)) || [];
        message.recoveryIdentifier = object.recoveryIdentifier ?? "";
        message.seenSignatures = object.seenSignatures?.map((e) => e) || [];
        message.recoveryIdentifierKind = object.recoveryIdentifierKind ?? 0;
        message.relyingParty = object.relyingParty ?? undefined;
        return message;
    },
};
function createBaseAssociationStateDiff() {
    return { newMembers: [], removedMembers: [] };
}
export const AssociationStateDiff = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.newMembers) {
            MemberIdentifier.encode(v, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.removedMembers) {
            MemberIdentifier.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAssociationStateDiff();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.newMembers.push(MemberIdentifier.decode(reader, reader.uint32()));
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.removedMembers.push(MemberIdentifier.decode(reader, reader.uint32()));
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            newMembers: globalThis.Array.isArray(object?.newMembers)
                ? object.newMembers.map((e) => MemberIdentifier.fromJSON(e))
                : [],
            removedMembers: globalThis.Array.isArray(object?.removedMembers)
                ? object.removedMembers.map((e) => MemberIdentifier.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.newMembers?.length) {
            obj.newMembers = message.newMembers.map((e) => MemberIdentifier.toJSON(e));
        }
        if (message.removedMembers?.length) {
            obj.removedMembers = message.removedMembers.map((e) => MemberIdentifier.toJSON(e));
        }
        return obj;
    },
    create(base) {
        return AssociationStateDiff.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseAssociationStateDiff();
        message.newMembers = object.newMembers?.map((e) => MemberIdentifier.fromPartial(e)) || [];
        message.removedMembers = object.removedMembers?.map((e) => MemberIdentifier.fromPartial(e)) || [];
        return message;
    },
};
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(globalThis.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;
}