@aptpod/iscp-ts
Version:
iSCP 2.0 client library for TypeScript
905 lines • 62.2 kB
JavaScript
import { WireType } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { DownstreamChunkResultExtensionFields } from "./extensions/downstream";
import { DownstreamMetadataAckExtensionFields } from "./extensions/downstream";
import { DownstreamMetadataExtensionFields } from "./extensions/downstream";
import { DownstreamNormalClose } from "./metadata";
import { DownstreamResume } from "./metadata";
import { DownstreamAbnormalClose } from "./metadata";
import { DownstreamOpen } from "./metadata";
import { UpstreamNormalClose } from "./metadata";
import { UpstreamResume } from "./metadata";
import { UpstreamAbnormalClose } from "./metadata";
import { UpstreamOpen } from "./metadata";
import { BaseTime } from "./metadata";
import { DownstreamChunkAckCompleteExtensionFields } from "./extensions/downstream";
import { DownstreamChunkAckExtensionFields } from "./extensions/downstream";
import { DownstreamChunkExtensionFields } from "./extensions/downstream";
import { StreamChunk } from "./common";
import { DownstreamCloseResponseExtensionFields } from "./extensions/downstream";
import { DownstreamCloseRequestExtensionFields } from "./extensions/downstream";
import { DownstreamResumeResponseExtensionFields } from "./extensions/downstream";
import { DownstreamResumeRequestExtensionFields } from "./extensions/downstream";
import { DownstreamOpenResponseExtensionFields } from "./extensions/downstream";
import { ResultCode } from "./result_code";
import { DownstreamOpenRequestExtensionFields } from "./extensions/downstream";
import { QoS } from "./common";
import { DataID } from "./common";
import { DownstreamFilter } from "./common";
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamOpenRequest$Type extends MessageType {
constructor() {
super("iscp2.DownstreamOpenRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "desired_stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "downstream_filters", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DownstreamFilter },
{ no: 4, name: "expiry_interval", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "data_id_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => DataID } },
{ no: 6, name: "qos", kind: "enum", T: () => ["iscp2.QoS", QoS] },
{ no: 7, name: "extension_fields", kind: "message", T: () => DownstreamOpenRequestExtensionFields },
{ no: 8, name: "omit_empty_chunk", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
]);
}
create(value) {
const message = { requestId: 0, desiredStreamIdAlias: 0, downstreamFilters: [], expiryInterval: 0, dataIdAliases: {}, qos: 0, omitEmptyChunk: false };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* uint32 desired_stream_id_alias */ 2:
message.desiredStreamIdAlias = reader.uint32();
break;
case /* repeated iscp2.DownstreamFilter downstream_filters */ 3:
message.downstreamFilters.push(DownstreamFilter.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* uint32 expiry_interval */ 4:
message.expiryInterval = reader.uint32();
break;
case /* map<uint32, iscp2.DataID> data_id_aliases */ 5:
this.binaryReadMap5(message.dataIdAliases, reader, options);
break;
case /* iscp2.QoS qos */ 6:
message.qos = reader.int32();
break;
case /* iscp2.DownstreamOpenRequestExtensionFields extension_fields */ 7:
message.extensionFields = DownstreamOpenRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
case /* bool omit_empty_chunk */ 8:
message.omitEmptyChunk = reader.bool();
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
binaryReadMap5(map, reader, options) {
let len = reader.uint32(), end = reader.pos + len, key, val;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case 1:
key = reader.uint32();
break;
case 2:
val = DataID.internalBinaryRead(reader, reader.uint32(), options);
break;
default: throw new globalThis.Error("unknown map entry field for field iscp2.DownstreamOpenRequest.data_id_aliases");
}
}
map[key ?? 0] = val ?? DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* uint32 desired_stream_id_alias = 2; */
if (message.desiredStreamIdAlias !== 0)
writer.tag(2, WireType.Varint).uint32(message.desiredStreamIdAlias);
/* repeated iscp2.DownstreamFilter downstream_filters = 3; */
for (let i = 0; i < message.downstreamFilters.length; i++)
DownstreamFilter.internalBinaryWrite(message.downstreamFilters[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
/* uint32 expiry_interval = 4; */
if (message.expiryInterval !== 0)
writer.tag(4, WireType.Varint).uint32(message.expiryInterval);
/* map<uint32, iscp2.DataID> data_id_aliases = 5; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(5, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k));
writer.tag(2, WireType.LengthDelimited).fork();
DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* iscp2.QoS qos = 6; */
if (message.qos !== 0)
writer.tag(6, WireType.Varint).int32(message.qos);
/* iscp2.DownstreamOpenRequestExtensionFields extension_fields = 7; */
if (message.extensionFields)
DownstreamOpenRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
/* bool omit_empty_chunk = 8; */
if (message.omitEmptyChunk !== false)
writer.tag(8, WireType.Varint).bool(message.omitEmptyChunk);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamOpenRequest
*/
export const DownstreamOpenRequest = new DownstreamOpenRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamOpenResponse$Type extends MessageType {
constructor() {
super("iscp2.DownstreamOpenResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "assigned_stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "server_time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
{ no: 4, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 5, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 6, name: "extension_fields", kind: "message", T: () => DownstreamOpenResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, assignedStreamId: new Uint8Array(0), serverTime: 0n, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes assigned_stream_id */ 2:
message.assignedStreamId = reader.bytes();
break;
case /* sint64 server_time */ 3:
message.serverTime = reader.sint64().toBigInt();
break;
case /* iscp2.ResultCode result_code */ 4:
message.resultCode = reader.int32();
break;
case /* string result_string */ 5:
message.resultString = reader.string();
break;
case /* iscp2.DownstreamOpenResponseExtensionFields extension_fields */ 6:
message.extensionFields = DownstreamOpenResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes assigned_stream_id = 2; */
if (message.assignedStreamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.assignedStreamId);
/* sint64 server_time = 3; */
if (message.serverTime !== 0n)
writer.tag(3, WireType.Varint).sint64(message.serverTime);
/* iscp2.ResultCode result_code = 4; */
if (message.resultCode !== 0)
writer.tag(4, WireType.Varint).int32(message.resultCode);
/* string result_string = 5; */
if (message.resultString !== "")
writer.tag(5, WireType.LengthDelimited).string(message.resultString);
/* iscp2.DownstreamOpenResponseExtensionFields extension_fields = 6; */
if (message.extensionFields)
DownstreamOpenResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamOpenResponse
*/
export const DownstreamOpenResponse = new DownstreamOpenResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamResumeRequest$Type extends MessageType {
constructor() {
super("iscp2.DownstreamResumeRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "desired_stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => DownstreamResumeRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0), desiredStreamIdAlias: 0 };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes stream_id */ 2:
message.streamId = reader.bytes();
break;
case /* uint32 desired_stream_id_alias */ 3:
message.desiredStreamIdAlias = reader.uint32();
break;
case /* iscp2.DownstreamResumeRequestExtensionFields extension_fields */ 4:
message.extensionFields = DownstreamResumeRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.streamId);
/* uint32 desired_stream_id_alias = 3; */
if (message.desiredStreamIdAlias !== 0)
writer.tag(3, WireType.Varint).uint32(message.desiredStreamIdAlias);
/* iscp2.DownstreamResumeRequestExtensionFields extension_fields = 4; */
if (message.extensionFields)
DownstreamResumeRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamResumeRequest
*/
export const DownstreamResumeRequest = new DownstreamResumeRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamResumeResponse$Type extends MessageType {
constructor() {
super("iscp2.DownstreamResumeResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => DownstreamResumeResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 2:
message.resultCode = reader.int32();
break;
case /* string result_string */ 3:
message.resultString = reader.string();
break;
case /* iscp2.DownstreamResumeResponseExtensionFields extension_fields */ 4:
message.extensionFields = DownstreamResumeResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, WireType.LengthDelimited).string(message.resultString);
/* iscp2.DownstreamResumeResponseExtensionFields extension_fields = 4; */
if (message.extensionFields)
DownstreamResumeResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamResumeResponse
*/
export const DownstreamResumeResponse = new DownstreamResumeResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamCloseRequest$Type extends MessageType {
constructor() {
super("iscp2.DownstreamCloseRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "extension_fields", kind: "message", T: () => DownstreamCloseRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0) };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes stream_id */ 2:
message.streamId = reader.bytes();
break;
case /* iscp2.DownstreamCloseRequestExtensionFields extension_fields */ 3:
message.extensionFields = DownstreamCloseRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.streamId);
/* iscp2.DownstreamCloseRequestExtensionFields extension_fields = 3; */
if (message.extensionFields)
DownstreamCloseRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamCloseRequest
*/
export const DownstreamCloseRequest = new DownstreamCloseRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamCloseResponse$Type extends MessageType {
constructor() {
super("iscp2.DownstreamCloseResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => DownstreamCloseResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 2:
message.resultCode = reader.int32();
break;
case /* string result_string */ 3:
message.resultString = reader.string();
break;
case /* iscp2.DownstreamCloseResponseExtensionFields extension_fields */ 4:
message.extensionFields = DownstreamCloseResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, WireType.LengthDelimited).string(message.resultString);
/* iscp2.DownstreamCloseResponseExtensionFields extension_fields = 4; */
if (message.extensionFields)
DownstreamCloseResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamCloseResponse
*/
export const DownstreamCloseResponse = new DownstreamCloseResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamChunk$Type extends MessageType {
constructor() {
super("iscp2.DownstreamChunk", [
{ no: 1, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "upstream_info", kind: "message", oneof: "upstreamOrAlias", T: () => UpstreamInfo },
{ no: 3, name: "upstream_alias", kind: "scalar", oneof: "upstreamOrAlias", T: 13 /*ScalarType.UINT32*/ },
{ no: 4, name: "stream_chunk", kind: "message", T: () => StreamChunk },
{ no: 5, name: "extension_fields", kind: "message", T: () => DownstreamChunkExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, upstreamOrAlias: { oneofKind: undefined } };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 stream_id_alias */ 1:
message.streamIdAlias = reader.uint32();
break;
case /* iscp2.UpstreamInfo upstream_info */ 2:
message.upstreamOrAlias = {
oneofKind: "upstreamInfo",
upstreamInfo: UpstreamInfo.internalBinaryRead(reader, reader.uint32(), options, message.upstreamOrAlias.upstreamInfo)
};
break;
case /* uint32 upstream_alias */ 3:
message.upstreamOrAlias = {
oneofKind: "upstreamAlias",
upstreamAlias: reader.uint32()
};
break;
case /* iscp2.StreamChunk stream_chunk */ 4:
message.streamChunk = StreamChunk.internalBinaryRead(reader, reader.uint32(), options, message.streamChunk);
break;
case /* iscp2.DownstreamChunkExtensionFields extension_fields */ 5:
message.extensionFields = DownstreamChunkExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, WireType.Varint).uint32(message.streamIdAlias);
/* iscp2.UpstreamInfo upstream_info = 2; */
if (message.upstreamOrAlias.oneofKind === "upstreamInfo")
UpstreamInfo.internalBinaryWrite(message.upstreamOrAlias.upstreamInfo, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* uint32 upstream_alias = 3; */
if (message.upstreamOrAlias.oneofKind === "upstreamAlias")
writer.tag(3, WireType.Varint).uint32(message.upstreamOrAlias.upstreamAlias);
/* iscp2.StreamChunk stream_chunk = 4; */
if (message.streamChunk)
StreamChunk.internalBinaryWrite(message.streamChunk, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
/* iscp2.DownstreamChunkExtensionFields extension_fields = 5; */
if (message.extensionFields)
DownstreamChunkExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamChunk
*/
export const DownstreamChunk = new DownstreamChunk$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamChunkAck$Type extends MessageType {
constructor() {
super("iscp2.DownstreamChunkAck", [
{ no: 1, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "ack_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "results", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DownstreamChunkResult },
{ no: 4, name: "upstream_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => UpstreamInfo } },
{ no: 5, name: "data_id_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => DataID } },
{ no: 6, name: "extension_fields", kind: "message", T: () => DownstreamChunkAckExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, ackId: 0, results: [], upstreamAliases: {}, dataIdAliases: {} };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 stream_id_alias */ 1:
message.streamIdAlias = reader.uint32();
break;
case /* uint32 ack_id */ 2:
message.ackId = reader.uint32();
break;
case /* repeated iscp2.DownstreamChunkResult results */ 3:
message.results.push(DownstreamChunkResult.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* map<uint32, iscp2.UpstreamInfo> upstream_aliases */ 4:
this.binaryReadMap4(message.upstreamAliases, reader, options);
break;
case /* map<uint32, iscp2.DataID> data_id_aliases */ 5:
this.binaryReadMap5(message.dataIdAliases, reader, options);
break;
case /* iscp2.DownstreamChunkAckExtensionFields extension_fields */ 6:
message.extensionFields = DownstreamChunkAckExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
binaryReadMap4(map, reader, options) {
let len = reader.uint32(), end = reader.pos + len, key, val;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case 1:
key = reader.uint32();
break;
case 2:
val = UpstreamInfo.internalBinaryRead(reader, reader.uint32(), options);
break;
default: throw new globalThis.Error("unknown map entry field for field iscp2.DownstreamChunkAck.upstream_aliases");
}
}
map[key ?? 0] = val ?? UpstreamInfo.create();
}
binaryReadMap5(map, reader, options) {
let len = reader.uint32(), end = reader.pos + len, key, val;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case 1:
key = reader.uint32();
break;
case 2:
val = DataID.internalBinaryRead(reader, reader.uint32(), options);
break;
default: throw new globalThis.Error("unknown map entry field for field iscp2.DownstreamChunkAck.data_id_aliases");
}
}
map[key ?? 0] = val ?? DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, WireType.Varint).uint32(message.streamIdAlias);
/* uint32 ack_id = 2; */
if (message.ackId !== 0)
writer.tag(2, WireType.Varint).uint32(message.ackId);
/* repeated iscp2.DownstreamChunkResult results = 3; */
for (let i = 0; i < message.results.length; i++)
DownstreamChunkResult.internalBinaryWrite(message.results[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
/* map<uint32, iscp2.UpstreamInfo> upstream_aliases = 4; */
for (let k of Object.keys(message.upstreamAliases)) {
writer.tag(4, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k));
writer.tag(2, WireType.LengthDelimited).fork();
UpstreamInfo.internalBinaryWrite(message.upstreamAliases[k], writer, options);
writer.join().join();
}
/* map<uint32, iscp2.DataID> data_id_aliases = 5; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(5, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k));
writer.tag(2, WireType.LengthDelimited).fork();
DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* iscp2.DownstreamChunkAckExtensionFields extension_fields = 6; */
if (message.extensionFields)
DownstreamChunkAckExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamChunkAck
*/
export const DownstreamChunkAck = new DownstreamChunkAck$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamChunkAckComplete$Type extends MessageType {
constructor() {
super("iscp2.DownstreamChunkAckComplete", [
{ no: 1, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "ack_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 4, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 5, name: "extension_fields", kind: "message", T: () => DownstreamChunkAckCompleteExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, ackId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 stream_id_alias */ 1:
message.streamIdAlias = reader.uint32();
break;
case /* uint32 ack_id */ 2:
message.ackId = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 3:
message.resultCode = reader.int32();
break;
case /* string result_string */ 4:
message.resultString = reader.string();
break;
case /* iscp2.DownstreamChunkAckCompleteExtensionFields extension_fields */ 5:
message.extensionFields = DownstreamChunkAckCompleteExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, WireType.Varint).uint32(message.streamIdAlias);
/* uint32 ack_id = 2; */
if (message.ackId !== 0)
writer.tag(2, WireType.Varint).uint32(message.ackId);
/* iscp2.ResultCode result_code = 3; */
if (message.resultCode !== 0)
writer.tag(3, WireType.Varint).int32(message.resultCode);
/* string result_string = 4; */
if (message.resultString !== "")
writer.tag(4, WireType.LengthDelimited).string(message.resultString);
/* iscp2.DownstreamChunkAckCompleteExtensionFields extension_fields = 5; */
if (message.extensionFields)
DownstreamChunkAckCompleteExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.DownstreamChunkAckComplete
*/
export const DownstreamChunkAckComplete = new DownstreamChunkAckComplete$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DownstreamMetadata$Type extends MessageType {
constructor() {
super("iscp2.DownstreamMetadata", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 13, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "base_time", kind: "message", oneof: "metadata", T: () => BaseTime },
{ no: 3, name: "upstream_open", kind: "message", oneof: "metadata", T: () => UpstreamOpen },
{ no: 4, name: "upstream_abnormal_close", kind: "message", oneof: "metadata", T: () => UpstreamAbnormalClose },
{ no: 5, name: "upstream_resume", kind: "message", oneof: "metadata", T: () => UpstreamResume },
{ no: 6, name: "upstream_normal_close", kind: "message", oneof: "metadata", T: () => UpstreamNormalClose },
{ no: 7, name: "downstream_open", kind: "message", oneof: "metadata", T: () => DownstreamOpen },
{ no: 8, name: "downstream_abnormal_close", kind: "message", oneof: "metadata", T: () => DownstreamAbnormalClose },
{ no: 9, name: "downstream_resume", kind: "message", oneof: "metadata", T: () => DownstreamResume },
{ no: 10, name: "downstream_normal_close", kind: "message", oneof: "metadata", T: () => DownstreamNormalClose },
{ no: 11, name: "source_node_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 12, name: "extension_fields", kind: "message", T: () => DownstreamMetadataExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamIdAlias: 0, metadata: { oneofKind: undefined }, sourceNodeId: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* uint32 stream_id_alias */ 13:
message.streamIdAlias = reader.uint32();
break;
case /* iscp2.BaseTime base_time */ 2:
message.metadata = {
oneofKind: "baseTime",
baseTime: BaseTime.internalBinaryRead(reader, reader.uint32(), options, message.metadata.baseTime)
};
break;
case /* iscp2.UpstreamOpen upstream_open */ 3:
message.metadata = {
oneofKind: "upstreamOpen",
upstreamOpen: UpstreamOpen.internalBinaryRead(reader, reader.uint32(), options, message.metadata.upstreamOpen)
};
break;
case /* iscp2.UpstreamAbnormalClose upstream_abnormal_close */ 4:
message.metadata = {
oneofKind: "upstreamAbnormalClose",
upstreamAbnormalClose: UpstreamAbnormalClose.internalBinaryRead(reader, reader.uint32(), options, message.metadata.upstreamAbnormalClose)
};
break;
case /* iscp2.UpstreamResume upstream_resume */ 5:
message.metadata = {
oneofKind: "upstreamResume",
upstreamResume: UpstreamResume.internalBinaryRead(reader, reader.uint32(), options, message.metadata.upstreamResume)
};
break;
case /* iscp2.UpstreamNormalClose upstream_normal_close */ 6:
message.metadata = {
oneofKind: "upstreamNormalClose",
upstreamNormalClose: UpstreamNormalClose.internalBinaryRead(reader, reader.uint32(), options, message.metadata.upstreamNormalClose)
};
break;
case /* iscp2.DownstreamOpen downstream_open */ 7:
message.metadata = {
oneofKind: "downstreamOpen",
downstreamOpen: DownstreamOpen.internalBinaryRead(reader, reader.uint32(), options, message.metadata.downstreamOpen)
};
break;
case /* iscp2.DownstreamAbnormalClose downstream_abnormal_close */ 8:
message.metadata = {
oneofKind: "downstreamAbnormalClose",
downstreamAbnormalClose: DownstreamAbnormalClose.internalBinaryRead(reader, reader.uint32(), options, message.metadata.downstreamAbnormalClose)
};
break;
case /* iscp2.DownstreamResume downstream_resume */ 9:
message.metadata = {
oneofKind: "downstreamResume",
downstreamResume: DownstreamResume.internalBinaryRead(reader, reader.uint32(), options, message.metadata.downstreamResume)
};
break;
case /* iscp2.DownstreamNormalClose downstream_normal_close */ 10:
message.metadata = {
oneofKind: "downstreamNormalClose",
downstreamNormalClose: DownstreamNormalClose.internalBinaryRead(reader, reader.uint32(), options, message.metadata.downstreamNormalClose)
};
break;
case /* string source_node_id */ 11:
message.sourceNodeId = reader.string();
break;
case /* iscp2.DownstreamMetadataExtensionFields extension_fields */ 12:
message.extensionFields = DownstreamMetadataExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* uint32 stream_id_alias = 13; */
if (message.streamIdAlias !== 0)
writer.tag(13, WireType.Varint).uint32(message.streamIdAlias);
/* iscp2.BaseTime base_time = 2; */
if (message.metadata.oneofKind === "baseTime")
BaseTime.internalBinaryWrite(message.metadata.baseTime, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamOpen upstream_open = 3; */
if (message.metadata.oneofKind === "upstreamOpen")
UpstreamOpen.internalBinaryWrite(message.metadata.upstreamOpen, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamAbnormalClose upstream_abnormal_close = 4; */
if (message.metadata.oneofKind === "upstreamAbnormalClose")
UpstreamAbnormalClose.internalBinaryWrite(message.metadata.upstreamAbnormalClose, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamResume upstream_resume = 5; */
if (message.metadata.oneofKind === "upstreamResume")
UpstreamResume.internalBinaryWrite(message.metadata.upstreamResume, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamNormalClose upstream_normal_close = 6; */
if (message.metadata.oneofKind === "upstreamNormalClose")
UpstreamNormalClose.internalBinaryWrite(message.metadata.upstreamNormalClose, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
/* iscp2.DownstreamOpen downstream_open = 7; */
if (message.metadata.oneofKind === "downstreamOpen")
DownstreamOpen.