@ekhein/lamda-node-sdk 1.0.2 → 2.0.0

package/dist/src/rpc/proxy.js

@@ -0,0 +1,774 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ApplicationInfo } from "./application";
+export const protobufPackage = "lamda.rpc";
+export var GproxyType;
+(function (GproxyType) {
+    GproxyType[GproxyType["SOCKS5"] = 0] = "SOCKS5";
+    GproxyType[GproxyType["HTTP_CONNECT"] = 1] = "HTTP_CONNECT";
+    GproxyType[GproxyType["HTTP_RELAY"] = 2] = "HTTP_RELAY";
+    GproxyType[GproxyType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(GproxyType || (GproxyType = {}));
+export function gproxyTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SOCKS5":
+            return GproxyType.SOCKS5;
+        case 1:
+        case "HTTP_CONNECT":
+            return GproxyType.HTTP_CONNECT;
+        case 2:
+        case "HTTP_RELAY":
+            return GproxyType.HTTP_RELAY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return GproxyType.UNRECOGNIZED;
+    }
+}
+export function gproxyTypeToJSON(object) {
+    switch (object) {
+        case GproxyType.SOCKS5:
+            return "SOCKS5";
+        case GproxyType.HTTP_CONNECT:
+            return "HTTP_CONNECT";
+        case GproxyType.HTTP_RELAY:
+            return "HTTP_RELAY";
+        case GproxyType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var OpenVPNProto;
+(function (OpenVPNProto) {
+    OpenVPNProto[OpenVPNProto["TCP"] = 0] = "TCP";
+    OpenVPNProto[OpenVPNProto["UDP"] = 1] = "UDP";
+    OpenVPNProto[OpenVPNProto["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenVPNProto || (OpenVPNProto = {}));
+export function openVPNProtoFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "TCP":
+            return OpenVPNProto.TCP;
+        case 1:
+        case "UDP":
+            return OpenVPNProto.UDP;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenVPNProto.UNRECOGNIZED;
+    }
+}
+export function openVPNProtoToJSON(object) {
+    switch (object) {
+        case OpenVPNProto.TCP:
+            return "TCP";
+        case OpenVPNProto.UDP:
+            return "UDP";
+        case OpenVPNProto.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var OpenVPNAuth;
+(function (OpenVPNAuth) {
+    OpenVPNAuth[OpenVPNAuth["SHA1"] = 0] = "SHA1";
+    OpenVPNAuth[OpenVPNAuth["SHA224"] = 1] = "SHA224";
+    OpenVPNAuth[OpenVPNAuth["SHA256"] = 2] = "SHA256";
+    OpenVPNAuth[OpenVPNAuth["SHA384"] = 3] = "SHA384";
+    OpenVPNAuth[OpenVPNAuth["SHA512"] = 4] = "SHA512";
+    OpenVPNAuth[OpenVPNAuth["RIPEMD160"] = 5] = "RIPEMD160";
+    OpenVPNAuth[OpenVPNAuth["RSA_SHA1"] = 6] = "RSA_SHA1";
+    OpenVPNAuth[OpenVPNAuth["RSA_SHA224"] = 7] = "RSA_SHA224";
+    OpenVPNAuth[OpenVPNAuth["RSA_SHA256"] = 8] = "RSA_SHA256";
+    OpenVPNAuth[OpenVPNAuth["RSA_SHA384"] = 9] = "RSA_SHA384";
+    OpenVPNAuth[OpenVPNAuth["RSA_SHA512"] = 10] = "RSA_SHA512";
+    OpenVPNAuth[OpenVPNAuth["RSA_RIPEMD160"] = 11] = "RSA_RIPEMD160";
+    OpenVPNAuth[OpenVPNAuth["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenVPNAuth || (OpenVPNAuth = {}));
+export function openVPNAuthFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SHA1":
+            return OpenVPNAuth.SHA1;
+        case 1:
+        case "SHA224":
+            return OpenVPNAuth.SHA224;
+        case 2:
+        case "SHA256":
+            return OpenVPNAuth.SHA256;
+        case 3:
+        case "SHA384":
+            return OpenVPNAuth.SHA384;
+        case 4:
+        case "SHA512":
+            return OpenVPNAuth.SHA512;
+        case 5:
+        case "RIPEMD160":
+            return OpenVPNAuth.RIPEMD160;
+        case 6:
+        case "RSA_SHA1":
+            return OpenVPNAuth.RSA_SHA1;
+        case 7:
+        case "RSA_SHA224":
+            return OpenVPNAuth.RSA_SHA224;
+        case 8:
+        case "RSA_SHA256":
+            return OpenVPNAuth.RSA_SHA256;
+        case 9:
+        case "RSA_SHA384":
+            return OpenVPNAuth.RSA_SHA384;
+        case 10:
+        case "RSA_SHA512":
+            return OpenVPNAuth.RSA_SHA512;
+        case 11:
+        case "RSA_RIPEMD160":
+            return OpenVPNAuth.RSA_RIPEMD160;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenVPNAuth.UNRECOGNIZED;
+    }
+}
+export function openVPNAuthToJSON(object) {
+    switch (object) {
+        case OpenVPNAuth.SHA1:
+            return "SHA1";
+        case OpenVPNAuth.SHA224:
+            return "SHA224";
+        case OpenVPNAuth.SHA256:
+            return "SHA256";
+        case OpenVPNAuth.SHA384:
+            return "SHA384";
+        case OpenVPNAuth.SHA512:
+            return "SHA512";
+        case OpenVPNAuth.RIPEMD160:
+            return "RIPEMD160";
+        case OpenVPNAuth.RSA_SHA1:
+            return "RSA_SHA1";
+        case OpenVPNAuth.RSA_SHA224:
+            return "RSA_SHA224";
+        case OpenVPNAuth.RSA_SHA256:
+            return "RSA_SHA256";
+        case OpenVPNAuth.RSA_SHA384:
+            return "RSA_SHA384";
+        case OpenVPNAuth.RSA_SHA512:
+            return "RSA_SHA512";
+        case OpenVPNAuth.RSA_RIPEMD160:
+            return "RSA_RIPEMD160";
+        case OpenVPNAuth.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var OpenVPNCipher;
+(function (OpenVPNCipher) {
+    OpenVPNCipher[OpenVPNCipher["AES_128_GCM"] = 0] = "AES_128_GCM";
+    OpenVPNCipher[OpenVPNCipher["AES_256_GCM"] = 1] = "AES_256_GCM";
+    OpenVPNCipher[OpenVPNCipher["CHACHA20_POLY1305"] = 2] = "CHACHA20_POLY1305";
+    OpenVPNCipher[OpenVPNCipher["AES_128_CBC"] = 3] = "AES_128_CBC";
+    OpenVPNCipher[OpenVPNCipher["AES_256_CBC"] = 4] = "AES_256_CBC";
+    OpenVPNCipher[OpenVPNCipher["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenVPNCipher || (OpenVPNCipher = {}));
+export function openVPNCipherFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "AES_128_GCM":
+            return OpenVPNCipher.AES_128_GCM;
+        case 1:
+        case "AES_256_GCM":
+            return OpenVPNCipher.AES_256_GCM;
+        case 2:
+        case "CHACHA20_POLY1305":
+            return OpenVPNCipher.CHACHA20_POLY1305;
+        case 3:
+        case "AES_128_CBC":
+            return OpenVPNCipher.AES_128_CBC;
+        case 4:
+        case "AES_256_CBC":
+            return OpenVPNCipher.AES_256_CBC;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenVPNCipher.UNRECOGNIZED;
+    }
+}
+export function openVPNCipherToJSON(object) {
+    switch (object) {
+        case OpenVPNCipher.AES_128_GCM:
+            return "AES_128_GCM";
+        case OpenVPNCipher.AES_256_GCM:
+            return "AES_256_GCM";
+        case OpenVPNCipher.CHACHA20_POLY1305:
+            return "CHACHA20_POLY1305";
+        case OpenVPNCipher.AES_128_CBC:
+            return "AES_128_CBC";
+        case OpenVPNCipher.AES_256_CBC:
+            return "AES_256_CBC";
+        case OpenVPNCipher.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var OpenVPNKeyDirection;
+(function (OpenVPNKeyDirection) {
+    OpenVPNKeyDirection[OpenVPNKeyDirection["KEY_DIRECTION_NONE"] = 0] = "KEY_DIRECTION_NONE";
+    OpenVPNKeyDirection[OpenVPNKeyDirection["KEY_DIRECTION_0"] = 1] = "KEY_DIRECTION_0";
+    OpenVPNKeyDirection[OpenVPNKeyDirection["KEY_DIRECTION_1"] = 2] = "KEY_DIRECTION_1";
+    OpenVPNKeyDirection[OpenVPNKeyDirection["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenVPNKeyDirection || (OpenVPNKeyDirection = {}));
+export function openVPNKeyDirectionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "KEY_DIRECTION_NONE":
+            return OpenVPNKeyDirection.KEY_DIRECTION_NONE;
+        case 1:
+        case "KEY_DIRECTION_0":
+            return OpenVPNKeyDirection.KEY_DIRECTION_0;
+        case 2:
+        case "KEY_DIRECTION_1":
+            return OpenVPNKeyDirection.KEY_DIRECTION_1;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenVPNKeyDirection.UNRECOGNIZED;
+    }
+}
+export function openVPNKeyDirectionToJSON(object) {
+    switch (object) {
+        case OpenVPNKeyDirection.KEY_DIRECTION_NONE:
+            return "KEY_DIRECTION_NONE";
+        case OpenVPNKeyDirection.KEY_DIRECTION_0:
+            return "KEY_DIRECTION_0";
+        case OpenVPNKeyDirection.KEY_DIRECTION_1:
+            return "KEY_DIRECTION_1";
+        case OpenVPNKeyDirection.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var OpenVPNEncryption;
+(function (OpenVPNEncryption) {
+    OpenVPNEncryption[OpenVPNEncryption["TLS_NONE"] = 0] = "TLS_NONE";
+    OpenVPNEncryption[OpenVPNEncryption["TLS_AUTH"] = 1] = "TLS_AUTH";
+    OpenVPNEncryption[OpenVPNEncryption["TLS_CRYPT"] = 2] = "TLS_CRYPT";
+    OpenVPNEncryption[OpenVPNEncryption["TLS_CRYPT_V2"] = 3] = "TLS_CRYPT_V2";
+    OpenVPNEncryption[OpenVPNEncryption["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenVPNEncryption || (OpenVPNEncryption = {}));
+export function openVPNEncryptionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "TLS_NONE":
+            return OpenVPNEncryption.TLS_NONE;
+        case 1:
+        case "TLS_AUTH":
+            return OpenVPNEncryption.TLS_AUTH;
+        case 2:
+        case "TLS_CRYPT":
+            return OpenVPNEncryption.TLS_CRYPT;
+        case 3:
+        case "TLS_CRYPT_V2":
+            return OpenVPNEncryption.TLS_CRYPT_V2;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenVPNEncryption.UNRECOGNIZED;
+    }
+}
+export function openVPNEncryptionToJSON(object) {
+    switch (object) {
+        case OpenVPNEncryption.TLS_NONE:
+            return "TLS_NONE";
+        case OpenVPNEncryption.TLS_AUTH:
+            return "TLS_AUTH";
+        case OpenVPNEncryption.TLS_CRYPT:
+            return "TLS_CRYPT";
+        case OpenVPNEncryption.TLS_CRYPT_V2:
+            return "TLS_CRYPT_V2";
+        case OpenVPNEncryption.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseGproxyConfigRequest() {
+    return {
+        application: undefined,
+        type: 0,
+        nameserver: "",
+        login: "",
+        password: "",
+        host: "",
+        port: 0,
+        bypassLocalSubnet: false,
+        dropUdp: false,
+        udpProxy: false,
+        dnsProxy: false,
+    };
+}
+export const GproxyConfigRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.application !== undefined) {
+            ApplicationInfo.encode(message.application, writer.uint32(10).fork()).join();
+        }
+        if (message.type !== 0) {
+            writer.uint32(16).int32(message.type);
+        }
+        if (message.nameserver !== "") {
+            writer.uint32(26).string(message.nameserver);
+        }
+        if (message.login !== "") {
+            writer.uint32(34).string(message.login);
+        }
+        if (message.password !== "") {
+            writer.uint32(42).string(message.password);
+        }
+        if (message.host !== "") {
+            writer.uint32(50).string(message.host);
+        }
+        if (message.port !== 0) {
+            writer.uint32(56).uint32(message.port);
+        }
+        if (message.bypassLocalSubnet !== false) {
+            writer.uint32(64).bool(message.bypassLocalSubnet);
+        }
+        if (message.dropUdp !== false) {
+            writer.uint32(72).bool(message.dropUdp);
+        }
+        if (message.udpProxy !== false) {
+            writer.uint32(80).bool(message.udpProxy);
+        }
+        if (message.dnsProxy !== false) {
+            writer.uint32(88).bool(message.dnsProxy);
+        }
+        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 = createBaseGproxyConfigRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.application = ApplicationInfo.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.type = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.nameserver = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.login = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.password = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.host = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.port = reader.uint32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.bypassLocalSubnet = reader.bool();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.dropUdp = reader.bool();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.udpProxy = reader.bool();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.dnsProxy = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            application: isSet(object.application) ? ApplicationInfo.fromJSON(object.application) : undefined,
+            type: isSet(object.type) ? gproxyTypeFromJSON(object.type) : 0,
+            nameserver: isSet(object.nameserver) ? globalThis.String(object.nameserver) : "",
+            login: isSet(object.login) ? globalThis.String(object.login) : "",
+            password: isSet(object.password) ? globalThis.String(object.password) : "",
+            host: isSet(object.host) ? globalThis.String(object.host) : "",
+            port: isSet(object.port) ? globalThis.Number(object.port) : 0,
+            bypassLocalSubnet: isSet(object.bypassLocalSubnet) ? globalThis.Boolean(object.bypassLocalSubnet) : false,
+            dropUdp: isSet(object.dropUdp) ? globalThis.Boolean(object.dropUdp) : false,
+            udpProxy: isSet(object.udpProxy) ? globalThis.Boolean(object.udpProxy) : false,
+            dnsProxy: isSet(object.dnsProxy) ? globalThis.Boolean(object.dnsProxy) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.application !== undefined) {
+            obj.application = ApplicationInfo.toJSON(message.application);
+        }
+        if (message.type !== 0) {
+            obj.type = gproxyTypeToJSON(message.type);
+        }
+        if (message.nameserver !== "") {
+            obj.nameserver = message.nameserver;
+        }
+        if (message.login !== "") {
+            obj.login = message.login;
+        }
+        if (message.password !== "") {
+            obj.password = message.password;
+        }
+        if (message.host !== "") {
+            obj.host = message.host;
+        }
+        if (message.port !== 0) {
+            obj.port = Math.round(message.port);
+        }
+        if (message.bypassLocalSubnet !== false) {
+            obj.bypassLocalSubnet = message.bypassLocalSubnet;
+        }
+        if (message.dropUdp !== false) {
+            obj.dropUdp = message.dropUdp;
+        }
+        if (message.udpProxy !== false) {
+            obj.udpProxy = message.udpProxy;
+        }
+        if (message.dnsProxy !== false) {
+            obj.dnsProxy = message.dnsProxy;
+        }
+        return obj;
+    },
+    create(base) {
+        return GproxyConfigRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGproxyConfigRequest();
+        message.application = (object.application !== undefined && object.application !== null)
+            ? ApplicationInfo.fromPartial(object.application)
+            : undefined;
+        message.type = object.type ?? 0;
+        message.nameserver = object.nameserver ?? "";
+        message.login = object.login ?? "";
+        message.password = object.password ?? "";
+        message.host = object.host ?? "";
+        message.port = object.port ?? 0;
+        message.bypassLocalSubnet = object.bypassLocalSubnet ?? false;
+        message.dropUdp = object.dropUdp ?? false;
+        message.udpProxy = object.udpProxy ?? false;
+        message.dnsProxy = object.dnsProxy ?? false;
+        return message;
+    },
+};
+function createBaseOpenVPNConfigRequest() {
+    return {
+        allTraffic: false,
+        proto: 0,
+        host: "",
+        port: 0,
+        cipher: 0,
+        ca: "",
+        cert: "",
+        key: "",
+        tlsEncryption: 0,
+        tlsKeyDirection: 0,
+        tlsKey: "",
+        auth: 0,
+        login: "",
+        password: "",
+    };
+}
+export const OpenVPNConfigRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.allTraffic !== false) {
+            writer.uint32(8).bool(message.allTraffic);
+        }
+        if (message.proto !== 0) {
+            writer.uint32(16).int32(message.proto);
+        }
+        if (message.host !== "") {
+            writer.uint32(26).string(message.host);
+        }
+        if (message.port !== 0) {
+            writer.uint32(32).uint32(message.port);
+        }
+        if (message.cipher !== 0) {
+            writer.uint32(40).int32(message.cipher);
+        }
+        if (message.ca !== "") {
+            writer.uint32(50).string(message.ca);
+        }
+        if (message.cert !== "") {
+            writer.uint32(58).string(message.cert);
+        }
+        if (message.key !== "") {
+            writer.uint32(66).string(message.key);
+        }
+        if (message.tlsEncryption !== 0) {
+            writer.uint32(72).int32(message.tlsEncryption);
+        }
+        if (message.tlsKeyDirection !== 0) {
+            writer.uint32(80).int32(message.tlsKeyDirection);
+        }
+        if (message.tlsKey !== "") {
+            writer.uint32(90).string(message.tlsKey);
+        }
+        if (message.auth !== 0) {
+            writer.uint32(96).int32(message.auth);
+        }
+        if (message.login !== "") {
+            writer.uint32(106).string(message.login);
+        }
+        if (message.password !== "") {
+            writer.uint32(114).string(message.password);
+        }
+        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 = createBaseOpenVPNConfigRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.allTraffic = reader.bool();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.proto = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.host = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.port = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.cipher = reader.int32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.ca = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.cert = reader.string();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.tlsEncryption = reader.int32();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.tlsKeyDirection = reader.int32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.tlsKey = reader.string();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.auth = reader.int32();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.login = reader.string();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.password = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            allTraffic: isSet(object.allTraffic) ? globalThis.Boolean(object.allTraffic) : false,
+            proto: isSet(object.proto) ? openVPNProtoFromJSON(object.proto) : 0,
+            host: isSet(object.host) ? globalThis.String(object.host) : "",
+            port: isSet(object.port) ? globalThis.Number(object.port) : 0,
+            cipher: isSet(object.cipher) ? openVPNCipherFromJSON(object.cipher) : 0,
+            ca: isSet(object.ca) ? globalThis.String(object.ca) : "",
+            cert: isSet(object.cert) ? globalThis.String(object.cert) : "",
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            tlsEncryption: isSet(object.tlsEncryption) ? openVPNEncryptionFromJSON(object.tlsEncryption) : 0,
+            tlsKeyDirection: isSet(object.tlsKeyDirection) ? openVPNKeyDirectionFromJSON(object.tlsKeyDirection) : 0,
+            tlsKey: isSet(object.tlsKey) ? globalThis.String(object.tlsKey) : "",
+            auth: isSet(object.auth) ? openVPNAuthFromJSON(object.auth) : 0,
+            login: isSet(object.login) ? globalThis.String(object.login) : "",
+            password: isSet(object.password) ? globalThis.String(object.password) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.allTraffic !== false) {
+            obj.allTraffic = message.allTraffic;
+        }
+        if (message.proto !== 0) {
+            obj.proto = openVPNProtoToJSON(message.proto);
+        }
+        if (message.host !== "") {
+            obj.host = message.host;
+        }
+        if (message.port !== 0) {
+            obj.port = Math.round(message.port);
+        }
+        if (message.cipher !== 0) {
+            obj.cipher = openVPNCipherToJSON(message.cipher);
+        }
+        if (message.ca !== "") {
+            obj.ca = message.ca;
+        }
+        if (message.cert !== "") {
+            obj.cert = message.cert;
+        }
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.tlsEncryption !== 0) {
+            obj.tlsEncryption = openVPNEncryptionToJSON(message.tlsEncryption);
+        }
+        if (message.tlsKeyDirection !== 0) {
+            obj.tlsKeyDirection = openVPNKeyDirectionToJSON(message.tlsKeyDirection);
+        }
+        if (message.tlsKey !== "") {
+            obj.tlsKey = message.tlsKey;
+        }
+        if (message.auth !== 0) {
+            obj.auth = openVPNAuthToJSON(message.auth);
+        }
+        if (message.login !== "") {
+            obj.login = message.login;
+        }
+        if (message.password !== "") {
+            obj.password = message.password;
+        }
+        return obj;
+    },
+    create(base) {
+        return OpenVPNConfigRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOpenVPNConfigRequest();
+        message.allTraffic = object.allTraffic ?? false;
+        message.proto = object.proto ?? 0;
+        message.host = object.host ?? "";
+        message.port = object.port ?? 0;
+        message.cipher = object.cipher ?? 0;
+        message.ca = object.ca ?? "";
+        message.cert = object.cert ?? "";
+        message.key = object.key ?? "";
+        message.tlsEncryption = object.tlsEncryption ?? 0;
+        message.tlsKeyDirection = object.tlsKeyDirection ?? 0;
+        message.tlsKey = object.tlsKey ?? "";
+        message.auth = object.auth ?? 0;
+        message.login = object.login ?? "";
+        message.password = object.password ?? "";
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}