@nebius/js-sdk 0.2.30 → 0.2.32

package/dist/esm/api/nebius/compute/v1/index.js

@@ -905,6 +905,1713 @@ export class DiskService {
         return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
     }
 }
+export const GetDiskSnapshotRequest = {
+    $type: "nebius.compute.v1.GetDiskSnapshotRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseGetDiskSnapshotRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.id = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyGetDiskSnapshotRequestCustom({
+            $type: "nebius.compute.v1.GetDiskSnapshotRequest",
+            id: isSet(object.id ?? object.id)
+                ? String(object.id ?? object.id)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.id !== "") {
+            obj[pick("id", "id")] = message.id;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetDiskSnapshotRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetDiskSnapshotRequest();
+        message.id = (object.id !== undefined && object.id !== null)
+            ? object.id
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(GetDiskSnapshotRequest);
+function GetDiskSnapshotRequestCustomInspect() {
+    const parts = [];
+    if (this.id !== "")
+        parts.push("id" + "=" + inspect(this.id));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function GetDiskSnapshotRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.id !== "")
+        obj.id = inspectJson(this.id);
+    return obj;
+}
+function applyGetDiskSnapshotRequestCustom(message) {
+    message[custom] = GetDiskSnapshotRequestCustomInspect;
+    message[customJson] = GetDiskSnapshotRequestCustomJson;
+    return message;
+}
+function createBaseGetDiskSnapshotRequest() {
+    const message = {
+        $type: "nebius.compute.v1.GetDiskSnapshotRequest",
+        id: "",
+    };
+    return applyGetDiskSnapshotRequestCustom(message);
+}
+export const ListDiskSnapshotsRequest = {
+    $type: "nebius.compute.v1.ListDiskSnapshotsRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.parentId !== "") {
+            writer.uint32(10).string(message.parentId);
+        }
+        if (message.pageSize !== undefined && !message.pageSize.isZero?.()) {
+            writer.uint32(16).int64(message.pageSize.toString());
+        }
+        if (message.pageToken !== "") {
+            writer.uint32(26).string(message.pageToken);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseListDiskSnapshotsRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.parentId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16)
+                        break;
+                    message.pageSize = Long.fromValue(reader.int64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26)
+                        break;
+                    message.pageToken = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyListDiskSnapshotsRequestCustom({
+            $type: "nebius.compute.v1.ListDiskSnapshotsRequest",
+            parentId: isSet(object.parentId ?? object.parent_id)
+                ? String(object.parentId ?? object.parent_id)
+                : "",
+            pageSize: isSet(object.pageSize ?? object.page_size)
+                ? Long.fromValue(object.pageSize ?? object.page_size)
+                : Long.ZERO,
+            pageToken: isSet(object.pageToken ?? object.page_token)
+                ? String(object.pageToken ?? object.page_token)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.parentId !== "") {
+            obj[pick("parentId", "parent_id")] = message.parentId;
+        }
+        if (!message.pageSize?.isZero?.()) {
+            obj[pick("pageSize", "page_size")] = (message.pageSize || Long.ZERO).toString();
+        }
+        if (message.pageToken !== "") {
+            obj[pick("pageToken", "page_token")] = message.pageToken;
+        }
+        return obj;
+    },
+    create(base) {
+        return ListDiskSnapshotsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseListDiskSnapshotsRequest();
+        message.parentId = (object.parentId !== undefined && object.parentId !== null)
+            ? object.parentId
+            : "";
+        message.pageSize = (object.pageSize !== undefined && object.pageSize !== null)
+            ? Long.fromValue(object.pageSize)
+            : Long.ZERO;
+        message.pageToken = (object.pageToken !== undefined && object.pageToken !== null)
+            ? object.pageToken
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(ListDiskSnapshotsRequest);
+function ListDiskSnapshotsRequestCustomInspect() {
+    const parts = [];
+    if (this.parentId !== "")
+        parts.push("parentId" + "=" + inspect(this.parentId));
+    if (!this.pageSize?.isZero?.())
+        parts.push("pageSize" + "=" + inspect(this.pageSize));
+    if (this.pageToken !== "")
+        parts.push("pageToken" + "=" + inspect(this.pageToken));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function ListDiskSnapshotsRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.parentId !== "")
+        obj.parentId = inspectJson(this.parentId);
+    if (!this.pageSize?.isZero?.())
+        obj.pageSize = inspectJson(this.pageSize);
+    if (this.pageToken !== "")
+        obj.pageToken = inspectJson(this.pageToken);
+    return obj;
+}
+function applyListDiskSnapshotsRequestCustom(message) {
+    message[custom] = ListDiskSnapshotsRequestCustomInspect;
+    message[customJson] = ListDiskSnapshotsRequestCustomJson;
+    return message;
+}
+function createBaseListDiskSnapshotsRequest() {
+    const message = {
+        $type: "nebius.compute.v1.ListDiskSnapshotsRequest",
+        parentId: "",
+        pageSize: Long.ZERO,
+        pageToken: "",
+    };
+    return applyListDiskSnapshotsRequestCustom(message);
+}
+export const ListDiskSnapshotsResponse = {
+    $type: "nebius.compute.v1.ListDiskSnapshotsResponse",
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of (message.items ?? [])) {
+            const w = writer.uint32(10).fork();
+            DiskSnapshot.encode(v, w);
+            w.join();
+        }
+        if (message.nextPageToken !== "") {
+            writer.uint32(18).string(message.nextPageToken);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseListDiskSnapshotsResponse();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.items.push(DiskSnapshot.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.nextPageToken = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyListDiskSnapshotsResponseCustom({
+            $type: "nebius.compute.v1.ListDiskSnapshotsResponse",
+            items: globalThis.Array.isArray(object?.items ?? object?.items)
+                ? (object.items ?? object.items).map((e) => DiskSnapshot.fromJSON(e))
+                : [],
+            nextPageToken: isSet(object.nextPageToken ?? object.next_page_token)
+                ? String(object.nextPageToken ?? object.next_page_token)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.items?.length) {
+            obj[pick("items", "items")] = message.items.map((e) => e ? DiskSnapshot.toJSON(e, use) : undefined);
+        }
+        if (message.nextPageToken !== "") {
+            obj[pick("nextPageToken", "next_page_token")] = message.nextPageToken;
+        }
+        return obj;
+    },
+    create(base) {
+        return ListDiskSnapshotsResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseListDiskSnapshotsResponse();
+        message.items = object.items?.map((e) => DiskSnapshot.fromPartial(e)) || [];
+        message.nextPageToken = (object.nextPageToken !== undefined && object.nextPageToken !== null)
+            ? object.nextPageToken
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(ListDiskSnapshotsResponse);
+function ListDiskSnapshotsResponseCustomInspect() {
+    const parts = [];
+    if ((this.items?.length ?? 0) !== 0)
+        parts.push("items" + "=" + inspect(this.items));
+    if (this.nextPageToken !== "")
+        parts.push("nextPageToken" + "=" + inspect(this.nextPageToken));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function ListDiskSnapshotsResponseCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if ((this.items?.length ?? 0) !== 0)
+        obj.items = inspectJson(this.items);
+    if (this.nextPageToken !== "")
+        obj.nextPageToken = inspectJson(this.nextPageToken);
+    return obj;
+}
+function applyListDiskSnapshotsResponseCustom(message) {
+    message[custom] = ListDiskSnapshotsResponseCustomInspect;
+    message[customJson] = ListDiskSnapshotsResponseCustomJson;
+    return message;
+}
+function createBaseListDiskSnapshotsResponse() {
+    const message = {
+        $type: "nebius.compute.v1.ListDiskSnapshotsResponse",
+        items: [],
+        nextPageToken: "",
+    };
+    return applyListDiskSnapshotsResponseCustom(message);
+}
+export const ListDiskSnapshotsByDiskRequest = {
+    $type: "nebius.compute.v1.ListDiskSnapshotsByDiskRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.diskId !== "") {
+            writer.uint32(10).string(message.diskId);
+        }
+        if (message.pageSize !== undefined && !message.pageSize.isZero?.()) {
+            writer.uint32(16).int64(message.pageSize.toString());
+        }
+        if (message.pageToken !== "") {
+            writer.uint32(26).string(message.pageToken);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseListDiskSnapshotsByDiskRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.diskId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16)
+                        break;
+                    message.pageSize = Long.fromValue(reader.int64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26)
+                        break;
+                    message.pageToken = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyListDiskSnapshotsByDiskRequestCustom({
+            $type: "nebius.compute.v1.ListDiskSnapshotsByDiskRequest",
+            diskId: isSet(object.diskId ?? object.disk_id)
+                ? String(object.diskId ?? object.disk_id)
+                : "",
+            pageSize: isSet(object.pageSize ?? object.page_size)
+                ? Long.fromValue(object.pageSize ?? object.page_size)
+                : Long.ZERO,
+            pageToken: isSet(object.pageToken ?? object.page_token)
+                ? String(object.pageToken ?? object.page_token)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.diskId !== "") {
+            obj[pick("diskId", "disk_id")] = message.diskId;
+        }
+        if (!message.pageSize?.isZero?.()) {
+            obj[pick("pageSize", "page_size")] = (message.pageSize || Long.ZERO).toString();
+        }
+        if (message.pageToken !== "") {
+            obj[pick("pageToken", "page_token")] = message.pageToken;
+        }
+        return obj;
+    },
+    create(base) {
+        return ListDiskSnapshotsByDiskRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseListDiskSnapshotsByDiskRequest();
+        message.diskId = (object.diskId !== undefined && object.diskId !== null)
+            ? object.diskId
+            : "";
+        message.pageSize = (object.pageSize !== undefined && object.pageSize !== null)
+            ? Long.fromValue(object.pageSize)
+            : Long.ZERO;
+        message.pageToken = (object.pageToken !== undefined && object.pageToken !== null)
+            ? object.pageToken
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(ListDiskSnapshotsByDiskRequest);
+function ListDiskSnapshotsByDiskRequestCustomInspect() {
+    const parts = [];
+    if (this.diskId !== "")
+        parts.push("diskId" + "=" + inspect(this.diskId));
+    if (!this.pageSize?.isZero?.())
+        parts.push("pageSize" + "=" + inspect(this.pageSize));
+    if (this.pageToken !== "")
+        parts.push("pageToken" + "=" + inspect(this.pageToken));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function ListDiskSnapshotsByDiskRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.diskId !== "")
+        obj.diskId = inspectJson(this.diskId);
+    if (!this.pageSize?.isZero?.())
+        obj.pageSize = inspectJson(this.pageSize);
+    if (this.pageToken !== "")
+        obj.pageToken = inspectJson(this.pageToken);
+    return obj;
+}
+function applyListDiskSnapshotsByDiskRequestCustom(message) {
+    message[custom] = ListDiskSnapshotsByDiskRequestCustomInspect;
+    message[customJson] = ListDiskSnapshotsByDiskRequestCustomJson;
+    return message;
+}
+function createBaseListDiskSnapshotsByDiskRequest() {
+    const message = {
+        $type: "nebius.compute.v1.ListDiskSnapshotsByDiskRequest",
+        diskId: "",
+        pageSize: Long.ZERO,
+        pageToken: "",
+    };
+    return applyListDiskSnapshotsByDiskRequestCustom(message);
+}
+export const ListDiskSnapshotsByDiskResponse = {
+    $type: "nebius.compute.v1.ListDiskSnapshotsByDiskResponse",
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of (message.items ?? [])) {
+            const w = writer.uint32(10).fork();
+            DiskSnapshot.encode(v, w);
+            w.join();
+        }
+        if (message.nextPageToken !== "") {
+            writer.uint32(18).string(message.nextPageToken);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseListDiskSnapshotsByDiskResponse();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.items.push(DiskSnapshot.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.nextPageToken = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyListDiskSnapshotsByDiskResponseCustom({
+            $type: "nebius.compute.v1.ListDiskSnapshotsByDiskResponse",
+            items: globalThis.Array.isArray(object?.items ?? object?.items)
+                ? (object.items ?? object.items).map((e) => DiskSnapshot.fromJSON(e))
+                : [],
+            nextPageToken: isSet(object.nextPageToken ?? object.next_page_token)
+                ? String(object.nextPageToken ?? object.next_page_token)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.items?.length) {
+            obj[pick("items", "items")] = message.items.map((e) => e ? DiskSnapshot.toJSON(e, use) : undefined);
+        }
+        if (message.nextPageToken !== "") {
+            obj[pick("nextPageToken", "next_page_token")] = message.nextPageToken;
+        }
+        return obj;
+    },
+    create(base) {
+        return ListDiskSnapshotsByDiskResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseListDiskSnapshotsByDiskResponse();
+        message.items = object.items?.map((e) => DiskSnapshot.fromPartial(e)) || [];
+        message.nextPageToken = (object.nextPageToken !== undefined && object.nextPageToken !== null)
+            ? object.nextPageToken
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(ListDiskSnapshotsByDiskResponse);
+function ListDiskSnapshotsByDiskResponseCustomInspect() {
+    const parts = [];
+    if ((this.items?.length ?? 0) !== 0)
+        parts.push("items" + "=" + inspect(this.items));
+    if (this.nextPageToken !== "")
+        parts.push("nextPageToken" + "=" + inspect(this.nextPageToken));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function ListDiskSnapshotsByDiskResponseCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if ((this.items?.length ?? 0) !== 0)
+        obj.items = inspectJson(this.items);
+    if (this.nextPageToken !== "")
+        obj.nextPageToken = inspectJson(this.nextPageToken);
+    return obj;
+}
+function applyListDiskSnapshotsByDiskResponseCustom(message) {
+    message[custom] = ListDiskSnapshotsByDiskResponseCustomInspect;
+    message[customJson] = ListDiskSnapshotsByDiskResponseCustomJson;
+    return message;
+}
+function createBaseListDiskSnapshotsByDiskResponse() {
+    const message = {
+        $type: "nebius.compute.v1.ListDiskSnapshotsByDiskResponse",
+        items: [],
+        nextPageToken: "",
+    };
+    return applyListDiskSnapshotsByDiskResponseCustom(message);
+}
+export const CreateDiskSnapshotRequest = {
+    $type: "nebius.compute.v1.CreateDiskSnapshotRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.metadata !== undefined) {
+            const w = writer.uint32(10).fork();
+            ResourceMetadata.encode(message.metadata, w);
+            w.join();
+        }
+        if (message.spec !== undefined) {
+            const w = writer.uint32(18).fork();
+            DiskSnapshotSpec.encode(message.spec, w);
+            w.join();
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseCreateDiskSnapshotRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.metadata = ResourceMetadata.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.spec = DiskSnapshotSpec.decode(reader, reader.uint32());
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyCreateDiskSnapshotRequestCustom({
+            $type: "nebius.compute.v1.CreateDiskSnapshotRequest",
+            metadata: isSet(object.metadata ?? object.metadata)
+                ? ResourceMetadata.fromJSON(object.metadata ?? object.metadata)
+                : undefined,
+            spec: isSet(object.spec ?? object.spec)
+                ? DiskSnapshotSpec.fromJSON(object.spec ?? object.spec)
+                : undefined,
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.metadata !== undefined) {
+            obj[pick("metadata", "metadata")] = message.metadata
+                ? ResourceMetadata.toJSON(message.metadata, use)
+                : undefined;
+        }
+        if (message.spec !== undefined) {
+            obj[pick("spec", "spec")] = message.spec
+                ? DiskSnapshotSpec.toJSON(message.spec, use)
+                : undefined;
+        }
+        return obj;
+    },
+    create(base) {
+        return CreateDiskSnapshotRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCreateDiskSnapshotRequest();
+        message.metadata = (object.metadata !== undefined && object.metadata !== null)
+            ? ResourceMetadata.fromPartial(object.metadata)
+            : undefined;
+        message.spec = (object.spec !== undefined && object.spec !== null)
+            ? DiskSnapshotSpec.fromPartial(object.spec)
+            : undefined;
+        return message;
+    },
+};
+protoRegistry.registerMessage(CreateDiskSnapshotRequest);
+function CreateDiskSnapshotRequestCustomInspect() {
+    const parts = [];
+    if (this.metadata !== undefined)
+        parts.push("metadata" + "=" + inspect(this.metadata));
+    if (this.spec !== undefined)
+        parts.push("spec" + "=" + inspect(this.spec));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function CreateDiskSnapshotRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.metadata !== undefined)
+        obj.metadata = inspectJson(this.metadata);
+    if (this.spec !== undefined)
+        obj.spec = inspectJson(this.spec);
+    return obj;
+}
+function applyCreateDiskSnapshotRequestCustom(message) {
+    message[custom] = CreateDiskSnapshotRequestCustomInspect;
+    message[customJson] = CreateDiskSnapshotRequestCustomJson;
+    return message;
+}
+function createBaseCreateDiskSnapshotRequest() {
+    const message = {
+        $type: "nebius.compute.v1.CreateDiskSnapshotRequest",
+        metadata: undefined,
+        spec: undefined,
+    };
+    return applyCreateDiskSnapshotRequestCustom(message);
+}
+export const UpdateDiskSnapshotRequest = {
+    $type: "nebius.compute.v1.UpdateDiskSnapshotRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.metadata !== undefined) {
+            const w = writer.uint32(10).fork();
+            ResourceMetadata.encode(message.metadata, w);
+            w.join();
+        }
+        if (message.spec !== undefined) {
+            const w = writer.uint32(18).fork();
+            DiskSnapshotSpec.encode(message.spec, w);
+            w.join();
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseUpdateDiskSnapshotRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.metadata = ResourceMetadata.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.spec = DiskSnapshotSpec.decode(reader, reader.uint32());
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyUpdateDiskSnapshotRequestCustom({
+            $type: "nebius.compute.v1.UpdateDiskSnapshotRequest",
+            metadata: isSet(object.metadata ?? object.metadata)
+                ? ResourceMetadata.fromJSON(object.metadata ?? object.metadata)
+                : undefined,
+            spec: isSet(object.spec ?? object.spec)
+                ? DiskSnapshotSpec.fromJSON(object.spec ?? object.spec)
+                : undefined,
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.metadata !== undefined) {
+            obj[pick("metadata", "metadata")] = message.metadata
+                ? ResourceMetadata.toJSON(message.metadata, use)
+                : undefined;
+        }
+        if (message.spec !== undefined) {
+            obj[pick("spec", "spec")] = message.spec
+                ? DiskSnapshotSpec.toJSON(message.spec, use)
+                : undefined;
+        }
+        return obj;
+    },
+    create(base) {
+        return UpdateDiskSnapshotRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseUpdateDiskSnapshotRequest();
+        message.metadata = (object.metadata !== undefined && object.metadata !== null)
+            ? ResourceMetadata.fromPartial(object.metadata)
+            : undefined;
+        message.spec = (object.spec !== undefined && object.spec !== null)
+            ? DiskSnapshotSpec.fromPartial(object.spec)
+            : undefined;
+        return message;
+    },
+};
+protoRegistry.registerMessage(UpdateDiskSnapshotRequest);
+function UpdateDiskSnapshotRequestCustomInspect() {
+    const parts = [];
+    if (this.metadata !== undefined)
+        parts.push("metadata" + "=" + inspect(this.metadata));
+    if (this.spec !== undefined)
+        parts.push("spec" + "=" + inspect(this.spec));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function UpdateDiskSnapshotRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.metadata !== undefined)
+        obj.metadata = inspectJson(this.metadata);
+    if (this.spec !== undefined)
+        obj.spec = inspectJson(this.spec);
+    return obj;
+}
+function applyUpdateDiskSnapshotRequestCustom(message) {
+    message[custom] = UpdateDiskSnapshotRequestCustomInspect;
+    message[customJson] = UpdateDiskSnapshotRequestCustomJson;
+    return message;
+}
+function createBaseUpdateDiskSnapshotRequest() {
+    const message = {
+        $type: "nebius.compute.v1.UpdateDiskSnapshotRequest",
+        metadata: undefined,
+        spec: undefined,
+    };
+    return applyUpdateDiskSnapshotRequestCustom(message);
+}
+export const DeleteDiskSnapshotRequest = {
+    $type: "nebius.compute.v1.DeleteDiskSnapshotRequest",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseDeleteDiskSnapshotRequest();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.id = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyDeleteDiskSnapshotRequestCustom({
+            $type: "nebius.compute.v1.DeleteDiskSnapshotRequest",
+            id: isSet(object.id ?? object.id)
+                ? String(object.id ?? object.id)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.id !== "") {
+            obj[pick("id", "id")] = message.id;
+        }
+        return obj;
+    },
+    create(base) {
+        return DeleteDiskSnapshotRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDeleteDiskSnapshotRequest();
+        message.id = (object.id !== undefined && object.id !== null)
+            ? object.id
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(DeleteDiskSnapshotRequest);
+function DeleteDiskSnapshotRequestCustomInspect() {
+    const parts = [];
+    if (this.id !== "")
+        parts.push("id" + "=" + inspect(this.id));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function DeleteDiskSnapshotRequestCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.id !== "")
+        obj.id = inspectJson(this.id);
+    return obj;
+}
+function applyDeleteDiskSnapshotRequestCustom(message) {
+    message[custom] = DeleteDiskSnapshotRequestCustomInspect;
+    message[customJson] = DeleteDiskSnapshotRequestCustomJson;
+    return message;
+}
+function createBaseDeleteDiskSnapshotRequest() {
+    const message = {
+        $type: "nebius.compute.v1.DeleteDiskSnapshotRequest",
+        id: "",
+    };
+    return applyDeleteDiskSnapshotRequestCustom(message);
+}
+export const DiskSnapshotServiceServiceDescription = {
+    get: {
+        path: "/nebius.compute.v1.DiskSnapshotService/Get",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetDiskSnapshotRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => GetDiskSnapshotRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(DiskSnapshot.encode(value).finish()),
+        responseDeserialize: (value) => DiskSnapshot.decode(value),
+    },
+    getByName: {
+        path: "/nebius.compute.v1.DiskSnapshotService/GetByName",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetByNameRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => GetByNameRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(DiskSnapshot.encode(value).finish()),
+        responseDeserialize: (value) => DiskSnapshot.decode(value),
+    },
+    list: {
+        path: "/nebius.compute.v1.DiskSnapshotService/List",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(ListDiskSnapshotsRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => ListDiskSnapshotsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(ListDiskSnapshotsResponse.encode(value).finish()),
+        responseDeserialize: (value) => ListDiskSnapshotsResponse.decode(value),
+    },
+    listByDisk: {
+        path: "/nebius.compute.v1.DiskSnapshotService/ListByDisk",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(ListDiskSnapshotsByDiskRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => ListDiskSnapshotsByDiskRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(ListDiskSnapshotsByDiskResponse.encode(value).finish()),
+        responseDeserialize: (value) => ListDiskSnapshotsByDiskResponse.decode(value),
+    },
+    create: {
+        path: "/nebius.compute.v1.DiskSnapshotService/Create",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(CreateDiskSnapshotRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => CreateDiskSnapshotRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(Operation.encode(value).finish()),
+        responseDeserialize: (value) => Operation.decode(value),
+    },
+    update: {
+        path: "/nebius.compute.v1.DiskSnapshotService/Update",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(UpdateDiskSnapshotRequest.encode(value).finish()),
+        sendResetMask: true,
+        requestDeserialize: (value) => UpdateDiskSnapshotRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(Operation.encode(value).finish()),
+        responseDeserialize: (value) => Operation.decode(value),
+    },
+    delete: {
+        path: "/nebius.compute.v1.DiskSnapshotService/Delete",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(DeleteDiskSnapshotRequest.encode(value).finish()),
+        sendResetMask: false,
+        requestDeserialize: (value) => DeleteDiskSnapshotRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(Operation.encode(value).finish()),
+        responseDeserialize: (value) => Operation.decode(value),
+    },
+};
+export const DiskSnapshotServiceBaseClient = makeGenericClientConstructor(DiskSnapshotServiceServiceDescription, "nebius.compute.v1.DiskSnapshotService");
+export class DiskSnapshotService {
+    sdk;
+    $type = "nebius.compute.v1.DiskSnapshotService";
+    addr;
+    spec;
+    apiServiceName = "compute";
+    constructor(sdk) {
+        this.sdk = sdk;
+        const addr = sdk.getAddressFromServiceName(this.$type, this.apiServiceName);
+        this.addr = addr;
+        this.spec = DiskSnapshotServiceServiceDescription;
+    }
+    getOperationService() {
+        return new OperationService(this.sdk, this.addr);
+    }
+    get(...args) {
+        const spec = this.spec.get;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = spec.responseDeserialize;
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    getByName(...args) {
+        const spec = this.spec.getByName;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = spec.responseDeserialize;
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    list(...args) {
+        const spec = this.spec.list;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = spec.responseDeserialize;
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    listByDisk(...args) {
+        const spec = this.spec.listByDisk;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = spec.responseDeserialize;
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    create(...args) {
+        const spec = this.spec.create;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = (value) => {
+            const resp = spec.responseDeserialize(value);
+            return new OperationWrapper(resp, this.getOperationService(), this.sdk.logger.child("operation"));
+        };
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    update(...args) {
+        const spec = this.spec.update;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = (value) => {
+            const resp = spec.responseDeserialize(value);
+            return new OperationWrapper(resp, this.getOperationService(), this.sdk.logger.child("operation"));
+        };
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+    delete(...args) {
+        const spec = this.spec.delete;
+        const request = args[0];
+        const metadata = (args.length > 1 ? args[1] : undefined);
+        const options = (args.length > 2 ? args[2] : undefined);
+        const deserialize = (value) => {
+            const resp = spec.responseDeserialize(value);
+            return new OperationWrapper(resp, this.getOperationService(), this.sdk.logger.child("operation"));
+        };
+        return new SDKRequestClass(this.sdk, spec, this.addr, deserialize, request, metadata, options);
+    }
+}
+export const DiskSnapshotStatus_State = createEnum("nebius.compute.v1.DiskSnapshotStatus.State", {
+    UNSPECIFIED: 0,
+    CREATING: 1,
+    READY: 2,
+    DELETING: 3,
+    ERROR: 4,
+});
+protoRegistry.registerEnum(DiskSnapshotStatus_State);
+export const DiskSnapshotStatus_CPUArchitecture = createEnum("nebius.compute.v1.DiskSnapshotStatus.CPUArchitecture", {
+    UNDEFINED: 0,
+    AMD64: 1,
+    ARM64: 2,
+});
+protoRegistry.registerEnum(DiskSnapshotStatus_CPUArchitecture);
+export const DiskSnapshot = {
+    $type: "nebius.compute.v1.DiskSnapshot",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.metadata !== undefined) {
+            const w = writer.uint32(10).fork();
+            ResourceMetadata.encode(message.metadata, w);
+            w.join();
+        }
+        if (message.spec !== undefined) {
+            const w = writer.uint32(18).fork();
+            DiskSnapshotSpec.encode(message.spec, w);
+            w.join();
+        }
+        if (message.status !== undefined) {
+            const w = writer.uint32(26).fork();
+            DiskSnapshotStatus.encode(message.status, w);
+            w.join();
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseDiskSnapshot();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.metadata = ResourceMetadata.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.spec = DiskSnapshotSpec.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26)
+                        break;
+                    message.status = DiskSnapshotStatus.decode(reader, reader.uint32());
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyDiskSnapshotCustom({
+            $type: "nebius.compute.v1.DiskSnapshot",
+            metadata: isSet(object.metadata ?? object.metadata)
+                ? ResourceMetadata.fromJSON(object.metadata ?? object.metadata)
+                : undefined,
+            spec: isSet(object.spec ?? object.spec)
+                ? DiskSnapshotSpec.fromJSON(object.spec ?? object.spec)
+                : undefined,
+            status: isSet(object.status ?? object.status)
+                ? DiskSnapshotStatus.fromJSON(object.status ?? object.status)
+                : undefined,
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.metadata !== undefined) {
+            obj[pick("metadata", "metadata")] = message.metadata
+                ? ResourceMetadata.toJSON(message.metadata, use)
+                : undefined;
+        }
+        if (message.spec !== undefined) {
+            obj[pick("spec", "spec")] = message.spec
+                ? DiskSnapshotSpec.toJSON(message.spec, use)
+                : undefined;
+        }
+        if (message.status !== undefined) {
+            obj[pick("status", "status")] = message.status
+                ? DiskSnapshotStatus.toJSON(message.status, use)
+                : undefined;
+        }
+        return obj;
+    },
+    create(base) {
+        return DiskSnapshot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDiskSnapshot();
+        message.metadata = (object.metadata !== undefined && object.metadata !== null)
+            ? ResourceMetadata.fromPartial(object.metadata)
+            : undefined;
+        message.spec = (object.spec !== undefined && object.spec !== null)
+            ? DiskSnapshotSpec.fromPartial(object.spec)
+            : undefined;
+        message.status = (object.status !== undefined && object.status !== null)
+            ? DiskSnapshotStatus.fromPartial(object.status)
+            : undefined;
+        return message;
+    },
+};
+protoRegistry.registerMessage(DiskSnapshot);
+function DiskSnapshotCustomInspect() {
+    const parts = [];
+    if (this.metadata !== undefined)
+        parts.push("metadata" + "=" + inspect(this.metadata));
+    if (this.spec !== undefined)
+        parts.push("spec" + "=" + inspect(this.spec));
+    if (this.status !== undefined)
+        parts.push("status" + "=" + inspect(this.status));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function DiskSnapshotCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.metadata !== undefined)
+        obj.metadata = inspectJson(this.metadata);
+    if (this.spec !== undefined)
+        obj.spec = inspectJson(this.spec);
+    if (this.status !== undefined)
+        obj.status = inspectJson(this.status);
+    return obj;
+}
+function applyDiskSnapshotCustom(message) {
+    message[custom] = DiskSnapshotCustomInspect;
+    message[customJson] = DiskSnapshotCustomJson;
+    return message;
+}
+function createBaseDiskSnapshot() {
+    const message = {
+        $type: "nebius.compute.v1.DiskSnapshot",
+        metadata: undefined,
+        spec: undefined,
+        status: undefined,
+    };
+    return applyDiskSnapshotCustom(message);
+}
+export const DiskSnapshotSpec = {
+    $type: "nebius.compute.v1.DiskSnapshotSpec",
+    encode(message, writer = new BinaryWriter()) {
+        if (message.sourceDiskId !== "") {
+            writer.uint32(10).string(message.sourceDiskId);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseDiskSnapshotSpec();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.sourceDiskId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.description = reader.string();
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyDiskSnapshotSpecCustom({
+            $type: "nebius.compute.v1.DiskSnapshotSpec",
+            sourceDiskId: isSet(object.sourceDiskId ?? object.source_disk_id)
+                ? String(object.sourceDiskId ?? object.source_disk_id)
+                : "",
+            description: isSet(object.description ?? object.description)
+                ? String(object.description ?? object.description)
+                : "",
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.sourceDiskId !== "") {
+            obj[pick("sourceDiskId", "source_disk_id")] = message.sourceDiskId;
+        }
+        if (message.description !== "") {
+            obj[pick("description", "description")] = message.description;
+        }
+        return obj;
+    },
+    create(base) {
+        return DiskSnapshotSpec.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDiskSnapshotSpec();
+        message.sourceDiskId = (object.sourceDiskId !== undefined && object.sourceDiskId !== null)
+            ? object.sourceDiskId
+            : "";
+        message.description = (object.description !== undefined && object.description !== null)
+            ? object.description
+            : "";
+        return message;
+    },
+};
+protoRegistry.registerMessage(DiskSnapshotSpec);
+function DiskSnapshotSpecCustomInspect() {
+    const parts = [];
+    if (this.sourceDiskId !== "")
+        parts.push("sourceDiskId" + "=" + inspect(this.sourceDiskId));
+    if (this.description !== "")
+        parts.push("description" + "=" + inspect(this.description));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function DiskSnapshotSpecCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.sourceDiskId !== "")
+        obj.sourceDiskId = inspectJson(this.sourceDiskId);
+    if (this.description !== "")
+        obj.description = inspectJson(this.description);
+    return obj;
+}
+function applyDiskSnapshotSpecCustom(message) {
+    message[custom] = DiskSnapshotSpecCustomInspect;
+    message[customJson] = DiskSnapshotSpecCustomJson;
+    return message;
+}
+function createBaseDiskSnapshotSpec() {
+    const message = {
+        $type: "nebius.compute.v1.DiskSnapshotSpec",
+        sourceDiskId: "",
+        description: "",
+    };
+    return applyDiskSnapshotSpecCustom(message);
+}
+export const DiskSnapshotStatus = {
+    $type: "nebius.compute.v1.DiskSnapshotStatus",
+    encode(message, writer = new BinaryWriter()) {
+        if ((message.state ?? DiskSnapshotStatus_State.UNSPECIFIED) !== DiskSnapshotStatus_State.UNSPECIFIED) {
+            DiskSnapshotStatus_State.encodeField(writer, 1, message.state);
+        }
+        if (message.contentSizeBytes !== undefined && !message.contentSizeBytes.isZero?.()) {
+            writer.uint32(16).int64(message.contentSizeBytes.toString());
+        }
+        if (message.storageSizeBytes !== undefined && !message.storageSizeBytes.isZero?.()) {
+            writer.uint32(24).int64(message.storageSizeBytes.toString());
+        }
+        if (message.lockState !== undefined) {
+            const w = writer.uint32(34).fork();
+            DiskSnapshotStatus_LockState.encode(message.lockState, w);
+            w.join();
+        }
+        if ((message.sourceCpuArchitecture ?? DiskSnapshotStatus_CPUArchitecture.UNDEFINED) !== DiskSnapshotStatus_CPUArchitecture.UNDEFINED) {
+            DiskSnapshotStatus_CPUArchitecture.encodeField(writer, 5, message.sourceCpuArchitecture);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseDiskSnapshotStatus();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8)
+                        break;
+                    message.state = DiskSnapshotStatus_State.fromNumber(reader.int32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16)
+                        break;
+                    message.contentSizeBytes = Long.fromValue(reader.int64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24)
+                        break;
+                    message.storageSizeBytes = Long.fromValue(reader.int64());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34)
+                        break;
+                    message.lockState = DiskSnapshotStatus_LockState.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40)
+                        break;
+                    message.sourceCpuArchitecture = DiskSnapshotStatus_CPUArchitecture.fromNumber(reader.int32());
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyDiskSnapshotStatusCustom({
+            $type: "nebius.compute.v1.DiskSnapshotStatus",
+            state: isSet(object.state ?? object.state)
+                ? DiskSnapshotStatus_State.fromJSON(object.state ?? object.state)
+                : DiskSnapshotStatus_State.UNSPECIFIED,
+            contentSizeBytes: isSet(object.contentSizeBytes ?? object.content_size_bytes)
+                ? Long.fromValue(object.contentSizeBytes ?? object.content_size_bytes)
+                : Long.ZERO,
+            storageSizeBytes: isSet(object.storageSizeBytes ?? object.storage_size_bytes)
+                ? Long.fromValue(object.storageSizeBytes ?? object.storage_size_bytes)
+                : Long.ZERO,
+            lockState: isSet(object.lockState ?? object.lock_state)
+                ? DiskSnapshotStatus_LockState.fromJSON(object.lockState ?? object.lock_state)
+                : undefined,
+            sourceCpuArchitecture: isSet(object.sourceCpuArchitecture ?? object.source_cpu_architecture)
+                ? DiskSnapshotStatus_CPUArchitecture.fromJSON(object.sourceCpuArchitecture ?? object.source_cpu_architecture)
+                : DiskSnapshotStatus_CPUArchitecture.UNDEFINED,
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if ((message.state ?? DiskSnapshotStatus_State.UNSPECIFIED) !== DiskSnapshotStatus_State.UNSPECIFIED) {
+            obj[pick("state", "state")] = DiskSnapshotStatus_State.toJSON(message.state);
+        }
+        if (!message.contentSizeBytes?.isZero?.()) {
+            obj[pick("contentSizeBytes", "content_size_bytes")] = (message.contentSizeBytes || Long.ZERO).toString();
+        }
+        if (!message.storageSizeBytes?.isZero?.()) {
+            obj[pick("storageSizeBytes", "storage_size_bytes")] = (message.storageSizeBytes || Long.ZERO).toString();
+        }
+        if (message.lockState !== undefined) {
+            obj[pick("lockState", "lock_state")] = message.lockState
+                ? DiskSnapshotStatus_LockState.toJSON(message.lockState, use)
+                : undefined;
+        }
+        if ((message.sourceCpuArchitecture ?? DiskSnapshotStatus_CPUArchitecture.UNDEFINED) !== DiskSnapshotStatus_CPUArchitecture.UNDEFINED) {
+            obj[pick("sourceCpuArchitecture", "source_cpu_architecture")] = DiskSnapshotStatus_CPUArchitecture.toJSON(message.sourceCpuArchitecture);
+        }
+        return obj;
+    },
+    create(base) {
+        return DiskSnapshotStatus.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDiskSnapshotStatus();
+        message.state = (object.state !== undefined && object.state !== null)
+            ? DiskSnapshotStatus_State.fromJSON(object.state.name)
+            : DiskSnapshotStatus_State.UNSPECIFIED;
+        message.contentSizeBytes = (object.contentSizeBytes !== undefined && object.contentSizeBytes !== null)
+            ? Long.fromValue(object.contentSizeBytes)
+            : Long.ZERO;
+        message.storageSizeBytes = (object.storageSizeBytes !== undefined && object.storageSizeBytes !== null)
+            ? Long.fromValue(object.storageSizeBytes)
+            : Long.ZERO;
+        message.lockState = (object.lockState !== undefined && object.lockState !== null)
+            ? DiskSnapshotStatus_LockState.fromPartial(object.lockState)
+            : undefined;
+        message.sourceCpuArchitecture = (object.sourceCpuArchitecture !== undefined && object.sourceCpuArchitecture !== null)
+            ? DiskSnapshotStatus_CPUArchitecture.fromJSON(object.sourceCpuArchitecture.name)
+            : DiskSnapshotStatus_CPUArchitecture.UNDEFINED;
+        return message;
+    },
+};
+protoRegistry.registerMessage(DiskSnapshotStatus);
+function DiskSnapshotStatusCustomInspect() {
+    const parts = [];
+    if (this.state !== undefined)
+        parts.push("state" + "=" + inspect(this.state));
+    if (!this.contentSizeBytes?.isZero?.())
+        parts.push("contentSizeBytes" + "=" + inspect(this.contentSizeBytes));
+    if (!this.storageSizeBytes?.isZero?.())
+        parts.push("storageSizeBytes" + "=" + inspect(this.storageSizeBytes));
+    if (this.lockState !== undefined)
+        parts.push("lockState" + "=" + inspect(this.lockState));
+    if (this.sourceCpuArchitecture !== undefined)
+        parts.push("sourceCpuArchitecture" + "=" + inspect(this.sourceCpuArchitecture));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function DiskSnapshotStatusCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if (this.state !== undefined)
+        obj.state = inspectJson(this.state);
+    if (!this.contentSizeBytes?.isZero?.())
+        obj.contentSizeBytes = inspectJson(this.contentSizeBytes);
+    if (!this.storageSizeBytes?.isZero?.())
+        obj.storageSizeBytes = inspectJson(this.storageSizeBytes);
+    if (this.lockState !== undefined)
+        obj.lockState = inspectJson(this.lockState);
+    if (this.sourceCpuArchitecture !== undefined)
+        obj.sourceCpuArchitecture = inspectJson(this.sourceCpuArchitecture);
+    return obj;
+}
+function applyDiskSnapshotStatusCustom(message) {
+    message[custom] = DiskSnapshotStatusCustomInspect;
+    message[customJson] = DiskSnapshotStatusCustomJson;
+    return message;
+}
+function createBaseDiskSnapshotStatus() {
+    const message = {
+        $type: "nebius.compute.v1.DiskSnapshotStatus",
+        state: DiskSnapshotStatus_State.UNSPECIFIED,
+        contentSizeBytes: Long.ZERO,
+        storageSizeBytes: Long.ZERO,
+        lockState: undefined,
+        sourceCpuArchitecture: DiskSnapshotStatus_CPUArchitecture.UNDEFINED,
+    };
+    return applyDiskSnapshotStatusCustom(message);
+}
+export const DiskSnapshotStatus_LockState = {
+    $type: "nebius.compute.v1.DiskSnapshotStatus.LockState",
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of (message.disks ?? [])) {
+            writer.uint32(10).string(v);
+        }
+        if (message[unknownFieldsSymbol]) {
+            writer.raw(message[unknownFieldsSymbol]);
+        }
+        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 = createBaseDiskSnapshotStatus_LockState();
+        let writer = undefined;
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10)
+                        break;
+                    message.disks.push(reader.string());
+                    continue;
+                }
+                default:
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            {
+                if (!writer)
+                    writer = new BinaryWriter();
+                const skipped = reader.skip(tag & 7, tag >>> 3);
+                writer.uint32(tag).raw(skipped);
+            }
+        }
+        if (writer) {
+            message[unknownFieldsSymbol] = writer.finish();
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return applyDiskSnapshotStatus_LockStateCustom({
+            $type: "nebius.compute.v1.DiskSnapshotStatus.LockState",
+            disks: globalThis.Array.isArray(object?.disks ?? object?.disks)
+                ? (object.disks ?? object.disks).map((e) => String(e))
+                : [],
+        });
+    },
+    toJSON(message, use = "json") {
+        const obj = {};
+        const pick = (json, pb) => (use === "json" ? json : pb);
+        if (message.disks?.length) {
+            obj[pick("disks", "disks")] = message.disks.map((e) => e);
+        }
+        return obj;
+    },
+    create(base) {
+        return DiskSnapshotStatus_LockState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDiskSnapshotStatus_LockState();
+        message.disks = object.disks?.map((e) => e) || [];
+        return message;
+    },
+};
+protoRegistry.registerMessage(DiskSnapshotStatus_LockState);
+function DiskSnapshotStatus_LockStateCustomInspect() {
+    const parts = [];
+    if ((this.disks?.length ?? 0) !== 0)
+        parts.push("disks" + "=" + inspect(this.disks));
+    return `${this.$type}(${parts.join(", ")})`;
+}
+function DiskSnapshotStatus_LockStateCustomJson() {
+    const obj = {
+        type: this.$type,
+    };
+    if ((this.disks?.length ?? 0) !== 0)
+        obj.disks = inspectJson(this.disks);
+    return obj;
+}
+function applyDiskSnapshotStatus_LockStateCustom(message) {
+    message[custom] = DiskSnapshotStatus_LockStateCustomInspect;
+    message[customJson] = DiskSnapshotStatus_LockStateCustomJson;
+    return message;
+}
+function createBaseDiskSnapshotStatus_LockState() {
+    const message = {
+        $type: "nebius.compute.v1.DiskSnapshotStatus.LockState",
+        disks: [],
+    };
+    return applyDiskSnapshotStatus_LockStateCustom(message);
+}
 export const DiskSpec_DiskType = createEnum("nebius.compute.v1.DiskSpec.DiskType", {
     UNSPECIFIED: 0,
     NETWORK_SSD: 1,
@@ -1949,6 +3656,9 @@ export const DiskStatus_LockState = {
         for (const v of (message.images ?? [])) {
             writer.uint32(10).string(v);
         }
+        for (const v of (message.snapshots ?? [])) {
+            writer.uint32(18).string(v);
+        }
         if (message[unknownFieldsSymbol]) {
             writer.raw(message[unknownFieldsSymbol]);
         }
@@ -1968,6 +3678,12 @@ export const DiskStatus_LockState = {
                     message.images.push(reader.string());
                     continue;
                 }
+                case 2: {
+                    if (tag !== 18)
+                        break;
+                    message.snapshots.push(reader.string());
+                    continue;
+                }
                 default:
                     break;
             }
@@ -1992,6 +3708,9 @@ export const DiskStatus_LockState = {
             images: globalThis.Array.isArray(object?.images ?? object?.images)
                 ? (object.images ?? object.images).map((e) => String(e))
                 : [],
+            snapshots: globalThis.Array.isArray(object?.snapshots ?? object?.snapshots)
+                ? (object.snapshots ?? object.snapshots).map((e) => String(e))
+                : [],
         });
     },
     toJSON(message, use = "json") {
@@ -2000,6 +3719,9 @@ export const DiskStatus_LockState = {
         if (message.images?.length) {
             obj[pick("images", "images")] = message.images.map((e) => e);
         }
+        if (message.snapshots?.length) {
+            obj[pick("snapshots", "snapshots")] = message.snapshots.map((e) => e);
+        }
         return obj;
     },
     create(base) {
@@ -2008,6 +3730,7 @@ export const DiskStatus_LockState = {
     fromPartial(object) {
         const message = createBaseDiskStatus_LockState();
         message.images = object.images?.map((e) => e) || [];
+        message.snapshots = object.snapshots?.map((e) => e) || [];
         return message;
     },
 };
@@ -2016,6 +3739,8 @@ function DiskStatus_LockStateCustomInspect() {
     const parts = [];
     if ((this.images?.length ?? 0) !== 0)
         parts.push("images" + "=" + inspect(this.images));
+    if ((this.snapshots?.length ?? 0) !== 0)
+        parts.push("snapshots" + "=" + inspect(this.snapshots));
     return `${this.$type}(${parts.join(", ")})`;
 }
 function DiskStatus_LockStateCustomJson() {
@@ -2024,6 +3749,8 @@ function DiskStatus_LockStateCustomJson() {
     };
     if ((this.images?.length ?? 0) !== 0)
         obj.images = inspectJson(this.images);
+    if ((this.snapshots?.length ?? 0) !== 0)
+        obj.snapshots = inspectJson(this.snapshots);
     return obj;
 }
 function applyDiskStatus_LockStateCustom(message) {
@@ -2035,6 +3762,7 @@ function createBaseDiskStatus_LockState() {
     const message = {
         $type: "nebius.compute.v1.DiskStatus.LockState",
         images: [],
+        snapshots: [],
     };
     return applyDiskStatus_LockStateCustom(message);
 }