@uipath/admin-tool 1.203.0-preview.203 → 1.204.0-preview.206

package/dist/index-40a6zw4t.js

@@ -0,0 +1,2246 @@
+import {
+  getLoginStatusAsync
+} from "./tool-016jy57n.js";
+import {
+  InvalidArgumentError,
+  Option,
+  OutputFormatter,
+  RESULTS,
+  addSdkUserAgentHeader,
+  catchError,
+  extractErrorDetails,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  instructionsFor,
+  processContext
+} from "./tool-v13kh7v7.js";
+import"./tool-1yh8g550.js";
+
+// ../vpngateway-sdk/generated/src/runtime.ts
+var BASE_PATH = "http://localhost".replace(/\/+$/, "");
+
+class Configuration {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig = new Configuration;
+
+class BaseAPI {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+class RequiredError extends Error {
+  field;
+  name = "RequiredError";
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+}
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+class JSONApiResponse {
+  raw;
+  transformer;
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+}
+
+class VoidApiResponse {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return;
+  }
+}
+// ../vpngateway-sdk/package.json
+var package_default = {
+  name: "@uipath/admin-vpngateway-sdk",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0",
+  description: "SDK for the UiPath Hypervisor VPN Gateway management APIs.",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/admin/vpngateway-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "vpn-gateway",
+    "hypervisor",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  private: true,
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    typecheck: "tsc --noEmit",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    lint: "biome check ."
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@types/node": "^25.5.0",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../vpngateway-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+// ../vpngateway-sdk/generated/src/models/FreezingMetadata.ts
+function FreezingMetadataFromJSON(json) {
+  return FreezingMetadataFromJSONTyped(json, false);
+}
+function FreezingMetadataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    frozen: json["Frozen"] == null ? undefined : json["Frozen"],
+    daysToFreeze: json["DaysToFreeze"] == null ? undefined : json["DaysToFreeze"],
+    freezingValidationMessage: json["FreezingValidationMessage"] == null ? undefined : json["FreezingValidationMessage"]
+  };
+}
+// ../vpngateway-sdk/generated/src/models/GatewayPrivateEndpoint.ts
+function GatewayPrivateEndpointFromJSON(json) {
+  return GatewayPrivateEndpointFromJSONTyped(json, false);
+}
+function GatewayPrivateEndpointFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["Id"],
+    name: json["Name"],
+    targetResourceId: json["TargetResourceId"] == null ? undefined : json["TargetResourceId"],
+    privateEndpointNames: json["PrivateEndpointNames"] == null ? undefined : json["PrivateEndpointNames"],
+    state: json["State"]
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayClientRootCertificate.ts
+function VpnGatewayClientRootCertificateFromJSON(json) {
+  return VpnGatewayClientRootCertificateFromJSONTyped(json, false);
+}
+function VpnGatewayClientRootCertificateFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["Name"],
+    publicCertificateData: json["PublicCertificateData"]
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayClientConfiguration.ts
+function VpnGatewayClientConfigurationFromJSON(json) {
+  return VpnGatewayClientConfigurationFromJSONTyped(json, false);
+}
+function VpnGatewayClientConfigurationFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    rootAddressSpace: json["RootAddressSpace"] == null ? undefined : json["RootAddressSpace"],
+    clientAddressSpaces: json["ClientAddressSpaces"],
+    vpnClientRootCertificates: json["VpnClientRootCertificates"].map(VpnGatewayClientRootCertificateFromJSON)
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayConnectionIPSecPolicy.ts
+function VpnGatewayConnectionIPSecPolicyFromJSON(json) {
+  return VpnGatewayConnectionIPSecPolicyFromJSONTyped(json, false);
+}
+function VpnGatewayConnectionIPSecPolicyFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["Key"] == null ? undefined : json["Key"],
+    saLifeTimeSeconds: json["SaLifeTimeSeconds"],
+    saDataSizeKilobytes: json["SaDataSizeKilobytes"],
+    iPsecEncryption: json["IPsecEncryption"],
+    iPsecIntegrity: json["IPsecIntegrity"],
+    ikeEncryption: json["IkeEncryption"],
+    ikeIntegrity: json["IkeIntegrity"],
+    dhGroup: json["DhGroup"],
+    pfsGroup: json["PfsGroup"]
+  };
+}
+function VpnGatewayConnectionIPSecPolicyToJSON(json) {
+  return VpnGatewayConnectionIPSecPolicyToJSONTyped(json, false);
+}
+function VpnGatewayConnectionIPSecPolicyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Key: value["key"],
+    SaLifeTimeSeconds: value["saLifeTimeSeconds"],
+    SaDataSizeKilobytes: value["saDataSizeKilobytes"],
+    IPsecEncryption: value["iPsecEncryption"],
+    IPsecIntegrity: value["iPsecIntegrity"],
+    IkeEncryption: value["ikeEncryption"],
+    IkeIntegrity: value["ikeIntegrity"],
+    DhGroup: value["dhGroup"],
+    PfsGroup: value["pfsGroup"]
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayConnection.ts
+function VpnGatewayConnectionFromJSON(json) {
+  return VpnGatewayConnectionFromJSONTyped(json, false);
+}
+function VpnGatewayConnectionFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["Key"],
+    name: json["Name"],
+    description: json["Description"] == null ? undefined : json["Description"],
+    targetIpAddress: json["TargetIpAddress"] == null ? undefined : json["TargetIpAddress"],
+    targetAddressSpaces: json["TargetAddressSpaces"] == null ? undefined : json["TargetAddressSpaces"],
+    expressRouteTargetResourceId: json["ExpressRouteTargetResourceId"] == null ? undefined : json["ExpressRouteTargetResourceId"],
+    internal: json["Internal"] == null ? undefined : json["Internal"],
+    state: json["State"],
+    insertedDateTime: json["InsertedDateTime"] == null ? undefined : new Date(json["InsertedDateTime"]),
+    ipSecPolicy: json["IpSecPolicy"] == null ? undefined : VpnGatewayConnectionIPSecPolicyFromJSON(json["IpSecPolicy"]),
+    bgpEnabled: (json["BGPEnabled"] ?? json["BgpEnabled"]) == null ? undefined : json["BGPEnabled"] ?? json["BgpEnabled"],
+    bgpPeerAddress: (json["BGPPeerAddress"] ?? json["BgpPeerAddress"]) == null ? undefined : json["BGPPeerAddress"] ?? json["BgpPeerAddress"],
+    asn: (json["ASN"] ?? json["Asn"]) == null ? undefined : json["ASN"] ?? json["Asn"],
+    primaryCustomBGPAddress: json["PrimaryCustomBGPAddress"] == null ? undefined : json["PrimaryCustomBGPAddress"]
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayNva.ts
+function VpnGatewayNvaFromJSON(json) {
+  return VpnGatewayNvaFromJSONTyped(json, false);
+}
+function VpnGatewayNvaFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["Id"],
+    state: json["State"],
+    nextHopIpAddress: json["NextHopIpAddress"] == null ? undefined : json["NextHopIpAddress"],
+    privateIpAddress: json["PrivateIpAddress"] == null ? undefined : json["PrivateIpAddress"],
+    targetVnetResourceId: json["TargetVnetResourceId"] == null ? undefined : json["TargetVnetResourceId"],
+    hubVnetResourceId: json["HubVnetResourceId"] == null ? undefined : json["HubVnetResourceId"],
+    reverseBgpDummyVnetResourceId: json["ReverseBgpDummyVnetResourceId"] == null ? undefined : json["ReverseBgpDummyVnetResourceId"],
+    routes: json["Routes"] == null ? undefined : json["Routes"],
+    autoPeerHub: json["AutoPeerHub"] == null ? undefined : json["AutoPeerHub"],
+    autoPeerBgp: json["AutoPeerBgp"] == null ? undefined : json["AutoPeerBgp"],
+    hubPeeringState: json["HubPeeringState"] == null ? undefined : json["HubPeeringState"],
+    bgpPeeringState: json["BgpPeeringState"] == null ? undefined : json["BgpPeeringState"],
+    subscriptionKey: json["SubscriptionKey"] == null ? undefined : json["SubscriptionKey"]
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayPeering.ts
+function VpnGatewayPeeringFromJSON(json) {
+  return VpnGatewayPeeringFromJSONTyped(json, false);
+}
+function VpnGatewayPeeringFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["Key"],
+    name: json["Name"] == null ? undefined : json["Name"],
+    targetResourceId: json["TargetResourceId"] == null ? undefined : json["TargetResourceId"],
+    targetAddressSpaces: json["TargetAddressSpaces"] == null ? undefined : json["TargetAddressSpaces"],
+    state: json["State"],
+    insertedDateTime: json["InsertedDateTime"] == null ? undefined : new Date(json["InsertedDateTime"])
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGatewayTrustedCertificate.ts
+function VpnGatewayTrustedCertificateFromJSON(json) {
+  return VpnGatewayTrustedCertificateFromJSONTyped(json, false);
+}
+function VpnGatewayTrustedCertificateFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["Name"],
+    publicCertificateData: json["PublicCertificateData"]
+  };
+}
+function VpnGatewayTrustedCertificateToJSON(json) {
+  return VpnGatewayTrustedCertificateToJSONTyped(json, false);
+}
+function VpnGatewayTrustedCertificateToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Name: value["name"],
+    PublicCertificateData: value["publicCertificateData"]
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/VpnGateway.ts
+function VpnGatewayFromJSON(json) {
+  return VpnGatewayFromJSONTyped(json, false);
+}
+function VpnGatewayFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["Key"],
+    name: json["Name"],
+    description: json["Description"] == null ? undefined : json["Description"],
+    vnetAddressSpace: json["VnetAddressSpace"],
+    vnetGatewaySubnetAddressSpace: json["VnetGatewaySubnetAddressSpace"],
+    publicIp: json["PublicIp"] == null ? undefined : json["PublicIp"],
+    resourceId: json["ResourceId"] == null ? undefined : json["ResourceId"],
+    location: json["Location"] == null ? undefined : json["Location"],
+    state: json["State"],
+    sku: json["Sku"] == null ? undefined : json["Sku"],
+    gatewayType: json["GatewayType"] == null ? undefined : json["GatewayType"],
+    insertedDateTime: json["InsertedDateTime"] == null ? undefined : new Date(json["InsertedDateTime"]),
+    dnsServers: json["DnsServers"] == null ? undefined : json["DnsServers"],
+    internalDnsServer: json["InternalDnsServer"] == null ? undefined : json["InternalDnsServer"],
+    connections: json["Connections"] == null ? undefined : json["Connections"].map(VpnGatewayConnectionFromJSON),
+    privateEndpoints: json["PrivateEndpoints"] == null ? undefined : json["PrivateEndpoints"].map(GatewayPrivateEndpointFromJSON),
+    privateEndpointNames: json["PrivateEndpointNames"] == null ? undefined : json["PrivateEndpointNames"],
+    maxUserConnections: json["MaxUserConnections"] == null ? undefined : json["MaxUserConnections"],
+    peerings: json["Peerings"] == null ? undefined : json["Peerings"].map(VpnGatewayPeeringFromJSON),
+    vpnGatewayClientConfiguration: json["VpnGatewayClientConfiguration"] == null ? undefined : VpnGatewayClientConfigurationFromJSON(json["VpnGatewayClientConfiguration"]),
+    bgpEnabled: (json["BGPEnabled"] ?? json["BgpEnabled"]) == null ? undefined : json["BGPEnabled"] ?? json["BgpEnabled"],
+    asn: (json["ASN"] ?? json["Asn"]) == null ? undefined : json["ASN"] ?? json["Asn"],
+    primaryBGPAddress: json["PrimaryBGPAddress"] == null ? undefined : json["PrimaryBGPAddress"],
+    primaryApipaAddresses: json["PrimaryApipaAddresses"] == null ? undefined : json["PrimaryApipaAddresses"],
+    trustedCertificates: json["TrustedCertificates"] == null ? undefined : json["TrustedCertificates"].map(VpnGatewayTrustedCertificateFromJSON),
+    nva: json["Nva"] == null ? undefined : VpnGatewayNvaFromJSON(json["Nva"]),
+    freezing: json["Freezing"] == null ? undefined : FreezingMetadataFromJSON(json["Freezing"])
+  };
+}
+
+// ../vpngateway-sdk/generated/src/models/ODataValueOfIEnumerableOfVpnGateway.ts
+function ODataValueOfIEnumerableOfVpnGatewayFromJSON(json) {
+  return ODataValueOfIEnumerableOfVpnGatewayFromJSONTyped(json, false);
+}
+function ODataValueOfIEnumerableOfVpnGatewayFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    value: json["value"] == null ? undefined : json["value"].map(VpnGatewayFromJSON)
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayConnectionCreationRequest.ts
+function VpnGatewayConnectionCreationRequestToJSON(json) {
+  return VpnGatewayConnectionCreationRequestToJSONTyped(json, false);
+}
+function VpnGatewayConnectionCreationRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Name: value["name"],
+    TargetIpAddress: value["targetIpAddress"],
+    TargetAddressSpaces: value["targetAddressSpaces"],
+    ExpressRouteTargetResourceId: value["expressRouteTargetResourceId"],
+    SharedKey: value["sharedKey"],
+    Internal: value["internal"],
+    BgpEnabled: value["bgpEnabled"],
+    Asn: value["asn"],
+    BgpPeerAddress: value["bgpPeerAddress"],
+    PrimaryCustomBGPAddress: value["primaryCustomBGPAddress"],
+    IpSecPolicy: VpnGatewayConnectionIPSecPolicyToJSON(value["ipSecPolicy"])
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayConnectionEditRequest.ts
+function VpnGatewayConnectionEditRequestToJSON(json) {
+  return VpnGatewayConnectionEditRequestToJSONTyped(json, false);
+}
+function VpnGatewayConnectionEditRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Name: value["name"],
+    TargetIpAddress: value["targetIpAddress"],
+    TargetAddressSpaces: value["targetAddressSpaces"],
+    SharedKey: value["sharedKey"],
+    BgpEnabled: value["bgpEnabled"],
+    Asn: value["asn"],
+    BgpPeerAddress: value["bgpPeerAddress"],
+    PrimaryCustomBGPAddress: value["primaryCustomBGPAddress"],
+    IpSecPolicy: VpnGatewayConnectionIPSecPolicyToJSON(value["ipSecPolicy"])
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayConnectionsEditConnectionParameters.ts
+function VpnGatewayConnectionsEditConnectionParametersToJSON(json) {
+  return VpnGatewayConnectionsEditConnectionParametersToJSONTyped(json, false);
+}
+function VpnGatewayConnectionsEditConnectionParametersToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    request: VpnGatewayConnectionEditRequestToJSON(value["request"])
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayCreationRequest.ts
+var VpnGatewayCreationRequestSkuEnum = {
+  Basic: "Basic"
+};
+var VpnGatewayCreationRequestTypeEnum = {
+  Vpn: "Vpn",
+  ExpressRoute: "ExpressRoute"
+};
+function VpnGatewayCreationRequestToJSON(json) {
+  return VpnGatewayCreationRequestToJSONTyped(json, false);
+}
+function VpnGatewayCreationRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Name: value["name"],
+    Description: value["description"],
+    VnetAddressSpace: value["vnetAddressSpace"],
+    DnsServers: value["dnsServers"],
+    Sku: value["sku"],
+    Type: value["type"],
+    PrimaryApipaAddresses: value["primaryApipaAddresses"],
+    TrustedCertificates: value["trustedCertificates"] == null ? undefined : value["trustedCertificates"].map(VpnGatewayTrustedCertificateToJSON)
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayEditRequest.ts
+function VpnGatewayEditRequestToJSON(json) {
+  return VpnGatewayEditRequestToJSONTyped(json, false);
+}
+function VpnGatewayEditRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    Name: value["name"],
+    Description: value["description"],
+    DnsServers: value["dnsServers"],
+    PrimaryApipaAddresses: value["primaryApipaAddresses"],
+    Sku: value["sku"],
+    TrustedCertificates: value["trustedCertificates"] == null ? undefined : value["trustedCertificates"].map(VpnGatewayTrustedCertificateToJSON)
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewayTenantConfiguration.ts
+function VpnGatewayTenantConfigurationFromJSON(json) {
+  return VpnGatewayTenantConfigurationFromJSONTyped(json, false);
+}
+function VpnGatewayTenantConfigurationFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    canCreateVpnGateway: json["CanCreateVpnGateway"],
+    validationError: json["ValidationError"] == null ? undefined : json["ValidationError"]
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewaysCreateConnectionParameters.ts
+function VpnGatewaysCreateConnectionParametersToJSON(json) {
+  return VpnGatewaysCreateConnectionParametersToJSONTyped(json, false);
+}
+function VpnGatewaysCreateConnectionParametersToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    request: VpnGatewayConnectionCreationRequestToJSON(value["request"])
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewaysCreateVpnGatewayParameters.ts
+function VpnGatewaysCreateVpnGatewayParametersToJSON(json) {
+  return VpnGatewaysCreateVpnGatewayParametersToJSONTyped(json, false);
+}
+function VpnGatewaysCreateVpnGatewayParametersToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    request: VpnGatewayCreationRequestToJSON(value["request"])
+  };
+}
+// ../vpngateway-sdk/generated/src/models/VpnGatewaysEditVpnGatewayParameters.ts
+function VpnGatewaysEditVpnGatewayParametersToJSON(json) {
+  return VpnGatewaysEditVpnGatewayParametersToJSONTyped(json, false);
+}
+function VpnGatewaysEditVpnGatewayParametersToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    request: VpnGatewayEditRequestToJSON(value["request"])
+  };
+}
+// ../vpngateway-sdk/generated/src/apis/VpnGatewayConnectionsApi.ts
+class VpnGatewayConnectionsApi extends BaseAPI {
+  async vpnGatewayConnectionsDeleteByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewayConnectionsDeleteByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGatewayConnections/{key}`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async vpnGatewayConnectionsDeleteByKey(requestParameters, initOverrides) {
+    await this.vpnGatewayConnectionsDeleteByKeyRaw(requestParameters, initOverrides);
+  }
+  async vpnGatewayConnectionsEditConnectionByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewayConnectionsEditConnectionByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
+    let urlPath = `/odata/VpnGatewayConnections/{key}/EditConnection`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: VpnGatewayConnectionsEditConnectionParametersToJSON(requestParameters["vpnGatewayConnectionsEditConnectionParameters"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayConnectionFromJSON(jsonValue));
+  }
+  async vpnGatewayConnectionsEditConnectionByKey(requestParameters, initOverrides) {
+    const response = await this.vpnGatewayConnectionsEditConnectionByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewayConnectionsGetVpnGatewayConnectionByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewayConnectionsGetVpnGatewayConnectionByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGatewayConnections/{key}`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayConnectionFromJSON(jsonValue));
+  }
+  async vpnGatewayConnectionsGetVpnGatewayConnectionByKey(requestParameters, initOverrides) {
+    const response = await this.vpnGatewayConnectionsGetVpnGatewayConnectionByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewayConnectionsRefreshConnectionByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewayConnectionsRefreshConnectionByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGatewayConnections/{key}/RefreshConnection`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async vpnGatewayConnectionsRefreshConnectionByKey(requestParameters, initOverrides) {
+    await this.vpnGatewayConnectionsRefreshConnectionByKeyRaw(requestParameters, initOverrides);
+  }
+}
+// ../vpngateway-sdk/generated/src/apis/VpnGatewaysApi.ts
+class VpnGatewaysApi extends BaseAPI {
+  async vpnGatewaysCreateConnectionByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewaysCreateConnectionByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
+    let urlPath = `/odata/VpnGateways/{key}/CreateConnection`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: VpnGatewaysCreateConnectionParametersToJSON(requestParameters["vpnGatewaysCreateConnectionParameters"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayConnectionFromJSON(jsonValue));
+  }
+  async vpnGatewaysCreateConnectionByKey(requestParameters, initOverrides) {
+    const response = await this.vpnGatewaysCreateConnectionByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewaysCreateVpnGatewayRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
+    let urlPath = `/odata/VpnGateways/CreateVpnGateway`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: VpnGatewaysCreateVpnGatewayParametersToJSON(requestParameters["vpnGatewaysCreateVpnGatewayParameters"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayFromJSON(jsonValue));
+  }
+  async vpnGatewaysCreateVpnGateway(requestParameters = {}, initOverrides) {
+    const response = await this.vpnGatewaysCreateVpnGatewayRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewaysDeleteByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewaysDeleteByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGateways/{key}`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async vpnGatewaysDeleteByKey(requestParameters, initOverrides) {
+    await this.vpnGatewaysDeleteByKeyRaw(requestParameters, initOverrides);
+  }
+  async vpnGatewaysEditVpnGatewayByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewaysEditVpnGatewayByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
+    let urlPath = `/odata/VpnGateways/{key}/EditVpnGateway`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: VpnGatewaysEditVpnGatewayParametersToJSON(requestParameters["vpnGatewaysEditVpnGatewayParameters"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayFromJSON(jsonValue));
+  }
+  async vpnGatewaysEditVpnGatewayByKey(requestParameters, initOverrides) {
+    const response = await this.vpnGatewaysEditVpnGatewayByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewaysGetVpnGatewayByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewaysGetVpnGatewayByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGateways/{key}`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayFromJSON(jsonValue));
+  }
+  async vpnGatewaysGetVpnGatewayByKey(requestParameters, initOverrides) {
+    const response = await this.vpnGatewaysGetVpnGatewayByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewaysGetVpnGatewaysRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
+    if (requestParameters["$filter"] != null) {
+      queryParameters["$filter"] = requestParameters["$filter"];
+    }
+    if (requestParameters["$orderby"] != null) {
+      queryParameters["$orderby"] = requestParameters["$orderby"];
+    }
+    if (requestParameters["$top"] != null) {
+      queryParameters["$top"] = requestParameters["$top"];
+    }
+    if (requestParameters["$skip"] != null) {
+      queryParameters["$skip"] = requestParameters["$skip"];
+    }
+    if (requestParameters["$count"] != null) {
+      queryParameters["$count"] = requestParameters["$count"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGateways`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ODataValueOfIEnumerableOfVpnGatewayFromJSON(jsonValue));
+  }
+  async vpnGatewaysGetVpnGateways(requestParameters = {}, initOverrides) {
+    const response = await this.vpnGatewaysGetVpnGatewaysRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async vpnGatewaysRedeployByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling vpnGatewaysRedeployByKey().');
+    }
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGateways/{key}/Redeploy`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async vpnGatewaysRedeployByKey(requestParameters, initOverrides) {
+    await this.vpnGatewaysRedeployByKeyRaw(requestParameters, initOverrides);
+  }
+  async vpnGatewaysTenantConfigurationRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["apiVersion"] != null) {
+      queryParameters["api-version"] = requestParameters["apiVersion"];
+    }
+    const headerParameters = {};
+    let urlPath = `/odata/VpnGateways/TenantConfiguration`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => VpnGatewayTenantConfigurationFromJSON(jsonValue));
+  }
+  async vpnGatewaysTenantConfiguration(requestParameters = {}, initOverrides) {
+    const response = await this.vpnGatewaysTenantConfigurationRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+// ../vpngateway-sdk/src/client-factory.ts
+async function resolveConfig(options) {
+  const status = await getLoginStatusAsync();
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  const tenant = options?.tenantName ?? status.tenantName;
+  if (!tenant) {
+    throw new Error("Tenant not available. Pass --tenant <name> or log in with a tenant context.");
+  }
+  const basePath = `${status.baseUrl}/${encodeURIComponent(status.organizationId)}/${encodeURIComponent(tenant)}/hypervisor_`;
+  const bearerToken = options?.s2sToken ?? status.accessToken;
+  return {
+    config: new Configuration({
+      basePath,
+      headers: addSdkUserAgentHeader({
+        Authorization: `Bearer ${bearerToken}`,
+        "x-uipath-source": "UiPath.CLI"
+      }, SDK_USER_AGENT)
+    }),
+    organizationId: status.organizationId,
+    tenantName: tenant
+  };
+}
+async function createApiClient(ApiClass, options) {
+  const { config, organizationId, tenantName } = await resolveConfig(options);
+  return {
+    api: new ApiClass(config),
+    organizationId,
+    tenantName
+  };
+}
+// ../vpngateway-commands/src/helpers/report-error.ts
+var LOCAL_THROW_INSTRUCTIONS = "Review the message above and adjust the command. Run with --help for usage.";
+async function reportError(error, loginInstructions) {
+  const details = await extractErrorDetails(error);
+  const isAuth = details.result === RESULTS.AuthenticationError;
+  const hasHttpStatus = details.context?.httpStatus !== undefined;
+  const instructions = isAuth ? loginInstructions : hasHttpStatus ? instructionsFor("backend", error) : LOCAL_THROW_INSTRUCTIONS;
+  OutputFormatter.error({
+    Result: details.result,
+    ...details.errorCode ? { ErrorCode: details.errorCode } : {},
+    Message: details.message,
+    Instructions: instructions,
+    ...details.retry ? { Retry: details.retry } : {}
+  });
+  processContext.exit(1);
+}
+
+// ../vpngateway-commands/src/helpers/validators.ts
+var IPV4_OCTET = /^(25[0-5]|2[0-4]\d|[01]?\d?\d)$/;
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function asInvalidArgument(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    throw new InvalidArgumentError(errorMessage(err));
+  }
+}
+function assertIpv4(value, label) {
+  const trimmed = value.trim();
+  const parts = trimmed.split(".");
+  if (parts.length !== 4 || !parts.every((p) => IPV4_OCTET.test(p))) {
+    throw new Error(`Invalid ${label}: '${value}'. Expected an IPv4 address like '203.0.113.10'.`);
+  }
+  return trimmed;
+}
+function cidrToIntRange(ip, prefix) {
+  const [a = 0, b = 0, c = 0, d = 0] = ip.split(".").map(Number);
+  const ipInt = ((a * 256 + b) * 256 + c) * 256 + d;
+  const size = 2 ** (32 - prefix);
+  const networkStart = Math.floor(ipInt / size) * size;
+  return { start: networkStart, end: networkStart + size - 1 };
+}
+var APIPA_START = 2851995648;
+var APIPA_END = 2852061183;
+function assertCidr(value, label, options = {}) {
+  const trimmed = value.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash === -1) {
+    throw new Error(`Invalid ${label}: '${value}'. Expected CIDR notation like '10.0.0.0/24'.`);
+  }
+  const ip = trimmed.slice(0, slash);
+  const prefixText = trimmed.slice(slash + 1);
+  const prefix = Number.parseInt(prefixText, 10);
+  assertIpv4(ip, `${label} address`);
+  if (prefixText.length === 0 || !Number.isInteger(prefix) || prefix < 0 || prefix > 32 || String(prefix) !== prefixText) {
+    throw new Error(`Invalid ${label}: '${value}'. Prefix length must be an integer between 0 and 32.`);
+  }
+  if (options.maxPrefix !== undefined && prefix > options.maxPrefix) {
+    throw new Error(`Invalid ${label}: '${value}'. Prefix /${prefix} is too small; maximum allowed is /${options.maxPrefix}.`);
+  }
+  if (options.minPrefix !== undefined && prefix < options.minPrefix) {
+    throw new Error(`Invalid ${label}: '${value}'. Prefix /${prefix} is too wide; minimum allowed is /${options.minPrefix}.`);
+  }
+  if (options.rejectDefaultRoute && ip === "0.0.0.0" && prefix === 0) {
+    throw new Error(`Invalid ${label}: '0.0.0.0/0' (default route) is not allowed.`);
+  }
+  if (options.rejectApipa) {
+    const { start, end } = cidrToIntRange(ip, prefix);
+    if (start <= APIPA_END && APIPA_START <= end) {
+      throw new Error(`Invalid ${label}: '${value}' overlaps the 169.254.0.0/16 APIPA range, which is reserved.`);
+    }
+  }
+  return trimmed;
+}
+var RESERVED_APIPA_ADDRESSES = new Set([
+  "169.254.21.2",
+  "169.254.22.2",
+  "169.254.21.6",
+  "169.254.22.6"
+]);
+function assertApipaBgp(value, label = "APIPA address") {
+  const trimmed = assertIpv4(value, label);
+  const parts = trimmed.split(".");
+  if (parts[0] !== "169" || parts[1] !== "254") {
+    throw new Error(`Invalid ${label}: '${value}'. Must start with 169.254 (APIPA range).`);
+  }
+  if (parts[2] !== "21" && parts[2] !== "22") {
+    throw new Error(`Invalid ${label}: '${value}'. Third octet must be 21 or 22.`);
+  }
+  if (RESERVED_APIPA_ADDRESSES.has(trimmed)) {
+    throw new Error(`${label} '${value}' is reserved.`);
+  }
+  return trimmed;
+}
+var FORBIDDEN_SHARED_KEY_CHARS = /[\s\-~]/;
+function assertSharedKey(value) {
+  if (!value) {
+    throw new Error("Shared key is required.");
+  }
+  if (value.length > 128) {
+    throw new Error(`Shared key is too long (${value.length} chars). Max 128.`);
+  }
+  if (FORBIDDEN_SHARED_KEY_CHARS.test(value)) {
+    throw new Error("Shared key must not contain spaces, dashes, or tildes.");
+  }
+  if (!/^[\x21-\x7e]+$/.test(value)) {
+    throw new Error("Shared key must contain only printable ASCII characters.");
+  }
+  return value;
+}
+var RESERVED_ASNS = new Set([65515, 64512]);
+function assertAsn(value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`Invalid ASN: '${value}'. Must be a positive integer.`);
+  }
+  if (RESERVED_ASNS.has(value)) {
+    throw new Error(`ASN ${value} is reserved.`);
+  }
+  return value;
+}
+function assertBase64X509(data, certName) {
+  if (!data.trim()) {
+    throw new Error(`Trusted certificate '${certName}' has empty PublicCertificateData.`);
+  }
+  let decoded;
+  try {
+    decoded = Buffer.from(data, "base64");
+  } catch {
+    throw new Error(`Trusted certificate '${certName}' has invalid Base64 PublicCertificateData.`);
+  }
+  if (decoded.length === 0) {
+    throw new Error(`Trusted certificate '${certName}' has invalid Base64 PublicCertificateData.`);
+  }
+}
+function assertTrustedCertSpec(value) {
+  if (/^name=/i.test(value) && /,publicCertificateData=/i.test(value)) {
+    throw new Error(`Invalid --trusted-cert '${value}'. Use the simple '<cert-name>=<base64-cert-data>' form (e.g. 'MyRootCA=MIIE7zCC...'); do NOT use 'name=X,publicCertificateData=Y'.`);
+  }
+  const eq = value.indexOf("=");
+  if (eq <= 0 || eq === value.length - 1) {
+    throw new Error(`Invalid --trusted-cert '${value}'. Expected '<cert-name>=<base64-cert-data>' (e.g. 'MyRootCA=MIIE7zCC...').`);
+  }
+  const name = value.slice(0, eq).trim();
+  const publicCertificateData = value.slice(eq + 1).trim();
+  if (!name) {
+    throw new Error(`Invalid --trusted-cert '${value}'. Certificate name must not be empty.`);
+  }
+  assertBase64X509(publicCertificateData, name);
+  return { name, publicCertificateData };
+}
+function assertTrustedCerts(certs, options = {}) {
+  const maxCount = options.maxCount ?? 10;
+  if (certs.length > maxCount) {
+    throw new Error(`Too many trusted certificates: ${certs.length}. Maximum is ${maxCount}.`);
+  }
+  const seenNames = new Set;
+  const seenData = new Set;
+  for (const cert of certs) {
+    const lower = cert.name.toLocaleLowerCase("en-US");
+    if (seenNames.has(lower)) {
+      throw new Error(`Duplicate trusted certificate name: '${cert.name}'.`);
+    }
+    seenNames.add(lower);
+    if (seenData.has(cert.publicCertificateData)) {
+      throw new Error(`Duplicate trusted certificate data for '${cert.name}'.`);
+    }
+    seenData.add(cert.publicCertificateData);
+  }
+}
+function assertIpsecPolicy(policy) {
+  if (policy.saLifeTimeSeconds < 300) {
+    throw new Error(`Invalid --ipsec-sa-lifetime ${policy.saLifeTimeSeconds}: must be at least 300 seconds.`);
+  }
+  const size = policy.saDataSizeKilobytes;
+  if (size !== 0 && (size < 1024 || size > 2147483647)) {
+    throw new Error(`Invalid --ipsec-sa-data-size ${size}: must be 0 or between 1024 and 2147483647.`);
+  }
+  if (policy.iPsecEncryption.toUpperCase().includes("GCMAES") && policy.iPsecEncryption.toLowerCase() !== policy.iPsecIntegrity.toLowerCase()) {
+    throw new Error(`When --ipsec-encryption is a GCMAES variant ('${policy.iPsecEncryption}'), --ipsec-integrity must match it exactly. Backend rejects mismatched GCM pairs.`);
+  }
+}
+function parseIntFlag(value) {
+  const trimmed = value.trim();
+  const n = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(n) || String(n) !== trimmed) {
+    throw new Error(`Expected an integer, got '${value}'.`);
+  }
+  return n;
+}
+function assertMaxCount(items, max, label) {
+  if (items.length > max) {
+    throw new Error(`Too many ${label} entries: ${items.length}. Maximum is ${max}.`);
+  }
+}
+function ipv4Parser(label) {
+  return (value) => asInvalidArgument(() => assertIpv4(value, label));
+}
+function appendIpv4(label) {
+  return (value, previous) => asInvalidArgument(() => [...previous, assertIpv4(value, label)]);
+}
+function cidrParser(label, options = {}) {
+  return (value) => asInvalidArgument(() => assertCidr(value, label, options));
+}
+function appendCidr(label, options = {}) {
+  return (value, previous) => asInvalidArgument(() => [
+    ...previous,
+    assertCidr(value, label, options)
+  ]);
+}
+function appendApipaBgp(label = "APIPA address") {
+  return (value, previous) => asInvalidArgument(() => [...previous, assertApipaBgp(value, label)]);
+}
+function sharedKeyParser(value) {
+  return asInvalidArgument(() => assertSharedKey(value));
+}
+function asnParser(value) {
+  return asInvalidArgument(() => assertAsn(parseIntFlag(value)));
+}
+function intParser(value) {
+  return asInvalidArgument(() => parseIntFlag(value));
+}
+
+// ../vpngateway-commands/src/commands/connections.ts
+var LOGIN_INSTRUCTIONS = "Ensure you are logged in with 'uip login' and that your account has org-admin access to the Hypervisor service. Pass --tenant <name> to target a tenant other than your login context.";
+var DELETE_INSTRUCTIONS = "This is destructive. Pass --confirm to confirm. The Azure connection resource is removed; on-prem peer must reconnect to a recreated connection.";
+var EDIT_INSTRUCTIONS = "Most edits trigger a tunnel renegotiation and a brief connectivity drop. Pass --confirm to confirm.";
+var COMMON_OPTIONS = {
+  tenant: [
+    "--tenant <name>",
+    "Target tenant name. Defaults to the tenant in your login context."
+  ]
+};
+var IPSEC_ENCRYPTION = [
+  "None",
+  "AES128",
+  "AES192",
+  "AES256",
+  "GCMAES128",
+  "GCMAES192",
+  "GCMAES256"
+];
+var IPSEC_INTEGRITY = [
+  "MD5",
+  "SHA1",
+  "SHA256",
+  "SHA384",
+  "GCMAES128",
+  "GCMAES256"
+];
+var IKE_ENCRYPTION = ["AES128", "AES192", "AES256", "GCMAES128", "GCMAES256"];
+var IKE_INTEGRITY = [
+  "MD5",
+  "SHA1",
+  "SHA256",
+  "SHA384",
+  "GCMAES128",
+  "GCMAES256"
+];
+var DH_GROUP = [
+  "None",
+  "DHGroup1",
+  "DHGroup2",
+  "DHGroup14",
+  "DHGroup24",
+  "DHGroup2048",
+  "ECP256",
+  "ECP384"
+];
+var PFS_GROUP = [
+  "None",
+  "PFS1",
+  "PFS2",
+  "PFS14",
+  "PFS24",
+  "PFS2048",
+  "ECP256",
+  "ECP384",
+  "PFS"
+];
+function assembleIpsec(opts) {
+  const {
+    ipsecSaLifetime,
+    ipsecSaDataSize,
+    ipsecEncryption,
+    ipsecIntegrity,
+    ikeEncryption,
+    ikeIntegrity,
+    dhGroup,
+    pfsGroup
+  } = opts;
+  const provided = [
+    ipsecSaLifetime,
+    ipsecSaDataSize,
+    ipsecEncryption,
+    ipsecIntegrity,
+    ikeEncryption,
+    ikeIntegrity,
+    dhGroup,
+    pfsGroup
+  ].filter((f) => f !== undefined).length;
+  if (provided === 0)
+    return;
+  if (ipsecSaLifetime === undefined || ipsecSaDataSize === undefined || ipsecEncryption === undefined || ipsecIntegrity === undefined || ikeEncryption === undefined || ikeIntegrity === undefined || dhGroup === undefined || pfsGroup === undefined) {
+    throw new Error("Partial IPsec policy. When using custom IPsec, pass all of: --ipsec-sa-lifetime, --ipsec-sa-data-size, --ipsec-encryption, --ipsec-integrity, --ike-encryption, --ike-integrity, --dh-group, --pfs-group.");
+  }
+  const policy = {
+    saLifeTimeSeconds: ipsecSaLifetime,
+    saDataSizeKilobytes: ipsecSaDataSize,
+    iPsecEncryption: ipsecEncryption,
+    iPsecIntegrity: ipsecIntegrity,
+    ikeEncryption,
+    ikeIntegrity,
+    dhGroup,
+    pfsGroup
+  };
+  assertIpsecPolicy(policy);
+  return policy;
+}
+function withIpsecFlags(cmd) {
+  return cmd.option("--ipsec-sa-lifetime <seconds>", "IPsec SA lifetime in seconds (min 300).", intParser).option("--ipsec-sa-data-size <kb>", "IPsec SA data-size in kilobytes (0 or 1024–2147483647).", intParser).addOption(new Option("--ipsec-encryption <alg>", "IPsec encryption algorithm. If a GCMAES variant is chosen, --ipsec-integrity must match it.").choices(IPSEC_ENCRYPTION)).addOption(new Option("--ipsec-integrity <alg>", "IPsec integrity algorithm.").choices(IPSEC_INTEGRITY)).addOption(new Option("--ike-encryption <alg>", "IKE encryption algorithm.").choices(IKE_ENCRYPTION)).addOption(new Option("--ike-integrity <alg>", "IKE integrity algorithm.").choices(IKE_INTEGRITY)).addOption(new Option("--dh-group <group>", "DH group.").choices(DH_GROUP)).addOption(new Option("--pfs-group <group>", "PFS group.").choices(PFS_GROUP));
+}
+var GET_EXAMPLES = [
+  {
+    Description: "Fetch a VPN gateway connection by key",
+    Command: "uip admin integrations vpn connections get 00000000-0000-0000-0000-000000000001",
+    Output: {
+      Code: "VpnGatewayConnectionGet",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "site-a",
+        state: "Connected",
+        targetIpAddress: "203.0.113.10",
+        targetAddressSpaces: ["192.168.1.0/24"],
+        bgpEnabled: false
+      }
+    }
+  }
+];
+var EDIT_EXAMPLES = [
+  {
+    Description: "Rename a connection (re-supplying the shared key)",
+    Command: "uip admin integrations vpn connections edit 00000000-0000-0000-0000-000000000001 --shared-key 'MyS3cr3tP4ssphr4se' --name new-name --confirm",
+    Output: {
+      Code: "VpnGatewayConnectionEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "new-name"
+      }
+    }
+  },
+  {
+    Description: "Replace target address spaces",
+    Command: "uip admin integrations vpn connections edit 00000000-0000-0000-0000-000000000001 --shared-key 'MyS3cr3tP4ssphr4se' --target-address-space 192.168.1.0/24 --target-address-space 10.10.0.0/16 --confirm",
+    Output: {
+      Code: "VpnGatewayConnectionEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        targetAddressSpaces: ["192.168.1.0/24", "10.10.0.0/16"]
+      }
+    }
+  },
+  {
+    Description: "Disable BGP on an existing connection",
+    Command: "uip admin integrations vpn connections edit 00000000-0000-0000-0000-000000000001 --shared-key 'MyS3cr3tP4ssphr4se' --no-bgp-enabled --confirm",
+    Output: {
+      Code: "VpnGatewayConnectionEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        bgpEnabled: false
+      }
+    }
+  }
+];
+var REFRESH_EXAMPLES = [
+  {
+    Description: "Refresh the connection's reported state from Azure",
+    Command: "uip admin integrations vpn connections refresh 00000000-0000-0000-0000-000000000001",
+    Output: {
+      Code: "VpnGatewayConnectionRefreshRequested",
+      Data: { Key: "00000000-0000-0000-0000-000000000001" }
+    }
+  }
+];
+var DELETE_EXAMPLES = [
+  {
+    Description: "Delete a connection (--confirm is required)",
+    Command: "uip admin integrations vpn connections delete 00000000-0000-0000-0000-000000000001 --confirm",
+    Output: {
+      Code: "VpnGatewayConnectionDeleted",
+      Data: { Key: "00000000-0000-0000-0000-000000000001" }
+    }
+  }
+];
+var CREATE_EXAMPLES = [
+  {
+    Description: "Site-to-site VPN connection without BGP (static routes)",
+    Command: "uip admin integrations vpn connections create 00000000-0000-0000-0000-0000000000aa --name site-a --shared-key 'MyS3cr3tP4ssphr4se' --target-ip 203.0.113.10 --target-address-space 192.168.1.0/24",
+    Output: {
+      Code: "VpnGatewayConnectionCreated",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "site-a",
+        state: "Connecting",
+        targetIpAddress: "203.0.113.10"
+      }
+    }
+  },
+  {
+    Description: "Site-to-site VPN connection with BGP",
+    Command: "uip admin integrations vpn connections create 00000000-0000-0000-0000-0000000000aa --name site-a --shared-key 'MyS3cr3tP4ssphr4se' --target-ip 203.0.113.10 --bgp-enabled --asn 65001 --bgp-peer-address 169.254.21.1",
+    Output: {
+      Code: "VpnGatewayConnectionCreated",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "site-a",
+        state: "Connecting",
+        targetIpAddress: "203.0.113.10",
+        bgpEnabled: true,
+        asn: 65001
+      }
+    }
+  }
+];
+var registerConnectionsCommand = (vpn) => {
+  const connections = vpn.command("connections").description([
+    "Manage site-to-site connections on a VPN gateway.",
+    "",
+    "Each connection peers one on-prem network with a UiPath VPN gateway.",
+    "Use `connections create 00000000-0000-0000-0000-0000000000aa` to attach a connection to a",
+    "gateway, then manage the connection lifecycle by its own key.",
+    "",
+    "Operations are asynchronous: a `Success` response means the task was",
+    "ENQUEUED, not applied. Poll `connections get <key>` until `state`",
+    "leaves `Connecting`/`Updating` before issuing the next mutation.",
+    "Concurrent mutations on the same gateway return HTTP 409 — wait a",
+    "few seconds and retry."
+  ].join(`
+`));
+  connections.command("get").argument("<key>", "VPN gateway connection key (GUID).").description("Fetch a VPN gateway connection by key.").option(...COMMON_OPTIONS.tenant).examples(GET_EXAMPLES).trackedAction(processContext, async (key, options) => {
+    const [error, result] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewayConnectionsApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewayConnectionsGetVpnGatewayConnectionByKey({ key });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayConnectionGet",
+      Data: result
+    });
+  });
+  const createCmd = connections.command("create").argument("<gateway-key>", "Parent VPN gateway key (GUID).").description([
+    "Attach a new site-to-site connection to a VPN gateway.",
+    "",
+    "Required: --name, --shared-key, --target-ip.",
+    "Without BGP: --target-address-space is required (one or more on-prem",
+    "CIDRs). The default route 0.0.0.0/0 is rejected.",
+    "With BGP: pass --bgp-enabled --asn <n> --bgp-peer-address <ip>.",
+    "",
+    "BGP pairing: --bgp-peer-address is the on-prem device's BGP",
+    "endpoint. It must be the /30 partner of an address in the gateway's",
+    "--apipa-address pool. Convention: gateway gets the higher usable",
+    "(e.g. .X+2 of the /30), on-prem peer gets the lower (.X+1). Example:",
+    "gateway has 169.254.21.10 → on-prem peer is 169.254.21.9 (both in",
+    "the 169.254.21.8/30 block).",
+    "",
+    "Custom IPsec policy is optional. If you set any --ipsec-*, --ike-*,",
+    "--dh-group, or --pfs-group flag, you must set ALL eight. When",
+    "--ipsec-encryption is a GCMAES variant, --ipsec-integrity must equal it."
+  ].join(`
+`)).requiredOption("--name <name>", "Connection name.").requiredOption("--shared-key <key>", "Pre-shared key. Max 128 ASCII chars; no spaces, dashes, or tildes.", sharedKeyParser).requiredOption("--target-ip <ip>", "On-prem VPN device public IPv4.", ipv4Parser("target IP")).option("--target-address-space <cidr>", "On-prem network CIDR (repeatable). Required without --bgp-enabled. 0.0.0.0/0 is not allowed.", appendCidr("target address space", { rejectDefaultRoute: true }), []).option("--bgp-enabled", "Use BGP for dynamic routing.").option("--asn <num>", "BGP ASN for the on-prem peer (positive integer; 65515 and 64512 are reserved).", asnParser).option("--bgp-peer-address <ip>", "BGP peer IPv4 address on the on-prem device.", ipv4Parser("BGP peer address")).option(...COMMON_OPTIONS.tenant);
+  withIpsecFlags(createCmd).examples(CREATE_EXAMPLES).trackedAction(processContext, async (gatewayKey, options) => {
+    const [error, result] = await catchError((async () => {
+      const ipSecPolicy = assembleIpsec(options);
+      if (options.bgpEnabled) {
+        if (options.asn === undefined) {
+          throw new Error("--asn is required when --bgp-enabled is set.");
+        }
+        if (options.bgpPeerAddress === undefined) {
+          throw new Error("--bgp-peer-address is required when --bgp-enabled is set.");
+        }
+      } else if (options.targetAddressSpace.length === 0) {
+        throw new Error("--target-address-space is required (at least once) when --bgp-enabled is not set.");
+      }
+      const request = {
+        name: options.name,
+        sharedKey: options.sharedKey,
+        targetIpAddress: options.targetIp
+      };
+      if (options.targetAddressSpace.length > 0)
+        request.targetAddressSpaces = options.targetAddressSpace;
+      if (options.bgpEnabled !== undefined)
+        request.bgpEnabled = options.bgpEnabled;
+      if (options.asn !== undefined)
+        request.asn = options.asn;
+      if (options.bgpPeerAddress !== undefined)
+        request.bgpPeerAddress = options.bgpPeerAddress;
+      if (ipSecPolicy)
+        request.ipSecPolicy = ipSecPolicy;
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysCreateConnectionByKey({
+        key: gatewayKey,
+        vpnGatewaysCreateConnectionParameters: { request }
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayConnectionCreated",
+      Data: result
+    });
+  });
+  const editCmd = connections.command("edit").argument("<key>", "VPN gateway connection key (GUID).").description([
+    "Update a VPN gateway connection's mutable fields.",
+    "",
+    "--shared-key and --confirm are REQUIRED on every edit. Re-supply the",
+    "current PSK; pass --confirm to acknowledge that most edits cause a brief",
+    "tunnel renegotiation and connectivity drop.",
+    "",
+    "Scalar fields you don't pass are preserved. List flags",
+    "(--target-address-space) REPLACE the existing list wholesale —",
+    "to keep an entry you must re-pass it. Use",
+    "--clear-target-address-spaces to empty the list explicitly.",
+    "",
+    "IPsec policy: preserved by default. Pass any",
+    "--ipsec-*/-ike-*/-dh-group/-pfs-group flag to REPLACE it (all eight",
+    "required). Pass --clear-ipsec to remove it entirely.",
+    "",
+    "BGP: preserved by default. Pass --bgp-enabled or --no-bgp-enabled to",
+    "change it; the CLI re-sends ASN and peer address from the current",
+    "connection if you don't override them.",
+    "",
+    "Transitioning from non-BGP to BGP (--bgp-enabled on a connection",
+    "that wasn't BGP-enabled before) requires you to ALSO pass --asn AND",
+    "--bgp-peer-address. The CLI rejects the edit upfront in that case."
+  ].join(`
+`)).requiredOption("--shared-key <key>", "Pre-shared key (required on every edit). Max 128 ASCII chars; no spaces, dashes, or tildes.", sharedKeyParser).option("--name <name>", "Rename the connection.").option("--target-ip <ip>", "On-prem VPN device public IPv4.", ipv4Parser("target IP")).option("--target-address-space <cidr>", "Replace the on-prem CIDR list (repeatable). 0.0.0.0/0 is not allowed.", appendCidr("target address space", { rejectDefaultRoute: true }), []).option("--clear-target-address-spaces", "Remove all target address spaces. Mutually exclusive with --target-address-space. Use with caution: a non-BGP connection without target address spaces is misconfigured.").option("--bgp-enabled", "Enable BGP.").option("--no-bgp-enabled", "Disable BGP.").option("--asn <num>", "BGP ASN.", asnParser).option("--bgp-peer-address <ip>", "BGP peer IPv4.", ipv4Parser("BGP peer address")).option("--clear-ipsec", "Remove the existing IPsec policy. Mutually exclusive with --ipsec-*/-ike-*/-dh-group/-pfs-group flags.").option("--confirm", "Confirm the edit. Required (most edits cause a brief connectivity drop).").option(...COMMON_OPTIONS.tenant);
+  withIpsecFlags(editCmd).examples(EDIT_EXAMPLES).trackedAction(processContext, async (key, options) => {
+    if (!options.confirm) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Refusing to edit connection ${key} without --confirm.`,
+        Instructions: EDIT_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [error, result] = await catchError((async () => {
+      const newIpsec = assembleIpsec(options);
+      if (options.clearIpsec && newIpsec) {
+        throw new Error("--clear-ipsec is mutually exclusive with --ipsec-*/-ike-*/-dh-group/-pfs-group flags. Pick one.");
+      }
+      if (options.clearTargetAddressSpaces && options.targetAddressSpace.length > 0) {
+        throw new Error("--clear-target-address-spaces is mutually exclusive with --target-address-space.");
+      }
+      const request = {
+        sharedKey: options.sharedKey
+      };
+      if (options.name !== undefined)
+        request.name = options.name;
+      if (options.targetIp !== undefined)
+        request.targetIpAddress = options.targetIp;
+      const { api } = await createApiClient(VpnGatewayConnectionsApi, {
+        tenantName: options.tenant
+      });
+      const userPassedBgpFlag = options.bgpEnabled !== undefined;
+      const userPassedAsn = options.asn !== undefined;
+      const userPassedBgpPeerAddress = options.bgpPeerAddress !== undefined;
+      const userPassedAddressSpaces = options.targetAddressSpace.length > 0 || options.clearTargetAddressSpaces;
+      const userExplicitlyNonBgp = userPassedBgpFlag && options.bgpEnabled === false;
+      const needsCurrentForIpsec = !newIpsec && !options.clearIpsec;
+      const needsCurrentForBgp = !userExplicitlyNonBgp && (!userPassedBgpFlag || !userPassedAsn || !userPassedBgpPeerAddress);
+      const needsCurrentForAddressSpaces = !userPassedAddressSpaces;
+      const current = needsCurrentForIpsec || needsCurrentForBgp || needsCurrentForAddressSpaces ? await api.vpnGatewayConnectionsGetVpnGatewayConnectionByKey({ key }) : undefined;
+      if (newIpsec) {
+        request.ipSecPolicy = newIpsec;
+      } else if (!options.clearIpsec && current?.ipSecPolicy) {
+        const { key: _existingKey, ...policy } = current.ipSecPolicy;
+        request.ipSecPolicy = policy;
+      }
+      const finalBgpEnabled = userPassedBgpFlag ? options.bgpEnabled : current?.bgpEnabled ?? false;
+      if (finalBgpEnabled && current?.bgpEnabled === false && (!userPassedAsn || !userPassedBgpPeerAddress)) {
+        throw new Error("Enabling BGP on a non-BGP connection requires both --asn and --bgp-peer-address.");
+      }
+      request.bgpEnabled = finalBgpEnabled;
+      if (finalBgpEnabled) {
+        request.asn = userPassedAsn ? options.asn : current?.asn;
+        request.bgpPeerAddress = userPassedBgpPeerAddress ? options.bgpPeerAddress : current?.bgpPeerAddress;
+      } else {
+        if (userPassedAsn)
+          request.asn = options.asn;
+        if (userPassedBgpPeerAddress)
+          request.bgpPeerAddress = options.bgpPeerAddress;
+      }
+      if (options.clearTargetAddressSpaces) {
+        request.targetAddressSpaces = [];
+      } else if (options.targetAddressSpace.length > 0) {
+        request.targetAddressSpaces = options.targetAddressSpace;
+      } else if (current?.targetAddressSpaces) {
+        request.targetAddressSpaces = current.targetAddressSpaces;
+      }
+      return await api.vpnGatewayConnectionsEditConnectionByKey({
+        key,
+        vpnGatewayConnectionsEditConnectionParameters: {
+          request
+        }
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayConnectionEdited",
+      Data: result
+    });
+  });
+  connections.command("refresh").argument("<key>", "VPN gateway connection key (GUID).").description([
+    "Queue a background refresh of the connection's state.",
+    "",
+    "Connection states are also refreshed automatically by a periodic",
+    "background job. Use this command only when you don't want to wait",
+    "for the next cycle.",
+    "",
+    "The CLI returns immediately once the task is queued. Call",
+    "`connections get <key>` afterwards to read the updated state.",
+    "Rejected if the connection has another operation in flight."
+  ].join(`
+`)).option(...COMMON_OPTIONS.tenant).examples(REFRESH_EXAMPLES).trackedAction(processContext, async (key, options) => {
+    const [error] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewayConnectionsApi, {
+        tenantName: options.tenant
+      });
+      await api.vpnGatewayConnectionsRefreshConnectionByKey({
+        key
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayConnectionRefreshRequested",
+      Data: { Key: key }
+    });
+  });
+  connections.command("delete").argument("<key>", "VPN gateway connection key (GUID).").description([
+    "Deletes the connection.",
+    "",
+    "This is destructive and cannot be undone.",
+    "",
+    "Pass --confirm to confirm. Without it the command exits with an error so",
+    "non-interactive callers can't accidentally trigger deletion."
+  ].join(`
+`)).option("--confirm", "Confirm deletion. Required (the command refuses without it).").option(...COMMON_OPTIONS.tenant).examples(DELETE_EXAMPLES).trackedAction(processContext, async (key, options) => {
+    if (!options.confirm) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Refusing to delete connection ${key} without --confirm.`,
+        Instructions: DELETE_INSTRUCTIONS
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [error] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewayConnectionsApi, {
+        tenantName: options.tenant
+      });
+      await api.vpnGatewayConnectionsDeleteByKey({ key });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayConnectionDeleted",
+      Data: { Key: key }
+    });
+  });
+};
+
+// ../vpngateway-commands/src/commands/gateways.ts
+function appendTrustedCert(value, previous) {
+  try {
+    return [...previous, assertTrustedCertSpec(value)];
+  } catch (err) {
+    throw new InvalidArgumentError(errorMessage(err));
+  }
+}
+var LOGIN_INSTRUCTIONS2 = "Ensure you are logged in with 'uip login' and that your account has org-admin access to the Hypervisor service. Pass --tenant <name> to target a tenant other than your login context.";
+var DELETE_INSTRUCTIONS2 = "This is destructive. Pass --confirm to confirm. Once deleted, all connections, peerings, and certificates on the gateway are gone.";
+var VPN_VNET_MAX_PREFIX = 27;
+var VPN_VNET_MIN_PREFIX = 8;
+var DNS_SERVERS_LIMIT = 3;
+var APIPA_ADDRESSES_LIMIT = 2;
+var TRUSTED_CERTIFICATES_LIMIT = 10;
+var COMMON_OPTIONS2 = {
+  tenant: [
+    "--tenant <name>",
+    "Target tenant name. Defaults to the tenant in your login context."
+  ]
+};
+var LIST_EXAMPLES = [
+  {
+    Description: "List all VPN gateways for the current tenant",
+    Command: "uip admin integrations vpn gateways list",
+    Output: {
+      Code: "VpnGatewayList",
+      Data: {
+        count: 1,
+        value: [
+          {
+            key: "00000000-0000-0000-0000-000000000001",
+            name: "prod-gw",
+            state: "Deployed",
+            gatewayType: "Vpn",
+            sku: "Basic",
+            vnetAddressSpace: "10.0.0.0/24",
+            location: "westus",
+            publicIp: "20.0.0.1",
+            connections: []
+          }
+        ]
+      }
+    }
+  }
+];
+var GET_EXAMPLES2 = [
+  {
+    Description: "Fetch a gateway and its connections by key",
+    Command: "uip admin integrations vpn gateways get 00000000-0000-0000-0000-000000000001",
+    Output: {
+      Code: "VpnGatewayGet",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "prod-gw",
+        state: "Deployed",
+        gatewayType: "Vpn",
+        sku: "Basic",
+        vnetAddressSpace: "10.0.0.0/24",
+        location: "westus",
+        publicIp: "20.0.0.1",
+        connections: [
+          {
+            key: "11111111-1111-1111-1111-111111111111",
+            name: "site-a",
+            state: "Connected",
+            targetIpAddress: "203.0.113.10"
+          }
+        ],
+        trustedCertificates: [
+          {
+            name: "corp-root-ca",
+            publicCertificateData: "MIIDazCCAlOgAwIBAgIUHs9..."
+          }
+        ]
+      }
+    }
+  }
+];
+var TENANT_CONFIG_EXAMPLES = [
+  {
+    Description: "Check whether the tenant is allowed to provision a VPN gateway",
+    Command: "uip admin integrations vpn gateways tenant-config",
+    Output: {
+      Code: "VpnGatewayTenantConfig",
+      Data: { canCreateVpnGateway: true }
+    }
+  }
+];
+var EDIT_EXAMPLES2 = [
+  {
+    Description: "Rename a gateway",
+    Command: "uip admin integrations vpn gateways edit 00000000-0000-0000-0000-000000000001 --name new-name",
+    Output: {
+      Code: "VpnGatewayEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "new-name"
+      }
+    }
+  },
+  {
+    Description: "Replace the DNS server list with two entries",
+    Command: "uip admin integrations vpn gateways edit 00000000-0000-0000-0000-000000000001 --dns-server 1.1.1.1 --dns-server 8.8.8.8",
+    Output: {
+      Code: "VpnGatewayEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        dnsServers: ["1.1.1.1", "8.8.8.8"]
+      }
+    }
+  },
+  {
+    Description: "Remove all DNS servers from a gateway",
+    Command: "uip admin integrations vpn gateways edit 00000000-0000-0000-0000-000000000001 --clear-dns-servers",
+    Output: {
+      Code: "VpnGatewayEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        dnsServers: []
+      }
+    }
+  },
+  {
+    Description: "Push trusted certificates from on-disk Base64 files (multi-line cert content via shell substitution)",
+    Command: 'ROOT=$(cat root.b64); INTER=$(cat inter.b64); uip admin integrations vpn gateways edit 00000000-0000-0000-0000-000000000001 --trusted-cert "Root=$ROOT" --trusted-cert "Inter=$INTER"',
+    Output: {
+      Code: "VpnGatewayEdited",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        trustedCertificates: [
+          {
+            name: "Root",
+            publicCertificateData: "MIIE7zCC..."
+          },
+          {
+            name: "Inter",
+            publicCertificateData: "MIIFLDCC..."
+          }
+        ]
+      }
+    }
+  }
+];
+var REDEPLOY_EXAMPLES = [
+  {
+    Description: "Retry deployment of a gateway in the Failed state",
+    Command: "uip admin integrations vpn gateways redeploy 00000000-0000-0000-0000-000000000001",
+    Output: {
+      Code: "VpnGatewayRedeployRequested",
+      Data: { Key: "00000000-0000-0000-0000-000000000001" }
+    }
+  }
+];
+var DELETE_EXAMPLES2 = [
+  {
+    Description: "Delete a gateway (--confirm is required)",
+    Command: "uip admin integrations vpn gateways delete 00000000-0000-0000-0000-000000000001 --confirm",
+    Output: {
+      Code: "VpnGatewayDeleted",
+      Data: { Key: "00000000-0000-0000-0000-000000000001" }
+    }
+  }
+];
+var CREATE_EXAMPLES2 = [
+  {
+    Description: "Provision a basic VPN gateway in a /24 VNet",
+    Command: "uip admin integrations vpn gateways create --name prod-gw --vnet-address-space 10.0.0.0/24",
+    Output: {
+      Code: "VpnGatewayCreated",
+      Data: {
+        key: "00000000-0000-0000-0000-000000000001",
+        name: "prod-gw",
+        state: "Provisioning",
+        gatewayType: "Vpn",
+        sku: "Basic",
+        vnetAddressSpace: "10.0.0.0/24"
+      }
+    }
+  },
+  {
+    Description: "Full lifecycle: provision a BGP-ready gateway with DNS, APIPA, and trusted certs, then poll for readiness before attaching connections",
+    Command: [
+      "ROOT=$(cat root.b64); INTER=$(cat inter.b64)",
+      "GW_KEY=$(uip admin integrations vpn gateways create \\",
+      "  --name prod-gw \\",
+      "  --vnet-address-space 10.0.0.0/24 \\",
+      "  --dns-server 172.23.0.105 --dns-server 172.23.2.89 \\",
+      "  --apipa-address 169.254.21.10 \\",
+      '  --trusted-cert "Root=$ROOT" --trusted-cert "Inter=$INTER" \\',
+      "  --output-filter Data.key --output plain)",
+      "# Poll until state becomes Deployed before creating connections:",
+      "until uip admin integrations vpn gateways get $GW_KEY \\",
+      "  --output-filter Data.state --output plain | grep -q Deployed; do",
+      "  sleep 30",
+      "done",
+      "uip admin integrations vpn connections create $GW_KEY \\",
+      '  --name site-a --shared-key "MyS3cr3tP4ssphr4se" \\',
+      "  --target-ip 203.0.113.10 \\",
+      "  --bgp-enabled --asn 65001 --bgp-peer-address 169.254.21.9"
+    ].join(`
+`),
+    Output: {
+      Code: "VpnGatewayConnectionCreated",
+      Data: {
+        key: "11111111-1111-1111-1111-111111111111",
+        name: "site-a",
+        state: "Connecting"
+      }
+    }
+  }
+];
+var registerGatewaysCommand = (vpn) => {
+  const gateways = vpn.command("gateways").description([
+    "Manage VPN gateways for the current tenant.",
+    "",
+    "A VPN gateway lets cloud and serverless robots reach on-prem",
+    "networks privately over a site-to-site IPsec tunnel. The gateway",
+    "is hosted in a network whose address space you provide at",
+    "create time.",
+    "",
+    "Operations are asynchronous: a `Success` response means the task",
+    "was ENQUEUED, not applied. Poll `gateways get <key>` until `state`",
+    "is `Deployed` before issuing the next mutation (or before",
+    "creating connections). Concurrent mutations on the same gateway",
+    "return HTTP 409 — wait a few seconds and retry."
+  ].join(`
+`));
+  gateways.command("list").description([
+    "List all VPN gateways for the current tenant.",
+    "",
+    "Returns a summary of each gateway (key, name, state, type, SKU, VNet,",
+    "location, public IP, connection count). Use `gateways get <key>` for the",
+    "full record including connections, peerings, and trusted certificates."
+  ].join(`
+`)).option(...COMMON_OPTIONS2.tenant).examples(LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysGetVpnGateways({
+        $expand: "Connections"
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    const gws = result.value ?? [];
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayList",
+      Data: { count: gws.length, value: gws }
+    });
+  });
+  gateways.command("get").argument("<key>", "VPN gateway key (GUID).").description("Fetch a VPN gateway by key, with its connections.").option(...COMMON_OPTIONS2.tenant).examples(GET_EXAMPLES2).trackedAction(processContext, async (key, options) => {
+    const [error, result] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysGetVpnGatewayByKey({
+        key,
+        $expand: "Connections"
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayGet",
+      Data: result
+    });
+  });
+  gateways.command("tenant-config").description([
+    "Check whether the current tenant is allowed to provision a VPN gateway.",
+    "",
+    "Returns `canCreateVpnGateway` and an optional `validationError` reason."
+  ].join(`
+`)).option(...COMMON_OPTIONS2.tenant).examples(TENANT_CONFIG_EXAMPLES).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysTenantConfiguration({});
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayTenantConfig",
+      Data: result
+    });
+  });
+  gateways.command("create").description([
+    "Provision a new VPN gateway hosted in a network using the",
+    "provided address space.",
+    "",
+    "The gateway is created asynchronously. Call `gateways get <key>` or",
+    "`gateways list` to track state (Provisioning, then Deployed or Failed).",
+    "On Failed, use `gateways redeploy <key>` to retry.",
+    "",
+    `--vnet-address-space must be a CIDR with prefix between /${VPN_VNET_MIN_PREFIX}`,
+    `and /${VPN_VNET_MAX_PREFIX} (e.g. /16, /24, /27). The 169.254.0.0/16 APIPA`,
+    "range is rejected because it collides with BGP APIPA addresses",
+    "(169.254.21.0/24 and 169.254.22.0/24) used internally for peering."
+  ].join(`
+`)).requiredOption("--name <name>", "Gateway name.").requiredOption("--vnet-address-space <cidr>", `VNet CIDR (prefix between /${VPN_VNET_MIN_PREFIX} and /${VPN_VNET_MAX_PREFIX}). Immutable after create.`, cidrParser("VNet address space", {
+    minPrefix: VPN_VNET_MIN_PREFIX,
+    maxPrefix: VPN_VNET_MAX_PREFIX,
+    rejectDefaultRoute: true,
+    rejectApipa: true
+  })).option("--description <text>", "Free-form description.").option("--dns-server <ip>", `DNS server IP (repeatable, max ${DNS_SERVERS_LIMIT}).`, appendIpv4("DNS server"), []).option("--apipa-address <ip>", `APIPA BGP peering address (repeatable, max ${APIPA_ADDRESSES_LIMIT}). Must be in 169.254.21.0/24 or 169.254.22.0/24.`, appendApipaBgp("APIPA address"), []).option("--trusted-cert <cert-name=base64>", `Trusted root certificate (repeatable, max ${TRUSTED_CERTIFICATES_LIMIT}). Format: '<cert-name>=<base64-X509>', e.g. 'MyRootCA=MIIE7zCC...'.`, appendTrustedCert, []).option(...COMMON_OPTIONS2.tenant).examples(CREATE_EXAMPLES2).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => {
+      assertMaxCount(options.dnsServer, DNS_SERVERS_LIMIT, "DNS server");
+      assertMaxCount(options.apipaAddress, APIPA_ADDRESSES_LIMIT, "APIPA address");
+      assertTrustedCerts(options.trustedCert, {
+        maxCount: TRUSTED_CERTIFICATES_LIMIT
+      });
+      const request = {
+        name: options.name,
+        vnetAddressSpace: options.vnetAddressSpace,
+        type: VpnGatewayCreationRequestTypeEnum.Vpn,
+        sku: VpnGatewayCreationRequestSkuEnum.Basic
+      };
+      if (options.description !== undefined)
+        request.description = options.description;
+      if (options.dnsServer.length > 0)
+        request.dnsServers = options.dnsServer;
+      if (options.apipaAddress.length > 0)
+        request.primaryApipaAddresses = options.apipaAddress;
+      if (options.trustedCert.length > 0)
+        request.trustedCertificates = options.trustedCert;
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysCreateVpnGateway({
+        vpnGatewaysCreateVpnGatewayParameters: { request }
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayCreated",
+      Data: result
+    });
+  });
+  gateways.command("edit").argument("<key>", "VPN gateway key (GUID).").description([
+    "Update a VPN gateway's mutable fields.",
+    "",
+    "Scalar fields (--name, --description) you don't pass are preserved.",
+    "Lists you DO pass replace the existing list wholesale. Pass each member",
+    "you want to keep when using --dns-server, --apipa-address, or",
+    "--trusted-cert. Pass --clear-dns-servers / --clear-apipa-addresses /",
+    "--clear-trusted-certs to remove all entries (mutually exclusive with the",
+    "matching populated flag)."
+  ].join(`
+`)).option("--name <name>", "Rename the gateway.").option("--description <text>", "Update description.").option("--dns-server <ip>", `Replace the DNS server list (repeatable, max ${DNS_SERVERS_LIMIT}).`, appendIpv4("DNS server"), []).option("--clear-dns-servers", "Remove all DNS servers. Mutually exclusive with --dns-server.").option("--apipa-address <ip>", `Replace the APIPA address list (repeatable, max ${APIPA_ADDRESSES_LIMIT}). Must be in 169.254.21.0/24 or 169.254.22.0/24.`, appendApipaBgp("APIPA address"), []).option("--clear-apipa-addresses", "Remove all APIPA BGP addresses. Mutually exclusive with --apipa-address.").option("--trusted-cert <cert-name=base64>", `Replace the trusted certificate list (repeatable, max ${TRUSTED_CERTIFICATES_LIMIT}). Format: '<cert-name>=<base64-X509>', e.g. 'MyRootCA=MIIE7zCC...'.`, appendTrustedCert, []).option("--clear-trusted-certs", "Remove all trusted certificates. Mutually exclusive with --trusted-cert.").option(...COMMON_OPTIONS2.tenant).examples(EDIT_EXAMPLES2).trackedAction(processContext, async (key, options) => {
+    const [error, result] = await catchError((async () => {
+      if (options.clearDnsServers && options.dnsServer.length > 0)
+        throw new Error("--clear-dns-servers is mutually exclusive with --dns-server.");
+      if (options.clearApipaAddresses && options.apipaAddress.length > 0)
+        throw new Error("--clear-apipa-addresses is mutually exclusive with --apipa-address.");
+      if (options.clearTrustedCerts && options.trustedCert.length > 0)
+        throw new Error("--clear-trusted-certs is mutually exclusive with --trusted-cert.");
+      assertMaxCount(options.dnsServer, DNS_SERVERS_LIMIT, "DNS server");
+      assertMaxCount(options.apipaAddress, APIPA_ADDRESSES_LIMIT, "APIPA address");
+      assertTrustedCerts(options.trustedCert, {
+        maxCount: TRUSTED_CERTIFICATES_LIMIT
+      });
+      const request = {};
+      if (options.name !== undefined)
+        request.name = options.name;
+      if (options.description !== undefined)
+        request.description = options.description;
+      if (options.clearDnsServers)
+        request.dnsServers = [];
+      else if (options.dnsServer.length > 0)
+        request.dnsServers = options.dnsServer;
+      if (options.clearApipaAddresses)
+        request.primaryApipaAddresses = [];
+      else if (options.apipaAddress.length > 0)
+        request.primaryApipaAddresses = options.apipaAddress;
+      if (options.clearTrustedCerts)
+        request.trustedCertificates = [];
+      else if (options.trustedCert.length > 0)
+        request.trustedCertificates = options.trustedCert;
+      if (Object.keys(request).length === 0) {
+        throw new Error("No edit fields provided. Pass at least one of --name, --description, --dns-server, --apipa-address, --trusted-cert, or a --clear-* flag.");
+      }
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      return await api.vpnGatewaysEditVpnGatewayByKey({
+        key,
+        vpnGatewaysEditVpnGatewayParameters: { request }
+      });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayEdited",
+      Data: result
+    });
+  });
+  gateways.command("redeploy").argument("<key>", "VPN gateway key (GUID).").description([
+    "Retry the last background task on a gateway whose previous deployment",
+    "attempt didn't complete cleanly (e.g., a Provision/Edit task faulted",
+    "or timed out).",
+    "",
+    "Rejected if the gateway is frozen, has an active task in flight, or is",
+    "in an unsupported state."
+  ].join(`
+`)).option(...COMMON_OPTIONS2.tenant).examples(REDEPLOY_EXAMPLES).trackedAction(processContext, async (key, options) => {
+    const [error] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      await api.vpnGatewaysRedeployByKey({ key });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayRedeployRequested",
+      Data: { Key: key }
+    });
+  });
+  gateways.command("delete").argument("<key>", "VPN gateway key (GUID).").description([
+    "Deletes the gateway and all related infrastructure.",
+    "",
+    "This is destructive and cannot be undone.",
+    "",
+    "Pass --confirm to confirm. Without it the command exits with an error so",
+    "non-interactive callers can't accidentally trigger deletion."
+  ].join(`
+`)).option("--confirm", "Confirm deletion. Required (the command refuses without it).").option(...COMMON_OPTIONS2.tenant).examples(DELETE_EXAMPLES2).trackedAction(processContext, async (key, options) => {
+    if (!options.confirm) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Refusing to delete gateway ${key} without --confirm.`,
+        Instructions: DELETE_INSTRUCTIONS2
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [error] = await catchError((async () => {
+      const { api } = await createApiClient(VpnGatewaysApi, {
+        tenantName: options.tenant
+      });
+      await api.vpnGatewaysDeleteByKey({ key });
+    })());
+    if (error) {
+      await reportError(error, LOGIN_INSTRUCTIONS2);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "VpnGatewayDeleted",
+      Data: { Key: key }
+    });
+  });
+};
+
+// ../vpngateway-commands/src/commands/vpn.ts
+var registerVpnCommand = (parent) => {
+  const integrations = getOrCreateIntegrationsCommand(parent);
+  const vpn = integrations.command("vpn").description("Manage UiPath VPN gateways and connections.");
+  registerGatewaysCommand(vpn);
+  registerConnectionsCommand(vpn);
+};
+function getOrCreateIntegrationsCommand(parent) {
+  const existing = parent.commands.find((c) => c.name() === "integrations");
+  if (existing)
+    return existing;
+  return parent.command("integrations").description("Manage UiPath integration configuration (VPN, ...).");
+}
+
+// ../vpngateway-commands/src/index.ts
+var registerCommands = async (program) => {
+  registerVpnCommand(program);
+};
+export {
+  registerCommands
+};
+
+//# debugId=7894022BB1A452E864756E2164756E21