@ekhein/lamda-node-sdk 1.0.3 → 2.0.1

package/dist/src/rpc/util.js

@@ -0,0 +1,1158 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export const protobufPackage = "lamda.rpc";
+export var ToastDuration;
+(function (ToastDuration) {
+    ToastDuration[ToastDuration["TD_SHORT"] = 0] = "TD_SHORT";
+    ToastDuration[ToastDuration["TD_LONG"] = 1] = "TD_LONG";
+    ToastDuration[ToastDuration["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ToastDuration || (ToastDuration = {}));
+export function toastDurationFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "TD_SHORT":
+            return ToastDuration.TD_SHORT;
+        case 1:
+        case "TD_LONG":
+            return ToastDuration.TD_LONG;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ToastDuration.UNRECOGNIZED;
+    }
+}
+export function toastDurationToJSON(object) {
+    switch (object) {
+        case ToastDuration.TD_SHORT:
+            return "TD_SHORT";
+        case ToastDuration.TD_LONG:
+            return "TD_LONG";
+        case ToastDuration.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseTouchDown() {
+    return { tid: 0, x: 0, y: 0, pressure: 0 };
+}
+export const TouchDown = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.tid !== 0) {
+            writer.uint32(8).int32(message.tid);
+        }
+        if (message.x !== 0) {
+            writer.uint32(16).int32(message.x);
+        }
+        if (message.y !== 0) {
+            writer.uint32(24).int32(message.y);
+        }
+        if (message.pressure !== 0) {
+            writer.uint32(32).int32(message.pressure);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchDown();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.tid = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.x = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.y = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.pressure = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            tid: isSet(object.tid) ? globalThis.Number(object.tid) : 0,
+            x: isSet(object.x) ? globalThis.Number(object.x) : 0,
+            y: isSet(object.y) ? globalThis.Number(object.y) : 0,
+            pressure: isSet(object.pressure) ? globalThis.Number(object.pressure) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.tid !== 0) {
+            obj.tid = Math.round(message.tid);
+        }
+        if (message.x !== 0) {
+            obj.x = Math.round(message.x);
+        }
+        if (message.y !== 0) {
+            obj.y = Math.round(message.y);
+        }
+        if (message.pressure !== 0) {
+            obj.pressure = Math.round(message.pressure);
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchDown.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchDown();
+        message.tid = object.tid ?? 0;
+        message.x = object.x ?? 0;
+        message.y = object.y ?? 0;
+        message.pressure = object.pressure ?? 0;
+        return message;
+    },
+};
+function createBaseTouchUp() {
+    return { tid: 0 };
+}
+export const TouchUp = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.tid !== 0) {
+            writer.uint32(8).int32(message.tid);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchUp();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.tid = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { tid: isSet(object.tid) ? globalThis.Number(object.tid) : 0 };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.tid !== 0) {
+            obj.tid = Math.round(message.tid);
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchUp.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchUp();
+        message.tid = object.tid ?? 0;
+        return message;
+    },
+};
+function createBaseTouchMove() {
+    return { tid: 0, x: 0, y: 0, pressure: 0 };
+}
+export const TouchMove = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.tid !== 0) {
+            writer.uint32(8).int32(message.tid);
+        }
+        if (message.x !== 0) {
+            writer.uint32(16).int32(message.x);
+        }
+        if (message.y !== 0) {
+            writer.uint32(24).int32(message.y);
+        }
+        if (message.pressure !== 0) {
+            writer.uint32(32).int32(message.pressure);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchMove();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.tid = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.x = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.y = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.pressure = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            tid: isSet(object.tid) ? globalThis.Number(object.tid) : 0,
+            x: isSet(object.x) ? globalThis.Number(object.x) : 0,
+            y: isSet(object.y) ? globalThis.Number(object.y) : 0,
+            pressure: isSet(object.pressure) ? globalThis.Number(object.pressure) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.tid !== 0) {
+            obj.tid = Math.round(message.tid);
+        }
+        if (message.x !== 0) {
+            obj.x = Math.round(message.x);
+        }
+        if (message.y !== 0) {
+            obj.y = Math.round(message.y);
+        }
+        if (message.pressure !== 0) {
+            obj.pressure = Math.round(message.pressure);
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchMove.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchMove();
+        message.tid = object.tid ?? 0;
+        message.x = object.x ?? 0;
+        message.y = object.y ?? 0;
+        message.pressure = object.pressure ?? 0;
+        return message;
+    },
+};
+function createBaseTouchWait() {
+    return { wait: 0 };
+}
+export const TouchWait = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.wait !== 0) {
+            writer.uint32(8).uint32(message.wait);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchWait();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.wait = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { wait: isSet(object.wait) ? globalThis.Number(object.wait) : 0 };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.wait !== 0) {
+            obj.wait = Math.round(message.wait);
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchWait.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchWait();
+        message.wait = object.wait ?? 0;
+        return message;
+    },
+};
+function createBaseTouchAction() {
+    return { down: undefined, move: undefined, wait: undefined, up: undefined };
+}
+export const TouchAction = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.down !== undefined) {
+            TouchDown.encode(message.down, writer.uint32(10).fork()).join();
+        }
+        if (message.move !== undefined) {
+            TouchMove.encode(message.move, writer.uint32(18).fork()).join();
+        }
+        if (message.wait !== undefined) {
+            TouchWait.encode(message.wait, writer.uint32(26).fork()).join();
+        }
+        if (message.up !== undefined) {
+            TouchUp.encode(message.up, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchAction();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.down = TouchDown.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.move = TouchMove.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.wait = TouchWait.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.up = TouchUp.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            down: isSet(object.down) ? TouchDown.fromJSON(object.down) : undefined,
+            move: isSet(object.move) ? TouchMove.fromJSON(object.move) : undefined,
+            wait: isSet(object.wait) ? TouchWait.fromJSON(object.wait) : undefined,
+            up: isSet(object.up) ? TouchUp.fromJSON(object.up) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.down !== undefined) {
+            obj.down = TouchDown.toJSON(message.down);
+        }
+        if (message.move !== undefined) {
+            obj.move = TouchMove.toJSON(message.move);
+        }
+        if (message.wait !== undefined) {
+            obj.wait = TouchWait.toJSON(message.wait);
+        }
+        if (message.up !== undefined) {
+            obj.up = TouchUp.toJSON(message.up);
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchAction.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchAction();
+        message.down = (object.down !== undefined && object.down !== null) ? TouchDown.fromPartial(object.down) : undefined;
+        message.move = (object.move !== undefined && object.move !== null) ? TouchMove.fromPartial(object.move) : undefined;
+        message.wait = (object.wait !== undefined && object.wait !== null) ? TouchWait.fromPartial(object.wait) : undefined;
+        message.up = (object.up !== undefined && object.up !== null) ? TouchUp.fromPartial(object.up) : undefined;
+        return message;
+    },
+};
+function createBaseTouchSequence() {
+    return { sequence: [] };
+}
+export const TouchSequence = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.sequence) {
+            TouchAction.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTouchSequence();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.sequence.push(TouchAction.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sequence: globalThis.Array.isArray(object?.sequence)
+                ? object.sequence.map((e) => TouchAction.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.sequence?.length) {
+            obj.sequence = message.sequence.map((e) => TouchAction.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return TouchSequence.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTouchSequence();
+        message.sequence = object.sequence?.map((e) => TouchAction.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBasePerformTouchRequest() {
+    return { sequence: undefined, wait: false };
+}
+export const PerformTouchRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.sequence !== undefined) {
+            TouchSequence.encode(message.sequence, writer.uint32(10).fork()).join();
+        }
+        if (message.wait !== false) {
+            writer.uint32(16).bool(message.wait);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePerformTouchRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.sequence = TouchSequence.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.wait = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sequence: isSet(object.sequence) ? TouchSequence.fromJSON(object.sequence) : undefined,
+            wait: isSet(object.wait) ? globalThis.Boolean(object.wait) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.sequence !== undefined) {
+            obj.sequence = TouchSequence.toJSON(message.sequence);
+        }
+        if (message.wait !== false) {
+            obj.wait = message.wait;
+        }
+        return obj;
+    },
+    create(base) {
+        return PerformTouchRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePerformTouchRequest();
+        message.sequence = (object.sequence !== undefined && object.sequence !== null)
+            ? TouchSequence.fromPartial(object.sequence)
+            : undefined;
+        message.wait = object.wait ?? false;
+        return message;
+    },
+};
+function createBaseSetPropRequest() {
+    return { name: "", value: "" };
+}
+export const SetPropRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSetPropRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return SetPropRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSetPropRequest();
+        message.name = object.name ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+function createBaseCertifiRequest() {
+    return { cert: new Uint8Array(0) };
+}
+export const CertifiRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.cert.length !== 0) {
+            writer.uint32(10).bytes(message.cert);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCertifiRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.cert = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { cert: isSet(object.cert) ? bytesFromBase64(object.cert) : new Uint8Array(0) };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.cert.length !== 0) {
+            obj.cert = base64FromBytes(message.cert);
+        }
+        return obj;
+    },
+    create(base) {
+        return CertifiRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCertifiRequest();
+        message.cert = object.cert ?? new Uint8Array(0);
+        return message;
+    },
+};
+function createBaseShowToastRequest() {
+    return { text: "", duration: 0 };
+}
+export const ShowToastRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.text !== "") {
+            writer.uint32(10).string(message.text);
+        }
+        if (message.duration !== 0) {
+            writer.uint32(16).int32(message.duration);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseShowToastRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.text = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.duration = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            text: isSet(object.text) ? globalThis.String(object.text) : "",
+            duration: isSet(object.duration) ? toastDurationFromJSON(object.duration) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.text !== "") {
+            obj.text = message.text;
+        }
+        if (message.duration !== 0) {
+            obj.duration = toastDurationToJSON(message.duration);
+        }
+        return obj;
+    },
+    create(base) {
+        return ShowToastRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseShowToastRequest();
+        message.text = object.text ?? "";
+        message.duration = object.duration ?? 0;
+        return message;
+    },
+};
+function createBaseServerInfoResponse() {
+    return { uniqueId: "", version: "", architecture: "", uptime: 0, secure: false };
+}
+export const ServerInfoResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.uniqueId !== "") {
+            writer.uint32(10).string(message.uniqueId);
+        }
+        if (message.version !== "") {
+            writer.uint32(18).string(message.version);
+        }
+        if (message.architecture !== "") {
+            writer.uint32(26).string(message.architecture);
+        }
+        if (message.uptime !== 0) {
+            writer.uint32(32).uint64(message.uptime);
+        }
+        if (message.secure !== false) {
+            writer.uint32(40).bool(message.secure);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseServerInfoResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.uniqueId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.version = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.architecture = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.uptime = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.secure = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            uniqueId: isSet(object.uniqueId) ? globalThis.String(object.uniqueId) : "",
+            version: isSet(object.version) ? globalThis.String(object.version) : "",
+            architecture: isSet(object.architecture) ? globalThis.String(object.architecture) : "",
+            uptime: isSet(object.uptime) ? globalThis.Number(object.uptime) : 0,
+            secure: isSet(object.secure) ? globalThis.Boolean(object.secure) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.uniqueId !== "") {
+            obj.uniqueId = message.uniqueId;
+        }
+        if (message.version !== "") {
+            obj.version = message.version;
+        }
+        if (message.architecture !== "") {
+            obj.architecture = message.architecture;
+        }
+        if (message.uptime !== 0) {
+            obj.uptime = Math.round(message.uptime);
+        }
+        if (message.secure !== false) {
+            obj.secure = message.secure;
+        }
+        return obj;
+    },
+    create(base) {
+        return ServerInfoResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseServerInfoResponse();
+        message.uniqueId = object.uniqueId ?? "";
+        message.version = object.version ?? "";
+        message.architecture = object.architecture ?? "";
+        message.uptime = object.uptime ?? 0;
+        message.secure = object.secure ?? false;
+        return message;
+    },
+};
+function createBaseHexPatchRequest() {
+    return { pattern: "", replacement: "", path: "", maxreplace: 0, dryrun: false };
+}
+export const HexPatchRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.pattern !== "") {
+            writer.uint32(10).string(message.pattern);
+        }
+        if (message.replacement !== "") {
+            writer.uint32(18).string(message.replacement);
+        }
+        if (message.path !== "") {
+            writer.uint32(26).string(message.path);
+        }
+        if (message.maxreplace !== 0) {
+            writer.uint32(32).int32(message.maxreplace);
+        }
+        if (message.dryrun !== false) {
+            writer.uint32(40).bool(message.dryrun);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHexPatchRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.pattern = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.replacement = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.path = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.maxreplace = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.dryrun = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "",
+            replacement: isSet(object.replacement) ? globalThis.String(object.replacement) : "",
+            path: isSet(object.path) ? globalThis.String(object.path) : "",
+            maxreplace: isSet(object.maxreplace) ? globalThis.Number(object.maxreplace) : 0,
+            dryrun: isSet(object.dryrun) ? globalThis.Boolean(object.dryrun) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.pattern !== "") {
+            obj.pattern = message.pattern;
+        }
+        if (message.replacement !== "") {
+            obj.replacement = message.replacement;
+        }
+        if (message.path !== "") {
+            obj.path = message.path;
+        }
+        if (message.maxreplace !== 0) {
+            obj.maxreplace = Math.round(message.maxreplace);
+        }
+        if (message.dryrun !== false) {
+            obj.dryrun = message.dryrun;
+        }
+        return obj;
+    },
+    create(base) {
+        return HexPatchRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseHexPatchRequest();
+        message.pattern = object.pattern ?? "";
+        message.replacement = object.replacement ?? "";
+        message.path = object.path ?? "";
+        message.maxreplace = object.maxreplace ?? 0;
+        message.dryrun = object.dryrun ?? false;
+        return message;
+    },
+};
+function createBaseHexPatchItem() {
+    return { path: "", index: 0, offset: 0 };
+}
+export const HexPatchItem = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.path !== "") {
+            writer.uint32(10).string(message.path);
+        }
+        if (message.index !== 0) {
+            writer.uint32(16).int32(message.index);
+        }
+        if (message.offset !== 0) {
+            writer.uint32(24).uint64(message.offset);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHexPatchItem();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.path = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.index = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.offset = longToNumber(reader.uint64());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            path: isSet(object.path) ? globalThis.String(object.path) : "",
+            index: isSet(object.index) ? globalThis.Number(object.index) : 0,
+            offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.path !== "") {
+            obj.path = message.path;
+        }
+        if (message.index !== 0) {
+            obj.index = Math.round(message.index);
+        }
+        if (message.offset !== 0) {
+            obj.offset = Math.round(message.offset);
+        }
+        return obj;
+    },
+    create(base) {
+        return HexPatchItem.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseHexPatchItem();
+        message.path = object.path ?? "";
+        message.index = object.index ?? 0;
+        message.offset = object.offset ?? 0;
+        return message;
+    },
+};
+function createBaseHexPatchResponse() {
+    return { count: 0, replaces: [] };
+}
+export const HexPatchResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.count !== 0) {
+            writer.uint32(8).int32(message.count);
+        }
+        for (const v of message.replaces) {
+            HexPatchItem.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHexPatchResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.count = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.replaces.push(HexPatchItem.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            count: isSet(object.count) ? globalThis.Number(object.count) : 0,
+            replaces: globalThis.Array.isArray(object?.replaces)
+                ? object.replaces.map((e) => HexPatchItem.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.count !== 0) {
+            obj.count = Math.round(message.count);
+        }
+        if (message.replaces?.length) {
+            obj.replaces = message.replaces.map((e) => HexPatchItem.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return HexPatchResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseHexPatchResponse();
+        message.count = object.count ?? 0;
+        message.replaces = object.replaces?.map((e) => HexPatchItem.fromPartial(e)) || [];
+        return message;
+    },
+};
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
+}
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}