@ottochain/sdk 2.2.5 → 2.4.0

package/dist/esm/generated/ottochain/v1/common.js

@@ -4,4 +4,1722 @@
 //   protoc               unknown
 // source: ottochain/v1/common.proto
 /* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export const protobufPackage = "ottochain.v1";
+/**
+ * Lifecycle status of a registered version (npm/Cargo-style).
+ *   - ACTIVE     — selectable + recommended.
+ *   - DEPRECATED — still resolvable/runnable, flagged, discouraged for new instances.
+ *   - YANKED     — excluded from NEW resolutions; existing pinned fibers keep running.
+ */
+export var RegistryStatus;
+(function (RegistryStatus) {
+    RegistryStatus["REGISTRY_STATUS_UNSPECIFIED"] = "REGISTRY_STATUS_UNSPECIFIED";
+    RegistryStatus["ACTIVE"] = "ACTIVE";
+    RegistryStatus["DEPRECATED"] = "DEPRECATED";
+    RegistryStatus["YANKED"] = "YANKED";
+    RegistryStatus["UNRECOGNIZED"] = "UNRECOGNIZED";
+})(RegistryStatus || (RegistryStatus = {}));
+export function registryStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "REGISTRY_STATUS_UNSPECIFIED":
+            return RegistryStatus.REGISTRY_STATUS_UNSPECIFIED;
+        case 1:
+        case "ACTIVE":
+            return RegistryStatus.ACTIVE;
+        case 2:
+        case "DEPRECATED":
+            return RegistryStatus.DEPRECATED;
+        case 3:
+        case "YANKED":
+            return RegistryStatus.YANKED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return RegistryStatus.UNRECOGNIZED;
+    }
+}
+export function registryStatusToJSON(object) {
+    switch (object) {
+        case RegistryStatus.REGISTRY_STATUS_UNSPECIFIED:
+            return "REGISTRY_STATUS_UNSPECIFIED";
+        case RegistryStatus.ACTIVE:
+            return "ACTIVE";
+        case RegistryStatus.DEPRECATED:
+            return "DEPRECATED";
+        case RegistryStatus.YANKED:
+            return "YANKED";
+        case RegistryStatus.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export function registryStatusToNumber(object) {
+    switch (object) {
+        case RegistryStatus.REGISTRY_STATUS_UNSPECIFIED:
+            return 0;
+        case RegistryStatus.ACTIVE:
+            return 1;
+        case RegistryStatus.DEPRECATED:
+            return 2;
+        case RegistryStatus.YANKED:
+            return 3;
+        case RegistryStatus.UNRECOGNIZED:
+        default:
+            return -1;
+    }
+}
+function createBaseVersionReq() {
+    return { requirement: undefined };
+}
+export const VersionReq = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.requirement?.$case) {
+            case "exact":
+                ExactVersion.encode(message.requirement.exact, writer.uint32(10).fork()).join();
+                break;
+            case "caret":
+                CaretVersion.encode(message.requirement.caret, writer.uint32(18).fork()).join();
+                break;
+            case "tilde":
+                TildeVersion.encode(message.requirement.tilde, writer.uint32(26).fork()).join();
+                break;
+            case "latest":
+                LatestVersion.encode(message.requirement.latest, writer.uint32(34).fork()).join();
+                break;
+            case "pinnedHash":
+                PinnedHashVersion.encode(message.requirement.pinnedHash, writer.uint32(42).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseVersionReq();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.requirement = { $case: "exact", exact: ExactVersion.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.requirement = { $case: "caret", caret: CaretVersion.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.requirement = { $case: "tilde", tilde: TildeVersion.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.requirement = { $case: "latest", latest: LatestVersion.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.requirement = { $case: "pinnedHash", pinnedHash: PinnedHashVersion.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            requirement: isSet(object.exact)
+                ? { $case: "exact", exact: ExactVersion.fromJSON(object.exact) }
+                : isSet(object.caret)
+                    ? { $case: "caret", caret: CaretVersion.fromJSON(object.caret) }
+                    : isSet(object.tilde)
+                        ? { $case: "tilde", tilde: TildeVersion.fromJSON(object.tilde) }
+                        : isSet(object.latest)
+                            ? { $case: "latest", latest: LatestVersion.fromJSON(object.latest) }
+                            : isSet(object.pinnedHash)
+                                ? { $case: "pinnedHash", pinnedHash: PinnedHashVersion.fromJSON(object.pinnedHash) }
+                                : isSet(object.pinned_hash)
+                                    ? { $case: "pinnedHash", pinnedHash: PinnedHashVersion.fromJSON(object.pinned_hash) }
+                                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.requirement?.$case === "exact") {
+            obj.exact = ExactVersion.toJSON(message.requirement.exact);
+        }
+        else if (message.requirement?.$case === "caret") {
+            obj.caret = CaretVersion.toJSON(message.requirement.caret);
+        }
+        else if (message.requirement?.$case === "tilde") {
+            obj.tilde = TildeVersion.toJSON(message.requirement.tilde);
+        }
+        else if (message.requirement?.$case === "latest") {
+            obj.latest = LatestVersion.toJSON(message.requirement.latest);
+        }
+        else if (message.requirement?.$case === "pinnedHash") {
+            obj.pinnedHash = PinnedHashVersion.toJSON(message.requirement.pinnedHash);
+        }
+        return obj;
+    },
+    create(base) {
+        return VersionReq.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseVersionReq();
+        switch (object.requirement?.$case) {
+            case "exact": {
+                if (object.requirement?.exact !== undefined && object.requirement?.exact !== null) {
+                    message.requirement = { $case: "exact", exact: ExactVersion.fromPartial(object.requirement.exact) };
+                }
+                break;
+            }
+            case "caret": {
+                if (object.requirement?.caret !== undefined && object.requirement?.caret !== null) {
+                    message.requirement = { $case: "caret", caret: CaretVersion.fromPartial(object.requirement.caret) };
+                }
+                break;
+            }
+            case "tilde": {
+                if (object.requirement?.tilde !== undefined && object.requirement?.tilde !== null) {
+                    message.requirement = { $case: "tilde", tilde: TildeVersion.fromPartial(object.requirement.tilde) };
+                }
+                break;
+            }
+            case "latest": {
+                if (object.requirement?.latest !== undefined && object.requirement?.latest !== null) {
+                    message.requirement = { $case: "latest", latest: LatestVersion.fromPartial(object.requirement.latest) };
+                }
+                break;
+            }
+            case "pinnedHash": {
+                if (object.requirement?.pinnedHash !== undefined && object.requirement?.pinnedHash !== null) {
+                    message.requirement = {
+                        $case: "pinnedHash",
+                        pinnedHash: PinnedHashVersion.fromPartial(object.requirement.pinnedHash),
+                    };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBaseExactVersion() {
+    return { version: "" };
+}
+export const ExactVersion = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExactVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { version: isSet(object.version) ? globalThis.String(object.version) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        return obj;
+    },
+    create(base) {
+        return ExactVersion.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseExactVersion();
+        message.version = object.version ?? "";
+        return message;
+    },
+};
+function createBaseCaretVersion() {
+    return { version: "" };
+}
+export const CaretVersion = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCaretVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { version: isSet(object.version) ? globalThis.String(object.version) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        return obj;
+    },
+    create(base) {
+        return CaretVersion.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCaretVersion();
+        message.version = object.version ?? "";
+        return message;
+    },
+};
+function createBaseTildeVersion() {
+    return { version: "" };
+}
+export const TildeVersion = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTildeVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { version: isSet(object.version) ? globalThis.String(object.version) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        return obj;
+    },
+    create(base) {
+        return TildeVersion.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTildeVersion();
+        message.version = object.version ?? "";
+        return message;
+    },
+};
+function createBaseLatestVersion() {
+    return {};
+}
+export const LatestVersion = {
+    encode(_, writer = new BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLatestVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return LatestVersion.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseLatestVersion();
+        return message;
+    },
+};
+function createBasePinnedHashVersion() {
+    return { schemaHash: "" };
+}
+export const PinnedHashVersion = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.schemaHash !== "") {
+            writer.uint32(10).string(message.schemaHash);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePinnedHashVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.schemaHash = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            schemaHash: isSet(object.schemaHash)
+                ? globalThis.String(object.schemaHash)
+                : isSet(object.schema_hash)
+                    ? globalThis.String(object.schema_hash)
+                    : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.schemaHash !== "") {
+            obj.schemaHash = message.schemaHash;
+        }
+        return obj;
+    },
+    create(base) {
+        return PinnedHashVersion.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePinnedHashVersion();
+        message.schemaHash = object.schemaHash ?? "";
+        return message;
+    },
+};
+function createBaseSchemaRef() {
+    return { name: "", version: undefined };
+}
+export const SchemaRef = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.version !== undefined) {
+            VersionReq.encode(message.version, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSchemaRef();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.version = VersionReq.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            version: isSet(object.version) ? VersionReq.fromJSON(object.version) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.version !== undefined) {
+            obj.version = VersionReq.toJSON(message.version);
+        }
+        return obj;
+    },
+    create(base) {
+        return SchemaRef.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchemaRef();
+        message.name = object.name ?? "";
+        message.version = (object.version !== undefined && object.version !== null)
+            ? VersionReq.fromPartial(object.version)
+            : undefined;
+        return message;
+    },
+};
+function createBaseFieldShape() {
+    return { name: "", number: 0, typeName: "", repeated: false, optional: false };
+}
+export const FieldShape = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.number !== 0) {
+            writer.uint32(16).int32(message.number);
+        }
+        if (message.typeName !== "") {
+            writer.uint32(26).string(message.typeName);
+        }
+        if (message.repeated !== false) {
+            writer.uint32(32).bool(message.repeated);
+        }
+        if (message.optional !== false) {
+            writer.uint32(40).bool(message.optional);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFieldShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.number = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.typeName = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.repeated = reader.bool();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.optional = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            number: isSet(object.number) ? globalThis.Number(object.number) : 0,
+            typeName: isSet(object.typeName)
+                ? globalThis.String(object.typeName)
+                : isSet(object.type_name)
+                    ? globalThis.String(object.type_name)
+                    : "",
+            repeated: isSet(object.repeated) ? globalThis.Boolean(object.repeated) : false,
+            optional: isSet(object.optional) ? globalThis.Boolean(object.optional) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.number !== 0) {
+            obj.number = Math.round(message.number);
+        }
+        if (message.typeName !== "") {
+            obj.typeName = message.typeName;
+        }
+        if (message.repeated !== false) {
+            obj.repeated = message.repeated;
+        }
+        if (message.optional !== false) {
+            obj.optional = message.optional;
+        }
+        return obj;
+    },
+    create(base) {
+        return FieldShape.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFieldShape();
+        message.name = object.name ?? "";
+        message.number = object.number ?? 0;
+        message.typeName = object.typeName ?? "";
+        message.repeated = object.repeated ?? false;
+        message.optional = object.optional ?? false;
+        return message;
+    },
+};
+function createBaseMessageShape() {
+    return { typeName: "", fields: [] };
+}
+export const MessageShape = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.typeName !== "") {
+            writer.uint32(10).string(message.typeName);
+        }
+        for (const v of message.fields) {
+            FieldShape.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMessageShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.typeName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.fields.push(FieldShape.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            typeName: isSet(object.typeName)
+                ? globalThis.String(object.typeName)
+                : isSet(object.type_name)
+                    ? globalThis.String(object.type_name)
+                    : "",
+            fields: globalThis.Array.isArray(object?.fields) ? object.fields.map((e) => FieldShape.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.typeName !== "") {
+            obj.typeName = message.typeName;
+        }
+        if (message.fields?.length) {
+            obj.fields = message.fields.map((e) => FieldShape.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return MessageShape.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMessageShape();
+        message.typeName = object.typeName ?? "";
+        message.fields = object.fields?.map((e) => FieldShape.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseSchemaShape() {
+    return { stateMessage: undefined, commands: {} };
+}
+export const SchemaShape = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.stateMessage !== undefined) {
+            MessageShape.encode(message.stateMessage, writer.uint32(10).fork()).join();
+        }
+        globalThis.Object.entries(message.commands).forEach(([key, value]) => {
+            SchemaShape_CommandsEntry.encode({ key: key, value }, writer.uint32(18).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSchemaShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.stateMessage = MessageShape.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    const entry2 = SchemaShape_CommandsEntry.decode(reader, reader.uint32());
+                    if (entry2.value !== undefined) {
+                        message.commands[entry2.key] = entry2.value;
+                    }
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            stateMessage: isSet(object.stateMessage)
+                ? MessageShape.fromJSON(object.stateMessage)
+                : isSet(object.state_message)
+                    ? MessageShape.fromJSON(object.state_message)
+                    : undefined,
+            commands: isObject(object.commands)
+                ? globalThis.Object.entries(object.commands).reduce((acc, [key, value]) => {
+                    acc[key] = MessageShape.fromJSON(value);
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.stateMessage !== undefined) {
+            obj.stateMessage = MessageShape.toJSON(message.stateMessage);
+        }
+        if (message.commands) {
+            const entries = globalThis.Object.entries(message.commands);
+            if (entries.length > 0) {
+                obj.commands = {};
+                entries.forEach(([k, v]) => {
+                    obj.commands[k] = MessageShape.toJSON(v);
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return SchemaShape.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchemaShape();
+        message.stateMessage = (object.stateMessage !== undefined && object.stateMessage !== null)
+            ? MessageShape.fromPartial(object.stateMessage)
+            : undefined;
+        message.commands = globalThis.Object.entries(object.commands ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = MessageShape.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseSchemaShape_CommandsEntry() {
+    return { key: "", value: undefined };
+}
+export const SchemaShape_CommandsEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            MessageShape.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSchemaShape_CommandsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = MessageShape.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? MessageShape.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = MessageShape.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return SchemaShape_CommandsEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchemaShape_CommandsEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? MessageShape.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSchemaBinding() {
+    return { name: "", version: "", schemaHash: "", logicHash: "" };
+}
+export const SchemaBinding = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.version !== "") {
+            writer.uint32(18).string(message.version);
+        }
+        if (message.schemaHash !== "") {
+            writer.uint32(26).string(message.schemaHash);
+        }
+        if (message.logicHash !== "") {
+            writer.uint32(34).string(message.logicHash);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSchemaBinding();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.schemaHash = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.logicHash = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            version: isSet(object.version) ? globalThis.String(object.version) : "",
+            schemaHash: isSet(object.schemaHash)
+                ? globalThis.String(object.schemaHash)
+                : isSet(object.schema_hash)
+                    ? globalThis.String(object.schema_hash)
+                    : "",
+            logicHash: isSet(object.logicHash)
+                ? globalThis.String(object.logicHash)
+                : isSet(object.logic_hash)
+                    ? globalThis.String(object.logic_hash)
+                    : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        if (message.schemaHash !== "") {
+            obj.schemaHash = message.schemaHash;
+        }
+        if (message.logicHash !== "") {
+            obj.logicHash = message.logicHash;
+        }
+        return obj;
+    },
+    create(base) {
+        return SchemaBinding.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchemaBinding();
+        message.name = object.name ?? "";
+        message.version = object.version ?? "";
+        message.schemaHash = object.schemaHash ?? "";
+        message.logicHash = object.logicHash ?? "";
+        return message;
+    },
+};
+function createBaseRegisteredVersion() {
+    return {
+        version: "",
+        schemaHash: "",
+        logicHash: "",
+        schemaShape: undefined,
+        status: RegistryStatus.REGISTRY_STATUS_UNSPECIFIED,
+        registeredAt: 0,
+        strict: false,
+    };
+}
+export const RegisteredVersion = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== "") {
+            writer.uint32(10).string(message.version);
+        }
+        if (message.schemaHash !== "") {
+            writer.uint32(18).string(message.schemaHash);
+        }
+        if (message.logicHash !== "") {
+            writer.uint32(26).string(message.logicHash);
+        }
+        if (message.schemaShape !== undefined) {
+            SchemaShape.encode(message.schemaShape, writer.uint32(34).fork()).join();
+        }
+        if (message.status !== RegistryStatus.REGISTRY_STATUS_UNSPECIFIED) {
+            writer.uint32(40).int32(registryStatusToNumber(message.status));
+        }
+        if (message.registeredAt !== 0) {
+            writer.uint32(48).int64(message.registeredAt);
+        }
+        if (message.strict !== false) {
+            writer.uint32(56).bool(message.strict);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRegisteredVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.schemaHash = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.logicHash = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.schemaShape = SchemaShape.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.status = registryStatusFromJSON(reader.int32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.registeredAt = longToNumber(reader.int64());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.strict = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            version: isSet(object.version) ? globalThis.String(object.version) : "",
+            schemaHash: isSet(object.schemaHash)
+                ? globalThis.String(object.schemaHash)
+                : isSet(object.schema_hash)
+                    ? globalThis.String(object.schema_hash)
+                    : "",
+            logicHash: isSet(object.logicHash)
+                ? globalThis.String(object.logicHash)
+                : isSet(object.logic_hash)
+                    ? globalThis.String(object.logic_hash)
+                    : "",
+            schemaShape: isSet(object.schemaShape)
+                ? SchemaShape.fromJSON(object.schemaShape)
+                : isSet(object.schema_shape)
+                    ? SchemaShape.fromJSON(object.schema_shape)
+                    : undefined,
+            status: isSet(object.status) ? registryStatusFromJSON(object.status) : RegistryStatus.REGISTRY_STATUS_UNSPECIFIED,
+            registeredAt: isSet(object.registeredAt)
+                ? globalThis.Number(object.registeredAt)
+                : isSet(object.registered_at)
+                    ? globalThis.Number(object.registered_at)
+                    : 0,
+            strict: isSet(object.strict) ? globalThis.Boolean(object.strict) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        if (message.schemaHash !== "") {
+            obj.schemaHash = message.schemaHash;
+        }
+        if (message.logicHash !== "") {
+            obj.logicHash = message.logicHash;
+        }
+        if (message.schemaShape !== undefined) {
+            obj.schemaShape = SchemaShape.toJSON(message.schemaShape);
+        }
+        if (message.status !== RegistryStatus.REGISTRY_STATUS_UNSPECIFIED) {
+            obj.status = registryStatusToJSON(message.status);
+        }
+        if (message.registeredAt !== 0) {
+            obj.registeredAt = Math.round(message.registeredAt);
+        }
+        if (message.strict !== false) {
+            obj.strict = message.strict;
+        }
+        return obj;
+    },
+    create(base) {
+        return RegisteredVersion.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRegisteredVersion();
+        message.version = object.version ?? "";
+        message.schemaHash = object.schemaHash ?? "";
+        message.logicHash = object.logicHash ?? "";
+        message.schemaShape = (object.schemaShape !== undefined && object.schemaShape !== null)
+            ? SchemaShape.fromPartial(object.schemaShape)
+            : undefined;
+        message.status = object.status ?? RegistryStatus.REGISTRY_STATUS_UNSPECIFIED;
+        message.registeredAt = object.registeredAt ?? 0;
+        message.strict = object.strict ?? false;
+        return message;
+    },
+};
+function createBaseVersionLineage() {
+    return { versions: {} };
+}
+export const VersionLineage = {
+    encode(message, writer = new BinaryWriter()) {
+        globalThis.Object.entries(message.versions).forEach(([key, value]) => {
+            VersionLineage_VersionsEntry.encode({ key: key, value }, writer.uint32(10).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseVersionLineage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    const entry1 = VersionLineage_VersionsEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.versions[entry1.key] = entry1.value;
+                    }
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            versions: isObject(object.versions)
+                ? globalThis.Object.entries(object.versions).reduce((acc, [key, value]) => {
+                    acc[key] = RegisteredVersion.fromJSON(value);
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.versions) {
+            const entries = globalThis.Object.entries(message.versions);
+            if (entries.length > 0) {
+                obj.versions = {};
+                entries.forEach(([k, v]) => {
+                    obj.versions[k] = RegisteredVersion.toJSON(v);
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return VersionLineage.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseVersionLineage();
+        message.versions = globalThis.Object.entries(object.versions ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = RegisteredVersion.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseVersionLineage_VersionsEntry() {
+    return { key: "", value: undefined };
+}
+export const VersionLineage_VersionsEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            RegisteredVersion.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseVersionLineage_VersionsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = RegisteredVersion.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? RegisteredVersion.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = RegisteredVersion.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return VersionLineage_VersionsEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseVersionLineage_VersionsEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? RegisteredVersion.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseRegistryTarget() {
+    return { target: undefined };
+}
+export const RegistryTarget = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.target?.$case) {
+            case "schemaPackage":
+                SchemaPackageTarget.encode(message.target.schemaPackage, writer.uint32(10).fork()).join();
+                break;
+            case "instanceAlias":
+                InstanceAliasTarget.encode(message.target.instanceAlias, writer.uint32(18).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRegistryTarget();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.target = {
+                        $case: "schemaPackage",
+                        schemaPackage: SchemaPackageTarget.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.target = {
+                        $case: "instanceAlias",
+                        instanceAlias: InstanceAliasTarget.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            target: isSet(object.schemaPackage)
+                ? { $case: "schemaPackage", schemaPackage: SchemaPackageTarget.fromJSON(object.schemaPackage) }
+                : isSet(object.schema_package)
+                    ? { $case: "schemaPackage", schemaPackage: SchemaPackageTarget.fromJSON(object.schema_package) }
+                    : isSet(object.instanceAlias)
+                        ? { $case: "instanceAlias", instanceAlias: InstanceAliasTarget.fromJSON(object.instanceAlias) }
+                        : isSet(object.instance_alias)
+                            ? { $case: "instanceAlias", instanceAlias: InstanceAliasTarget.fromJSON(object.instance_alias) }
+                            : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.target?.$case === "schemaPackage") {
+            obj.schemaPackage = SchemaPackageTarget.toJSON(message.target.schemaPackage);
+        }
+        else if (message.target?.$case === "instanceAlias") {
+            obj.instanceAlias = InstanceAliasTarget.toJSON(message.target.instanceAlias);
+        }
+        return obj;
+    },
+    create(base) {
+        return RegistryTarget.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRegistryTarget();
+        switch (object.target?.$case) {
+            case "schemaPackage": {
+                if (object.target?.schemaPackage !== undefined && object.target?.schemaPackage !== null) {
+                    message.target = {
+                        $case: "schemaPackage",
+                        schemaPackage: SchemaPackageTarget.fromPartial(object.target.schemaPackage),
+                    };
+                }
+                break;
+            }
+            case "instanceAlias": {
+                if (object.target?.instanceAlias !== undefined && object.target?.instanceAlias !== null) {
+                    message.target = {
+                        $case: "instanceAlias",
+                        instanceAlias: InstanceAliasTarget.fromPartial(object.target.instanceAlias),
+                    };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBaseSchemaPackageTarget() {
+    return { versions: undefined };
+}
+export const SchemaPackageTarget = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.versions !== undefined) {
+            VersionLineage.encode(message.versions, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSchemaPackageTarget();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.versions = VersionLineage.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { versions: isSet(object.versions) ? VersionLineage.fromJSON(object.versions) : undefined };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.versions !== undefined) {
+            obj.versions = VersionLineage.toJSON(message.versions);
+        }
+        return obj;
+    },
+    create(base) {
+        return SchemaPackageTarget.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchemaPackageTarget();
+        message.versions = (object.versions !== undefined && object.versions !== null)
+            ? VersionLineage.fromPartial(object.versions)
+            : undefined;
+        return message;
+    },
+};
+function createBaseInstanceAliasTarget() {
+    return { fiberId: "" };
+}
+export const InstanceAliasTarget = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.fiberId !== "") {
+            writer.uint32(10).string(message.fiberId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseInstanceAliasTarget();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fiberId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            fiberId: isSet(object.fiberId)
+                ? globalThis.String(object.fiberId)
+                : isSet(object.fiber_id)
+                    ? globalThis.String(object.fiber_id)
+                    : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.fiberId !== "") {
+            obj.fiberId = message.fiberId;
+        }
+        return obj;
+    },
+    create(base) {
+        return InstanceAliasTarget.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInstanceAliasTarget();
+        message.fiberId = object.fiberId ?? "";
+        return message;
+    },
+};
+function createBaseRegistryEntry() {
+    return { name: "", owner: [], target: undefined, metadata: {} };
+}
+export const RegistryEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        for (const v of message.owner) {
+            writer.uint32(18).string(v);
+        }
+        if (message.target !== undefined) {
+            RegistryTarget.encode(message.target, writer.uint32(26).fork()).join();
+        }
+        globalThis.Object.entries(message.metadata).forEach(([key, value]) => {
+            RegistryEntry_MetadataEntry.encode({ key: key, value }, writer.uint32(34).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRegistryEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.owner.push(reader.string());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.target = RegistryTarget.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    const entry4 = RegistryEntry_MetadataEntry.decode(reader, reader.uint32());
+                    if (entry4.value !== undefined) {
+                        message.metadata[entry4.key] = entry4.value;
+                    }
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            owner: globalThis.Array.isArray(object?.owner) ? object.owner.map((e) => globalThis.String(e)) : [],
+            target: isSet(object.target) ? RegistryTarget.fromJSON(object.target) : undefined,
+            metadata: isObject(object.metadata)
+                ? globalThis.Object.entries(object.metadata).reduce((acc, [key, value]) => {
+                    acc[key] = globalThis.String(value);
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.owner?.length) {
+            obj.owner = message.owner;
+        }
+        if (message.target !== undefined) {
+            obj.target = RegistryTarget.toJSON(message.target);
+        }
+        if (message.metadata) {
+            const entries = globalThis.Object.entries(message.metadata);
+            if (entries.length > 0) {
+                obj.metadata = {};
+                entries.forEach(([k, v]) => {
+                    obj.metadata[k] = v;
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return RegistryEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRegistryEntry();
+        message.name = object.name ?? "";
+        message.owner = object.owner?.map((e) => e) || [];
+        message.target = (object.target !== undefined && object.target !== null)
+            ? RegistryTarget.fromPartial(object.target)
+            : undefined;
+        message.metadata = globalThis.Object.entries(object.metadata ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseRegistryEntry_MetadataEntry() {
+    return { key: "", value: "" };
+}
+export const RegistryEntry_MetadataEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRegistryEntry_MetadataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return RegistryEntry_MetadataEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRegistryEntry_MetadataEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}