@uipath/admin-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/tool-ezfarkxh.js

@@ -0,0 +1,2531 @@
+import {
+  getLoginStatusAsync
+} from "./tool-016jy57n.js";
+import {
+  OutputFormatter,
+  RESULTS,
+  addSdkUserAgentHeader,
+  catchError,
+  extractErrorMessage,
+  getFileSystem,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  processContext
+} from "./tool-v13kh7v7.js";
+import"./tool-1yh8g550.js";
+// ../apms-tool/package.json
+var package_default = {
+  name: "@uipath/apms-tool",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0-preview.211",
+  description: "CLI plugin for the UiPath Access Policy Management Service.",
+  private: false,
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/admin/apms-tool"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "cli-tool"
+  ],
+  type: "module",
+  main: "./dist/tool.js",
+  exports: {
+    ".": "./dist/tool.js"
+  },
+  bin: {
+    "apms-tool": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun ../../../tools/build-tool.ts",
+    package: "bun run build && bun pm pack",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.11",
+    "@uipath/apms-sdk": "workspace:*",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    commander: "^14.0.3",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../apms-sdk/generated/src/runtime.ts
+var BASE_PATH = "http://localhost:35599".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;
+  }
+}
+// ../apms-sdk/package.json
+var package_default2 = {
+  name: "@uipath/apms-sdk",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0",
+  description: "SDK for the UiPath Access Policy Management Service API.",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/admin/apms-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "access-policy-management",
+    "apms",
+    "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",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    lint: "biome check ."
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@types/node": "^25.5.2",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../apms-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default2);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainDataStatus.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainDataStatusToJSON(value) {
+  return value;
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainDataType.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainDataTypeFromJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainDataTypeFromJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainDataTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainDataTypeToJSON(value) {
+  return value;
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    startIp: value["startIp"],
+    endIp: value["endIp"],
+    ipNetworks: value["ipNetworks"],
+    expiresInMinutes: value["expiresInMinutes"],
+    type: UiPathPlatformServiceAccessPolicyManagementDomainDataTypeToJSON(value["type"])
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    status: UiPathPlatformServiceAccessPolicyManagementDomainDataStatusToJSON(value["status"])
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    serviceType: value["serviceType"],
+    folderId: value["folderId"],
+    appSystemName: value["appSystemName"],
+    tenantId: value["tenantId"],
+    appId: value["appId"],
+    appName: value["appName"],
+    appDescription: value["appDescription"]
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    ipNetworks: value["ipNetworks"],
+    type: UiPathPlatformServiceAccessPolicyManagementDomainDataTypeToJSON(value["type"])
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    startIp: value["startIp"],
+    endIp: value["endIp"],
+    name: value["name"],
+    ipNetwork: value["ipNetwork"]
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    status: UiPathPlatformServiceAccessPolicyManagementDomainDataStatusToJSON(value["status"]),
+    updatedOn: value["updatedOn"] == null ? value["updatedOn"] : value["updatedOn"].toISOString()
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequest.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequestToJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequestToJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    regexEntry: value["regexEntry"],
+    tenantId: value["tenantId"],
+    appId: value["appId"],
+    appName: value["appName"],
+    appDescription: value["appDescription"]
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDto.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    name: json["name"] == null ? undefined : json["name"],
+    ipNetwork: json["ipNetwork"] == null ? undefined : json["ipNetwork"],
+    organizationId: json["organizationId"] == null ? undefined : json["organizationId"],
+    type: json["type"] == null ? undefined : UiPathPlatformServiceAccessPolicyManagementDomainDataTypeFromJSON(json["type"]),
+    expiresAt: json["expiresAt"] == null ? undefined : new Date(json["expiresAt"])
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDto.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    name: json["name"] == null ? undefined : json["name"],
+    startIp: json["startIp"] == null ? undefined : json["startIp"],
+    endIp: json["endIp"] == null ? undefined : json["endIp"],
+    organizationId: json["organizationId"] == null ? undefined : json["organizationId"]
+  };
+}
+
+// ../apms-sdk/generated/src/models/UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDto.ts
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSON(json) {
+  return UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSONTyped(json, false);
+}
+function UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    regexBypassId: json["regexBypassId"] == null ? undefined : json["regexBypassId"],
+    serviceType: json["serviceType"] == null ? undefined : json["serviceType"],
+    organizationId: json["organizationId"] == null ? undefined : json["organizationId"],
+    regexEntry: json["regexEntry"] == null ? undefined : json["regexEntry"],
+    tenantId: json["tenantId"] == null ? undefined : json["tenantId"],
+    appId: json["appId"] == null ? undefined : json["appId"],
+    appName: json["appName"] == null ? undefined : json["appName"],
+    appDescription: json["appDescription"] == null ? undefined : json["appDescription"],
+    lastUpdated: json["lastUpdated"] == null ? undefined : new Date(json["lastUpdated"])
+  };
+}
+
+// ../apms-sdk/generated/src/apis/IpNetworkConfigurationApi.ts
+class IpNetworkConfigurationApi extends BaseAPI {
+  async _deleteRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete().');
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling _delete().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete(requestParameters, initOverrides) {
+    await this._deleteRaw(requestParameters, initOverrides);
+  }
+  async _delete_1Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete_1().');
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling _delete_1().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete_1(requestParameters, initOverrides) {
+    await this._delete_1Raw(requestParameters, initOverrides);
+  }
+  async _delete_2Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete_2().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequest"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete_2(requestParameters, initOverrides) {
+    await this._delete_2Raw(requestParameters, initOverrides);
+  }
+  async _delete_3Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete_3().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsDeleteIpNetworkRequest"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete_3(requestParameters, initOverrides) {
+    await this._delete_3Raw(requestParameters, initOverrides);
+  }
+  async addRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling add().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async add(requestParameters, initOverrides) {
+    const response = await this.addRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async add_4Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling add_4().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async add_4(requestParameters, initOverrides) {
+    const response = await this.add_4Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling get().');
+    }
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling get().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON(jsonValue));
+  }
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getByOrganizationIdRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling getByOrganizationId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async getByOrganizationId(requestParameters, initOverrides) {
+    const response = await this.getByOrganizationIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getByOrganizationId_5Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling getByOrganizationId_5().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async getByOrganizationId_5(requestParameters, initOverrides) {
+    const response = await this.getByOrganizationId_5Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async get_6Raw(requestParameters, initOverrides) {
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling get_6().');
+    }
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling get_6().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON(jsonValue));
+  }
+  async get_6(requestParameters, initOverrides) {
+    const response = await this.get_6Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async putRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling put().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async put(requestParameters, initOverrides) {
+    const response = await this.putRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async put_7Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling put_7().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON));
+  }
+  async put_7(requestParameters, initOverrides) {
+    const response = await this.put_7Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async updateRaw(requestParameters, initOverrides) {
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling update().');
+    }
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling update().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON(jsonValue));
+  }
+  async update(requestParameters, initOverrides) {
+    const response = await this.updateRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async update_8Raw(requestParameters, initOverrides) {
+    if (requestParameters["id"] == null) {
+      throw new RequiredError("id", 'Required parameter "id" was null or undefined when calling update_8().');
+    }
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling update_8().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipnetworks/{id}`;
+    urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters["id"])));
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpNetworkConfigurationDtoFromJSON(jsonValue));
+  }
+  async update_8(requestParameters, initOverrides) {
+    const response = await this.update_8Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+
+// ../apms-sdk/generated/src/apis/IpRangeConfigurationStatusApi.ts
+class IpRangeConfigurationStatusApi extends BaseAPI {
+  async _deleteRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete(requestParameters, initOverrides) {
+    await this._deleteRaw(requestParameters, initOverrides);
+  }
+  async _delete_1Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete_1().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete_1(requestParameters, initOverrides) {
+    await this._delete_1Raw(requestParameters, initOverrides);
+  }
+  async addRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling add().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSON(jsonValue));
+  }
+  async add(requestParameters, initOverrides) {
+    const response = await this.addRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async add_2Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling add_2().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSON(jsonValue));
+  }
+  async add_2(requestParameters, initOverrides) {
+    const response = await this.add_2Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling get().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSON(jsonValue));
+  }
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async get_3Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling get_3().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesIpRangeConfigurationDtoFromJSON(jsonValue));
+  }
+  async get_3(requestParameters, initOverrides) {
+    const response = await this.get_3Raw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async updateRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling update().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequest"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async update(requestParameters, initOverrides) {
+    await this.updateRaw(requestParameters, initOverrides);
+  }
+  async update_4Raw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling update_4().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/accessPolicy/organization/{organizationId}/ipRangeStatus`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequest"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async update_4(requestParameters, initOverrides) {
+    await this.update_4Raw(requestParameters, initOverrides);
+  }
+}
+
+// ../apms-sdk/generated/src/apis/RegexBypassApi.ts
+class RegexBypassApi extends BaseAPI {
+  async _deleteRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling _delete().');
+    }
+    if (requestParameters["regexBypassId"] == null) {
+      throw new RequiredError("regexBypassId", 'Required parameter "regexBypassId" was null or undefined when calling _delete().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/regexBypass/{regexBypassId}`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    urlPath = urlPath.replace(`{${"regexBypassId"}}`, encodeURIComponent(String(requestParameters["regexBypassId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async _delete(requestParameters, initOverrides) {
+    await this._deleteRaw(requestParameters, initOverrides);
+  }
+  async addRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling add().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/regexBypass`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSON(jsonValue));
+  }
+  async add(requestParameters, initOverrides) {
+    const response = await this.addRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling get().');
+    }
+    if (requestParameters["regexBypassId"] == null) {
+      throw new RequiredError("regexBypassId", 'Required parameter "regexBypassId" was null or undefined when calling get().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/regexBypass/{regexBypassId}`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    urlPath = urlPath.replace(`{${"regexBypassId"}}`, encodeURIComponent(String(requestParameters["regexBypassId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSON(jsonValue));
+  }
+  async get(requestParameters, initOverrides) {
+    const response = await this.getRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async getAllRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling getAll().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/regexBypass`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSON));
+  }
+  async getAll(requestParameters, initOverrides) {
+    const response = await this.getAllRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async updateRaw(requestParameters, initOverrides) {
+    if (requestParameters["organizationId"] == null) {
+      throw new RequiredError("organizationId", 'Required parameter "organizationId" was null or undefined when calling update().');
+    }
+    if (requestParameters["regexBypassId"] == null) {
+      throw new RequiredError("regexBypassId", 'Required parameter "regexBypassId" was null or undefined when calling update().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json-patch+json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("bearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/organization/{organizationId}/regexBypass/{regexBypassId}`;
+    urlPath = urlPath.replace(`{${"organizationId"}}`, encodeURIComponent(String(requestParameters["organizationId"])));
+    urlPath = urlPath.replace(`{${"regexBypassId"}}`, encodeURIComponent(String(requestParameters["regexBypassId"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequestToJSON(requestParameters["uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UiPathPlatformServiceAccessPolicyManagementDomainResponsesRegexBypassDtoFromJSON(jsonValue));
+  }
+  async update(requestParameters, initOverrides) {
+    const response = await this.updateRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+// ../apms-sdk/src/client-factory.ts
+var STRIP_PREFIX_RE = /\/accesspolicy_\/api\/(?:accessPolicy\/)?organization\/[^/]+/;
+function rewriteApmsUrl(url) {
+  return url.replace(STRIP_PREFIX_RE, "/accesspolicy_");
+}
+async function resolveConfig(options) {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options?.loginValidity
+  });
+  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 basePath = `${status.baseUrl}/${status.organizationId}/accesspolicy_`;
+  const bearerToken = options?.s2sToken ?? status.accessToken;
+  const fetchApi = (input, init) => {
+    if (typeof input === "string") {
+      return fetch(rewriteApmsUrl(input), init);
+    }
+    if (input instanceof URL) {
+      return fetch(rewriteApmsUrl(input.toString()), init);
+    }
+    return fetch(new Request(rewriteApmsUrl(input.url), input), init);
+  };
+  return {
+    config: new Configuration({
+      basePath,
+      accessToken: async () => bearerToken,
+      headers: addSdkUserAgentHeader(undefined, SDK_USER_AGENT),
+      fetchApi
+    }),
+    organizationId: status.organizationId
+  };
+}
+async function createApiClient(ApiClass, options) {
+  const { config, organizationId } = await resolveConfig(options);
+  return {
+    api: new ApiClass(config),
+    organizationId
+  };
+}
+// ../apms-tool/src/commands/_shared.ts
+var LOGIN_INSTRUCTIONS = "Ensure you are logged in with 'uip login' and have access to the Access Policy Management service.";
+var NON_NEGATIVE_INTEGER_RE = /^\d+$/;
+var parseIntOption = (raw) => {
+  const trimmed = raw.trim();
+  if (!NON_NEGATIVE_INTEGER_RE.test(trimmed)) {
+    throw new Error(`Expected a non-negative integer, got '${raw}'.`);
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected a non-negative integer, got '${raw}'.`);
+  }
+  return parsed;
+};
+var withLoginValidity = (cmd) => {
+  cmd.option("--login-validity <minutes>", "Override the interactive-login token lifetime for this call. Rarely needed.", parseIntOption);
+  return cmd;
+};
+async function loadJsonFile(file, typeLabel) {
+  const fs = getFileSystem();
+  const [readErr, content] = await catchError(fs.readFile(file, "utf-8"));
+  if (readErr || content === null) {
+    return [
+      {
+        message: readErr?.message ?? `File not found: ${file}`,
+        instructions: `Verify the file exists at '${file}' and is readable.`
+      },
+      null
+    ];
+  }
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr) {
+    return [
+      {
+        message: parseErr.message,
+        instructions: `The file must be valid JSON conforming to ${typeLabel}.`
+      },
+      null
+    ];
+  }
+  return [null, parsed];
+}
+var emitLoadError = (err) => {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: err.message,
+    Instructions: err.instructions
+  });
+  processContext.exit(1);
+};
+var emitFailure = async (error, instructions) => {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: await extractErrorMessage(error),
+    Instructions: instructions
+  });
+  processContext.exit(1);
+};
+var GUID_RE = /^[0-9a-fA-F-]{36}$/;
+async function extractResponseData(response) {
+  const [readErr, text] = await catchError(response.raw.clone().text());
+  if (readErr || !text)
+    return;
+  const [, parsed] = catchError(() => JSON.parse(text));
+  if (typeof parsed === "string" && GUID_RE.test(parsed)) {
+    return { operationId: parsed };
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return;
+}
+async function fetchCurrentIp(loginValidity) {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: loginValidity
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken || !status.organizationId) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  const url = `${status.baseUrl}/${status.organizationId}/portal_/api/accesspolicy/ip`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${status.accessToken}` }
+  });
+  const text = (await res.text()).trim();
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}${res.statusText ? ` ${res.statusText}` : ""}${text ? `: ${text}` : ""}`);
+  }
+  if (isIPv4(text)) {
+    return { body: { ipAddress: text }, ip: text };
+  }
+  const [, parsed] = catchError(() => JSON.parse(text));
+  if (typeof parsed === "string" && isIPv4(parsed)) {
+    return { body: { ipAddress: parsed }, ip: parsed };
+  }
+  const body = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  const candidate = body.ipAddress ?? body.ip ?? body.clientIp ?? body.publicIp;
+  const ip = typeof candidate === "string" ? candidate : undefined;
+  return { body, ip };
+}
+var IPV4_SEGMENT = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])";
+var IPV4_REGEX = new RegExp(`^(?:${IPV4_SEGMENT}\\.){3}${IPV4_SEGMENT}$`);
+function isIPv4(value) {
+  return typeof value === "string" && IPV4_REGEX.test(value);
+}
+function ipInCidr(ip, cidr) {
+  if (!isIPv4(ip))
+    return false;
+  const [network, prefixRaw] = cidr.split("/");
+  if (!isIPv4(network))
+    return false;
+  const prefix = prefixRaw === undefined ? 32 : Number(prefixRaw);
+  if (!Number.isInteger(prefix) || prefix < 0 || prefix > 32 || Number.isNaN(prefix)) {
+    return false;
+  }
+  const toInt = (addr) => {
+    const octets = addr.split(".").map(Number);
+    return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+  };
+  const mask = prefix === 0 ? 0 : ~0 << 32 - prefix >>> 0;
+  return (toInt(ip) & mask) === (toInt(network) & mask);
+}
+var MINUTES_PER = {
+  m: 1,
+  h: 60,
+  d: 60 * 24,
+  w: 60 * 24 * 7
+};
+var MAX_EXPIRES_MINUTES = 60 * 24 * 365 * 10;
+function parseExpiresMinutes(input) {
+  const trimmed = input.trim();
+  const match = trimmed.match(/^(\d+)([mhdw])$/);
+  if (!match) {
+    throw new Error(`Expected --expires in the form <integer><m|h|d|w> (e.g. 15m, 2h, 30d, 1w), got '${input}'.`);
+  }
+  const n = Number.parseInt(match[1], 10);
+  const minutes = n * MINUTES_PER[match[2]];
+  if (minutes < 1) {
+    throw new Error(`--expires must be at least 1 minute, got '${input}'.`);
+  }
+  if (minutes > MAX_EXPIRES_MINUTES) {
+    throw new Error(`--expires must be at most 10 years (= ${MAX_EXPIRES_MINUTES} minutes), got '${input}'.`);
+  }
+  return minutes;
+}
+function findEntryIdByCidr(entries, cidr) {
+  const matches = entries.filter((e) => e.ipNetwork === cidr);
+  if (matches.length === 0)
+    return { error: "none" };
+  if (matches.length > 1)
+    return { error: "ambiguous" };
+  const id = matches[0].id;
+  if (typeof id !== "string" || id.length === 0)
+    return { error: "none" };
+  return { id };
+}
+
+// ../apms-tool/src/commands/bypass-rules.ts
+async function getApi(options) {
+  const [err, client] = await catchError(createApiClient(RegexBypassApi, {
+    loginValidity: options.loginValidity
+  }));
+  if (err) {
+    await emitFailure(err, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  return client;
+}
+var SAMPLE_ID = "b1c2d3e4-0000-0000-0000-000000000001";
+var LIST_EXAMPLES = [
+  {
+    Description: "List all bypass rules for the organization",
+    Command: "uip admin ip-restriction bypass-rules list",
+    Output: {
+      Code: "ApmsBypassRulesList",
+      Data: [{ id: SAMPLE_ID, regexEntry: "^.*\\.contoso\\.com$" }]
+    }
+  },
+  {
+    Description: "List rules whose regexEntry or appName contains a fragment (case-insensitive)",
+    Command: "uip admin ip-restriction bypass-rules list --filter contoso",
+    Output: {
+      Code: "ApmsBypassRulesList",
+      Data: [{ id: SAMPLE_ID, regexEntry: "^.*\\.contoso\\.com$" }]
+    }
+  }
+];
+var GET_EXAMPLES = [
+  {
+    Description: "Fetch a single bypass rule by id",
+    Command: `uip admin ip-restriction bypass-rules get ${SAMPLE_ID}`,
+    Output: {
+      Code: "ApmsBypassRulesGet",
+      Data: { id: SAMPLE_ID, regexEntry: "^.*\\.contoso\\.com$" }
+    }
+  }
+];
+var CREATE_EXAMPLES = [
+  {
+    Description: "Create a new bypass rule from a JSON file",
+    Command: "uip admin ip-restriction bypass-rules create --file ./bypass-rule.json",
+    Output: {
+      Code: "ApmsBypassRulesCreated",
+      Data: { id: SAMPLE_ID, regexEntry: "^.*\\.contoso\\.com$" }
+    }
+  }
+];
+var UPDATE_EXAMPLES = [
+  {
+    Description: "Patch an existing bypass rule by id",
+    Command: `uip admin ip-restriction bypass-rules update ${SAMPLE_ID} --file ./bypass-rule-update.json`,
+    Output: {
+      Code: "ApmsBypassRulesUpdated",
+      Data: { id: SAMPLE_ID, regexEntry: "^.*\\.contoso\\.com$" }
+    }
+  }
+];
+var DELETE_EXAMPLES = [
+  {
+    Description: "Delete a bypass rule by id",
+    Command: `uip admin ip-restriction bypass-rules delete ${SAMPLE_ID}`,
+    Output: { Code: "ApmsBypassRulesDeleted", Data: {} }
+  }
+];
+var registerBypassRulesCommands = (apms) => {
+  const bypassRules = apms.command("bypass-rules").description([
+    "Manage bypass rules that exempt specific URL patterns from IP allowlisting.",
+    "",
+    "Use this when an org has IP allowlisting on but needs a narrowly-scoped",
+    "exception for a specific App / folder / tenant URL pattern. Each rule's",
+    "regex pattern is generated server-side from the supplied entry."
+  ].join(`
+`));
+  withLoginValidity(bypassRules.command("list").description([
+    "List bypass rules configured for the caller's organization.",
+    "",
+    "Pass `--filter <fragment>` to narrow client-side; matches are",
+    "case-insensitive substrings on either `regexEntry` or `appName`."
+  ].join(`
+`)).option("--filter <fragment>", "Case-insensitive substring filter on regexEntry or appName.").examples(LIST_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const client = await getApi(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.getAll({ organizationId: client.organizationId }));
+    if (error) {
+      await emitFailure(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    const rules = result ?? [];
+    const filterFragment = options.filter?.toLowerCase();
+    const filtered = filterFragment !== undefined ? rules.filter((r) => {
+      const haystack = `${r.regexEntry ?? ""} ${r.appName ?? ""}`.toLowerCase();
+      return haystack.includes(filterFragment);
+    }) : rules;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsBypassRulesList",
+      Data: filtered
+    });
+  });
+  withLoginValidity(bypassRules.command("get").description("Fetch a single bypass rule by id within the caller's organization.").argument("<id>", "Bypass rule UUID. Obtain from `bypass-rules list`.").examples(GET_EXAMPLES)).trackedAction(processContext, async (id, options) => {
+    const client = await getApi(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.get({
+      regexBypassId: id,
+      organizationId: client.organizationId
+    }));
+    if (error) {
+      await emitFailure(error, "Check the bypass rule UUID with 'uip admin ip-restriction bypass-rules list'.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsBypassRulesGet",
+      Data: result
+    });
+  });
+  withLoginValidity(bypassRules.command("create").description("Create a new bypass rule from a JSON file (AddRegexBypassRequest schema).").requiredOption("--file <path>", "Path to a JSON file containing the AddRegexBypassRequest body.").examples(CREATE_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const client = await getApi(options);
+    if (!client)
+      return;
+    const [loadErr, body] = await loadJsonFile(options.file, "AddRegexBypassRequest");
+    if (loadErr) {
+      emitLoadError(loadErr);
+      return;
+    }
+    const [error, result] = await catchError(client.api.add({
+      organizationId: client.organizationId,
+      uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddRegexBypassRequest: body
+    }));
+    if (error) {
+      await emitFailure(error, "Verify --file is valid JSON conforming to AddRegexBypassRequest.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsBypassRulesCreated",
+      Data: result
+    });
+  });
+  withLoginValidity(bypassRules.command("update").description([
+    "Patch an existing bypass rule by id. The supplied regexEntry replaces",
+    "the stored pattern.",
+    "",
+    "For the typical case, pass `--regex-entry <pattern>` inline. For the",
+    "rarer case where you want to update tenant/app metadata too, pass",
+    "`--file <path>` with the full UpdateRegexBypassRequest body."
+  ].join(`
+`)).argument("<id>", "Bypass rule UUID. Obtain from `bypass-rules list`.").option("--file <path>", "Path to a JSON file containing the UpdateRegexBypassRequest body.").option("--regex-entry <pattern>", "Replacement regex pattern (the only required field on update).").examples(UPDATE_EXAMPLES)).trackedAction(processContext, async (id, options) => {
+    const inlineProvided = options.regexEntry !== undefined;
+    if (options.file !== undefined && inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--file is mutually exclusive with --regex-entry.",
+        Instructions: "Pass either --file for the full body, or --regex-entry for the pattern-only update."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (options.file === undefined && !inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Provide either --file or --regex-entry.",
+        Instructions: "Inline: --regex-entry <pattern>. File: --file <path> with an UpdateRegexBypassRequest body."
+      });
+      processContext.exit(1);
+      return;
+    }
+    let body;
+    if (options.file !== undefined) {
+      const [loadErr, loaded] = await loadJsonFile(options.file, "UpdateRegexBypassRequest");
+      if (loadErr) {
+        emitLoadError(loadErr);
+        return;
+      }
+      body = loaded;
+    } else {
+      body = { regexEntry: options.regexEntry };
+    }
+    const client = await getApi(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.update({
+      regexBypassId: id,
+      organizationId: client.organizationId,
+      uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateRegexBypassRequest: body
+    }));
+    if (error) {
+      await emitFailure(error, "Verify the rule UUID and that the request matches the UpdateRegexBypassRequest schema.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsBypassRulesUpdated",
+      Data: result
+    });
+  });
+  withLoginValidity(bypassRules.command("delete").description("Delete a bypass rule by id within the caller's organization.").argument("<id>", "Bypass rule UUID. Obtain from `bypass-rules list`.").examples(DELETE_EXAMPLES)).trackedAction(processContext, async (id, options) => {
+    const client = await getApi(options);
+    if (!client)
+      return;
+    const [error, response] = await catchError(client.api._deleteRaw({
+      regexBypassId: id,
+      organizationId: client.organizationId
+    }));
+    if (error || !response) {
+      await emitFailure(error ?? new Error("Empty response"), "Check the bypass rule UUID with 'uip admin ip-restriction bypass-rules list'.");
+      return;
+    }
+    const responseBody = await extractResponseData(response);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsBypassRulesDeleted",
+      Data: responseBody ?? {}
+    });
+  });
+};
+
+// ../apms-tool/src/commands/enforcement.ts
+var ENABLE_WARNING = "You are attempting to enforce IP restriction. Once it is enforced, this organization can not be accessed from any untrusted IP address that belongs to a user or robot.";
+var PREFLIGHT_REJECT_MESSAGE = "Your IP address must be within the trusted IP ranges before you enforce IP restrictions. Please add your IP address and try again.";
+var GET_EXAMPLES2 = [
+  {
+    Description: "Fetch the current IP-range enforcement state for the organization",
+    Command: "uip admin ip-restriction enforcement get",
+    Output: {
+      Code: "ApmsEnforcementGet",
+      Data: { organizationId: "<org-guid>" }
+    }
+  }
+];
+var ENABLE_EXAMPLES = [
+  {
+    Description: "Turn on IP-range enforcement. The CLI first calls `my-ip` and `ip-ranges list` to confirm your IP is in the allowlist, then patches the status. `--confirm` is mandatory because the wrong allowlist locks you out instantly.",
+    Command: "uip admin ip-restriction enforcement enable --confirm",
+    Output: { Code: "ApmsEnforcementEnabled", Data: {} }
+  }
+];
+var DISABLE_EXAMPLES = [
+  {
+    Description: "Turn off IP-range enforcement (idempotent).",
+    Command: "uip admin ip-restriction enforcement disable",
+    Output: { Code: "ApmsEnforcementDisabled", Data: {} }
+  }
+];
+async function getStatusApi(options) {
+  const [err, client] = await catchError(createApiClient(IpRangeConfigurationStatusApi, {
+    loginValidity: options.loginValidity
+  }));
+  if (err) {
+    await emitFailure(err, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  return client;
+}
+async function getNetworksApi(options) {
+  const [err, client] = await catchError(createApiClient(IpNetworkConfigurationApi, {
+    loginValidity: options.loginValidity
+  }));
+  if (err) {
+    await emitFailure(err, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  return client;
+}
+async function setEnforcement(api, organizationId, status) {
+  const [updateErr, updateRes] = await catchError(api.updateRaw({
+    organizationId,
+    uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationStatusRequest: {
+      status
+    }
+  }));
+  if (!updateErr && updateRes) {
+    return { body: await extractResponseData(updateRes), error: null };
+  }
+  const status404 = (updateErr?.status ?? 0) === 404 || (updateErr?.response?.status ?? 0) === 404;
+  if (!status404) {
+    return { body: undefined, error: updateErr };
+  }
+  const [addErr, addRes] = await catchError(api.addRaw({
+    organizationId,
+    uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationStatusRequest: {
+      status
+    }
+  }));
+  if (addErr || !addRes) {
+    return {
+      body: undefined,
+      error: addErr ?? new Error("Empty response")
+    };
+  }
+  return { body: await extractResponseData(addRes), error: null };
+}
+var registerEnforcementCommands = (apms) => {
+  const enforcement = apms.command("enforcement").description([
+    "Manage the singleton IP-range enforcement switch for the organization.",
+    "",
+    "When enforcement is on, only the IP networks in `ip-ranges list`",
+    "can reach this org. When off, the platform default applies."
+  ].join(`
+`));
+  withLoginValidity(enforcement.command("get").description("Show the current IP-range enforcement state for the caller's organization.").examples(GET_EXAMPLES2)).trackedAction(processContext, async (options) => {
+    const client = await getStatusApi(options);
+    if (!client)
+      return;
+    const [error, response] = await catchError(client.api.getRaw({ organizationId: client.organizationId }));
+    if (error || !response) {
+      await emitFailure(error ?? new Error("Empty response"), LOGIN_INSTRUCTIONS);
+      return;
+    }
+    const responseBody = await extractResponseData(response);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsEnforcementGet",
+      Data: responseBody ?? {}
+    });
+  });
+  withLoginValidity(enforcement.command("enable").description([
+    "Enforce IP restrictions for the organization (idempotent).",
+    "",
+    "Pre-flight: the CLI calls `my-ip` and compares it against the",
+    "CIDRs returned by `ip-ranges list`. If your IP isn't in any",
+    "trusted entry the call is rejected before reaching the platform.",
+    "",
+    "**Lockout warning** — wrong allowlist + enabled enforcement",
+    "= your org becomes unreachable from any address outside the",
+    "list. `--confirm` is mandatory."
+  ].join(`
+`)).option("--confirm", "Acknowledge the lockout risk and proceed. Required.").examples(ENABLE_EXAMPLES)).trackedAction(processContext, async (options) => {
+    if (options.confirm !== true) {
+      OutputFormatter.log({ Warning: ENABLE_WARNING });
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--confirm is required to enforce IP restrictions.",
+        Instructions: "Re-run with --confirm to acknowledge the lockout risk and proceed."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [ipErr, ipResult] = await catchError(fetchCurrentIp(options.loginValidity));
+    if (ipErr || !ipResult) {
+      await emitFailure(ipErr ?? new Error("Failed to determine current IP"), "Run `uip admin ip-restriction my-ip` to inspect the response from the IP discovery endpoint.");
+      return;
+    }
+    const callerIp = ipResult.ip;
+    if (!callerIp) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Could not determine the caller's IP from the platform response.",
+        Instructions: "The IP-discovery endpoint returned an unexpected shape. Inspect with `uip admin ip-restriction my-ip`."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const networksClient = await getNetworksApi(options);
+    if (!networksClient)
+      return;
+    const [listErr, entries] = await catchError(networksClient.api.getByOrganizationId({
+      organizationId: networksClient.organizationId
+    }));
+    if (listErr) {
+      await emitFailure(listErr, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    const cidrs = (entries ?? []).map((e) => e.ipNetwork).filter((c) => typeof c === "string" && c.length > 0);
+    const inRange = cidrs.some((cidr) => ipInCidr(callerIp, cidr));
+    if (!inRange) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: PREFLIGHT_REJECT_MESSAGE,
+        Instructions: `Your current IP is ${callerIp}. Add it via 'uip admin ip-restriction ip-ranges create --name <label> --cidr ${callerIp}/32' (or a wider CIDR), then re-run.`
+      });
+      processContext.exit(1);
+      return;
+    }
+    const statusClient = await getStatusApi(options);
+    if (!statusClient)
+      return;
+    const { body, error } = await setEnforcement(statusClient.api, statusClient.organizationId, "Enabled");
+    if (error) {
+      await emitFailure(error, "Verify the request body conforms to UpdateIpConfigurationStatusRequest.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsEnforcementEnabled",
+      Data: body ?? {}
+    });
+  });
+  withLoginValidity(enforcement.command("disable").description([
+    "Stop enforcing IP restrictions (idempotent).",
+    "",
+    "Patches the singleton status row to Disabled; lazily creates",
+    "the row first if it doesn't exist yet."
+  ].join(`
+`)).examples(DISABLE_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const client = await getStatusApi(options);
+    if (!client)
+      return;
+    const { body, error } = await setEnforcement(client.api, client.organizationId, "Disabled");
+    if (error) {
+      await emitFailure(error, "Verify the request body conforms to UpdateIpConfigurationStatusRequest.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsEnforcementDisabled",
+      Data: body ?? {}
+    });
+  });
+};
+
+// ../apms-tool/src/commands/ip-ranges.ts
+function hasCreateInline(options) {
+  return options.name !== undefined || options.cidr !== undefined && options.cidr.length > 0 || options.startIp !== undefined || options.endIp !== undefined || options.expires !== undefined;
+}
+function hasUpdateInline(options) {
+  return options.name !== undefined || options.startIp !== undefined || options.endIp !== undefined || options.cidr !== undefined;
+}
+async function getApi2(options) {
+  const [err, client] = await catchError(createApiClient(IpNetworkConfigurationApi, {
+    loginValidity: options.loginValidity
+  }));
+  if (err) {
+    await emitFailure(err, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  return client;
+}
+async function getStatusApi2(options) {
+  const [err, client] = await catchError(createApiClient(IpRangeConfigurationStatusApi, {
+    loginValidity: options.loginValidity
+  }));
+  if (err) {
+    await emitFailure(err, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  return client;
+}
+var SAMPLE_ID2 = "a1b2c3d4-0000-0000-0000-000000000001";
+var DELETE_WARNING = "You are about to delete an IP range entry. If enforcement is enabled, removing the wrong entry can lock you — or the whole organization — out of UiPath. Verify the target with `ip-ranges list` and `my-ip` before proceeding.";
+var LIST_EXAMPLES2 = [
+  {
+    Description: "List all IP range entries for the current organization",
+    Command: "uip admin ip-restriction ip-ranges list",
+    Output: {
+      Code: "ApmsIpRangesList",
+      Data: [
+        {
+          id: SAMPLE_ID2,
+          name: "Office VPN",
+          ipNetwork: "10.0.0.0/16"
+        }
+      ]
+    }
+  },
+  {
+    Description: "List entries whose name contains a fragment (case-insensitive)",
+    Command: "uip admin ip-restriction ip-ranges list --filter office",
+    Output: { Code: "ApmsIpRangesList", Data: [] }
+  }
+];
+var GET_EXAMPLES3 = [
+  {
+    Description: "Fetch a single IP range entry by id",
+    Command: `uip admin ip-restriction ip-ranges get ${SAMPLE_ID2}`,
+    Output: {
+      Code: "ApmsIpRangeGet",
+      Data: {
+        id: SAMPLE_ID2,
+        name: "Office VPN",
+        ipNetwork: "10.0.0.0/16"
+      }
+    }
+  },
+  {
+    Description: "Fetch by CIDR (no need to look up the GUID first)",
+    Command: "uip admin ip-restriction ip-ranges get --cidr 10.0.0.0/16",
+    Output: {
+      Code: "ApmsIpRangeGet",
+      Data: {
+        id: SAMPLE_ID2,
+        name: "Office VPN",
+        ipNetwork: "10.0.0.0/16"
+      }
+    }
+  }
+];
+var CREATE_EXAMPLES2 = [
+  {
+    Description: "Add a CIDR entry inline. Idempotent — second call with the same --cidr is a safe no-op.",
+    Command: "uip admin ip-restriction ip-ranges create --name 'Office VPN' --cidr 10.0.0.0/16",
+    Output: {
+      Code: "ApmsIpRangeCreated",
+      Data: [{ id: SAMPLE_ID2, name: "Office VPN" }]
+    }
+  },
+  {
+    Description: "Add multiple CIDRs at once and set an expiry of 30 days",
+    Command: "uip admin ip-restriction ip-ranges create --name 'Datacenter A' --cidr 10.0.0.0/16 --cidr 192.168.0.0/24 --expires 30d",
+    Output: { Code: "ApmsIpRangeCreated", Data: [] }
+  },
+  {
+    Description: "Add an entry as a start/end IP range (legacy shape; still supported)",
+    Command: "uip admin ip-restriction ip-ranges create --name 'Office' --start-ip 10.0.0.1 --end-ip 10.0.0.50",
+    Output: { Code: "ApmsIpRangeCreated", Data: [] }
+  },
+  {
+    Description: "Full body control via JSON file",
+    Command: "uip admin ip-restriction ip-ranges create --file ./entry.json",
+    Output: { Code: "ApmsIpRangeCreated", Data: [] }
+  }
+];
+var UPDATE_EXAMPLES2 = [
+  {
+    Description: "Rename an entry",
+    Command: `uip admin ip-restriction ip-ranges update ${SAMPLE_ID2} --name 'Home VPN'`,
+    Output: {
+      Code: "ApmsIpRangeUpdated",
+      Data: { id: SAMPLE_ID2, name: "Home VPN" }
+    }
+  },
+  {
+    Description: "Replace the CIDR on an existing entry",
+    Command: `uip admin ip-restriction ip-ranges update ${SAMPLE_ID2} --cidr 10.0.1.0/24`,
+    Output: { Code: "ApmsIpRangeUpdated", Data: { id: SAMPLE_ID2 } }
+  }
+];
+var DELETE_EXAMPLES2 = [
+  {
+    Description: "Delete by id (--confirm acknowledges the lockout risk)",
+    Command: `uip admin ip-restriction ip-ranges delete ${SAMPLE_ID2} --confirm`,
+    Output: { Code: "ApmsIpRangeDeleted", Data: {} }
+  },
+  {
+    Description: "Delete by CIDR (lookup-then-delete)",
+    Command: "uip admin ip-restriction ip-ranges delete --cidr 10.0.0.0/16 --confirm",
+    Output: { Code: "ApmsIpRangeDeleted", Data: {} }
+  }
+];
+async function resolveEntryId(api, organizationId, positionalId, cidr) {
+  if (positionalId !== undefined && cidr !== undefined) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Pass either the positional id OR --cidr, not both.",
+      Instructions: "Use the positional UUID or the --cidr <cidr> flag to identify the entry."
+    });
+    processContext.exit(1);
+    return null;
+  }
+  if (positionalId === undefined && cidr === undefined) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Provide an id positionally or --cidr <cidr>.",
+      Instructions: "Look the id up via `uip admin ip-restriction ip-ranges list`, or pass --cidr <cidr>."
+    });
+    processContext.exit(1);
+    return null;
+  }
+  const [listErr, entries] = await catchError(api.getByOrganizationId({ organizationId }));
+  if (listErr) {
+    await emitFailure(listErr, LOGIN_INSTRUCTIONS);
+    return null;
+  }
+  const allEntries = entries ?? [];
+  if (positionalId !== undefined) {
+    return { id: positionalId, entries: allEntries };
+  }
+  const result = findEntryIdByCidr(allEntries, cidr);
+  if (result.error === "none") {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: `No ip-range entry matched CIDR '${cidr}'.`,
+      Instructions: "Run `uip admin ip-restriction ip-ranges list` to see the entries currently configured."
+    });
+    processContext.exit(1);
+    return null;
+  }
+  if (result.error === "ambiguous") {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: `Multiple ip-range entries match CIDR '${cidr}'. Resolve by id instead.`,
+      Instructions: "List entries with `uip admin ip-restriction ip-ranges list` and pass the positional id of the one to operate on."
+    });
+    processContext.exit(1);
+    return null;
+  }
+  return { id: result.id, entries: allEntries };
+}
+var registerIpRangesCommands = (apms) => {
+  const ipranges = apms.command("ip-ranges").description([
+    "Manage IP range allowlists for the organization.",
+    "",
+    "Each entry can be a CIDR block, a start/end IP range, or a list of CIDRs.",
+    "Entries gate inbound access to UiPath Cloud — see UiPath docs for the full schema."
+  ].join(`
+`));
+  withLoginValidity(ipranges.command("list").description([
+    "List IP range entries for the caller's organization.",
+    "",
+    "Pass `--filter <fragment>` to narrow client-side by name",
+    "(case-insensitive substring match on the entry's `name` field)."
+  ].join(`
+`)).option("--filter <fragment>", "Case-insensitive substring filter on the entry's name.").examples(LIST_EXAMPLES2)).trackedAction(processContext, async (options) => {
+    const client = await getApi2(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.getByOrganizationId({
+      organizationId: client.organizationId
+    }));
+    if (error) {
+      await emitFailure(error, LOGIN_INSTRUCTIONS);
+      return;
+    }
+    const entries = result ?? [];
+    const filterFragment = options.filter?.toLowerCase();
+    const filtered = filterFragment !== undefined ? entries.filter((e) => (e.name ?? "").toLowerCase().includes(filterFragment)) : entries;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsIpRangesList",
+      Data: filtered
+    });
+  });
+  withLoginValidity(ipranges.command("get").description([
+    "Fetch a single IP range entry by id or by CIDR.",
+    "",
+    "Pass the entry's UUID positionally, or `--cidr <cidr>` to look it up",
+    "by its allowlist value (the CLI lists entries and finds the match)."
+  ].join(`
+`)).argument("[id]", "IP range entry UUID. Obtain from `ip-ranges list`. Optional when --cidr is provided.").option("--cidr <cidr>", "Look up the entry by CIDR instead of id.").examples(GET_EXAMPLES3)).trackedAction(processContext, async (positionalId, options) => {
+    const client = await getApi2(options);
+    if (!client)
+      return;
+    const resolved = await resolveEntryId(client.api, client.organizationId, positionalId, options.cidr);
+    if (!resolved)
+      return;
+    const [error, result] = await catchError(client.api.get({
+      id: resolved.id,
+      organizationId: client.organizationId
+    }));
+    if (error) {
+      await emitFailure(error, "Check the IP range UUID with 'uip admin ip-restriction ip-ranges list'.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsIpRangeGet",
+      Data: result
+    });
+  });
+  withLoginValidity(ipranges.command("create").description([
+    "Add an IP range entry to the organization (idempotent).",
+    "",
+    "This call upserts on CIDR — running it twice with the same --cidr is",
+    "a safe no-op. For repeating CIDRs in one call, pass --cidr multiple",
+    "times. For full body control, pass --file <path> with an",
+    "AddIpConfigurationRequest body."
+  ].join(`
+`)).option("--file <path>", "Path to a JSON file containing the AddIpConfigurationRequest body.").option("--name <name>", "Display name for the entry. Required in inline mode.").option("--cidr <cidr>", "CIDR block to allow (e.g. 10.0.0.0/16). Repeatable to add several in one call.", (value, prev) => [
+    ...prev ?? [],
+    value
+  ]).option("--start-ip <ip>", "Start of an IP range (use with --end-ip).").option("--end-ip <ip>", "End of an IP range (use with --start-ip).").option("--expires <duration>", "Optional expiry. Accepts <integer><m|h|d|w> (e.g. 15m, 2h, 30d, 1w).").examples(CREATE_EXAMPLES2)).trackedAction(processContext, async (options) => {
+    const inlineProvided = hasCreateInline(options);
+    if (options.file !== undefined && inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--file is mutually exclusive with --name / --cidr / --start-ip / --end-ip / --expires.",
+        Instructions: "Pass either --file for the full body, or the inline flags for a simple range."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (options.file === undefined && !inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Provide either --file or inline flags.",
+        Instructions: "Inline minimum: --name <name> --cidr <cidr>. Or pass --file <path> for the full body."
+      });
+      processContext.exit(1);
+      return;
+    }
+    let body;
+    if (options.file !== undefined) {
+      const [loadErr, loaded] = await loadJsonFile(options.file, "AddIpConfigurationRequest");
+      if (loadErr) {
+        emitLoadError(loadErr);
+        return;
+      }
+      body = loaded;
+    } else {
+      if (options.name === undefined) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "--name is required in inline mode.",
+          Instructions: "Pass --name '<label>'. The platform stores the label and `ip-ranges list` shows it; without it the entry is hard to identify later."
+        });
+        processContext.exit(1);
+        return;
+      }
+      const hasCidr = options.cidr !== undefined && options.cidr.length > 0;
+      const hasStart = options.startIp !== undefined;
+      const hasEnd = options.endIp !== undefined;
+      if (hasCidr && (hasStart || hasEnd)) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "--cidr is mutually exclusive with --start-ip / --end-ip.",
+          Instructions: "Pick one shape: either --cidr <cidr> (repeatable) for CIDR allowlists, or --start-ip + --end-ip for a contiguous range."
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (hasStart && !hasEnd || !hasStart && hasEnd) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "--start-ip and --end-ip must be provided together.",
+          Instructions: "Pass both bounds of the range, or switch to --cidr <cidr>."
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (!hasCidr && !hasStart && !hasEnd) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Provide either --cidr (repeatable) or --start-ip + --end-ip in inline mode.",
+          Instructions: "Inline minimum: --name <name> --cidr <cidr>."
+        });
+        processContext.exit(1);
+        return;
+      }
+      let expiresInMinutes;
+      if (options.expires !== undefined) {
+        const [parseErr, minutes] = catchError(() => parseExpiresMinutes(options.expires));
+        if (parseErr) {
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: parseErr.message,
+            Instructions: "--expires accepts <integer><m|h|d|w>: 15m, 2h, 30d, 1w. Omit for no expiry."
+          });
+          processContext.exit(1);
+          return;
+        }
+        expiresInMinutes = minutes;
+      }
+      body = {
+        name: options.name,
+        ...hasCidr ? { ipNetworks: options.cidr } : {},
+        ...hasStart ? { startIp: options.startIp } : {},
+        ...hasEnd ? { endIp: options.endIp } : {},
+        ...expiresInMinutes !== undefined ? { expiresInMinutes } : {}
+      };
+    }
+    const client = await getApi2(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.put({
+      organizationId: client.organizationId,
+      uiPathPlatformServiceAccessPolicyManagementDomainRequestsAddIpConfigurationRequest: body
+    }));
+    if (error) {
+      await emitFailure(error, "Verify the request body and that the IP range fields are well-formed.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsIpRangeCreated",
+      Data: result
+    });
+  });
+  withLoginValidity(ipranges.command("update").description([
+    "Patch a single IP range entry by id.",
+    "",
+    "Pass any of `--name`, `--cidr`, `--start-ip`, `--end-ip` inline, or",
+    "`--file <path>` for the full UpdateIpConfigurationRequest body."
+  ].join(`
+`)).argument("<id>", "IP range entry UUID. Obtain from `ip-ranges list`.").option("--file <path>", "Path to a JSON file containing the UpdateIpConfigurationRequest body.").option("--name <name>", "New display name.").option("--cidr <cidr>", "New CIDR to set on the entry.").option("--start-ip <ip>", "New start of the IP range.").option("--end-ip <ip>", "New end of the IP range.").examples(UPDATE_EXAMPLES2)).trackedAction(processContext, async (id, options) => {
+    const inlineProvided = hasUpdateInline(options);
+    if (options.file !== undefined && inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--file is mutually exclusive with --name / --cidr / --start-ip / --end-ip.",
+        Instructions: "Pass either --file for the full body, or the inline flags for the fields you want to change."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (options.file === undefined && !inlineProvided) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Provide either --file or inline flags.",
+        Instructions: "Inline: at least one of --name / --cidr / --start-ip / --end-ip. File: --file <path>."
+      });
+      processContext.exit(1);
+      return;
+    }
+    let body;
+    if (options.file !== undefined) {
+      const [loadErr, loaded] = await loadJsonFile(options.file, "UpdateIpConfigurationRequest");
+      if (loadErr) {
+        emitLoadError(loadErr);
+        return;
+      }
+      body = loaded;
+    } else {
+      body = {
+        name: options.name,
+        startIp: options.startIp,
+        endIp: options.endIp,
+        ipNetwork: options.cidr
+      };
+    }
+    const client = await getApi2(options);
+    if (!client)
+      return;
+    const [error, result] = await catchError(client.api.update({
+      id,
+      organizationId: client.organizationId,
+      uiPathPlatformServiceAccessPolicyManagementDomainRequestsUpdateIpConfigurationRequest: body
+    }));
+    if (error) {
+      await emitFailure(error, "Verify the IP range UUID and that --file matches the UpdateIpConfigurationRequest schema.");
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsIpRangeUpdated",
+      Data: result
+    });
+  });
+  withLoginValidity(ipranges.command("delete").description([
+    "Delete a single IP range entry by id or by CIDR.",
+    "",
+    "**Lockout warning** — removing the wrong entry while enforcement",
+    "is enabled can lock you (or the whole org) out of UiPath.",
+    "`--confirm` is mandatory; the CLI also runs a safety pre-flight",
+    "(only-entry / caller-IP-uniquely-covered) when enforcement is on.",
+    "To bypass the safety check, run `enforcement disable` first."
+  ].join(`
+`)).argument("[id]", "IP range entry UUID. Obtain from `ip-ranges list`. Optional when --cidr is provided.").option("--cidr <cidr>", "Look up the entry to delete by CIDR instead of id.").option("--confirm", "Acknowledge the lockout risk and proceed. Required.").examples(DELETE_EXAMPLES2)).trackedAction(processContext, async (positionalId, options) => {
+    if (options.confirm !== true) {
+      OutputFormatter.log({ Warning: DELETE_WARNING });
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "--confirm is required to delete an IP range entry.",
+        Instructions: "Re-run with --confirm to acknowledge the lockout risk and proceed."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const client = await getApi2(options);
+    if (!client)
+      return;
+    const resolved = await resolveEntryId(client.api, client.organizationId, positionalId, options.cidr);
+    if (!resolved)
+      return;
+    const { id, entries } = resolved;
+    const statusClient = await getStatusApi2(options);
+    if (!statusClient)
+      return;
+    const [statusErr, statusResp] = await catchError(statusClient.api.getRaw({
+      organizationId: statusClient.organizationId
+    }));
+    if (statusErr || !statusResp) {
+      await emitFailure(statusErr ?? new Error("Empty response"), "Failed to read enforcement status before delete. Run `uip admin ip-restriction enforcement get` to inspect.");
+      return;
+    }
+    const statusBody = await extractResponseData(statusResp);
+    const enforcementEnabled = statusBody?.status === "Enabled";
+    if (enforcementEnabled) {
+      if (entries.length <= 1) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Refusing to delete the only IP range entry while enforcement is enabled — the organization would become unreachable.",
+          Instructions: "Run `uip admin ip-restriction enforcement disable` first, or add another trusted entry, then retry."
+        });
+        processContext.exit(1);
+        return;
+      }
+      const target = entries.find((e) => e.id === id);
+      const targetCidr = target?.ipNetwork;
+      if (typeof targetCidr === "string" && targetCidr.length > 0) {
+        const [ipErr, ipResult] = await catchError(fetchCurrentIp(options.loginValidity));
+        if (ipErr || !ipResult || !ipResult.ip) {
+          await emitFailure(ipErr ?? new Error("Failed to determine the caller's IP for the lockout-safety pre-flight."), "Run `uip admin ip-restriction my-ip` to inspect; or run `uip admin ip-restriction enforcement disable` first to skip the safety check.");
+          return;
+        }
+        const callerIp = ipResult.ip;
+        if (ipInCidr(callerIp, targetCidr)) {
+          const otherCovers = entries.filter((e) => e.id !== id).some((e) => typeof e.ipNetwork === "string" && e.ipNetwork.length > 0 ? ipInCidr(callerIp, e.ipNetwork) : false);
+          if (!otherCovers) {
+            OutputFormatter.error({
+              Result: RESULTS.Failure,
+              Message: "You are unable to delete your IP address from the trusted IP range while IP restrictions is enabled.",
+              Instructions: `Run \`uip admin ip-restriction enforcement disable\` first, or add another trusted entry that covers ${callerIp}, then retry.`
+            });
+            processContext.exit(1);
+            return;
+          }
+        }
+      }
+    }
+    const [error, response] = await catchError(client.api._deleteRaw({
+      id,
+      organizationId: client.organizationId
+    }));
+    if (error || !response) {
+      await emitFailure(error ?? new Error("Empty response"), "Check the IP range UUID with 'uip admin ip-restriction ip-ranges list'.");
+      return;
+    }
+    const responseBody = await extractResponseData(response);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsIpRangeDeleted",
+      Data: responseBody ?? {}
+    });
+  });
+};
+
+// ../apms-tool/src/commands/my-ip.ts
+var MY_IP_EXAMPLES = [
+  {
+    Description: "Show the public IP the platform sees for the current caller (handy for filling in `ip-ranges create` and as a sanity check before enforcing IP restrictions).",
+    Command: "uip admin ip-restriction my-ip",
+    Output: {
+      Code: "ApmsMyIpGet",
+      Data: { ipAddress: "<your-public-ip>" }
+    }
+  }
+];
+var registerMyIpCommand = (apms) => {
+  withLoginValidity(apms.command("my-ip").description([
+    "Show the public IP the UiPath platform sees for the current caller.",
+    "",
+    "Useful before running `enforcement enable` to confirm",
+    "your IP is in the trusted ip-ranges allowlist."
+  ].join(`
+`)).examples(MY_IP_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const [err, result] = await catchError(fetchCurrentIp(options.loginValidity));
+    if (err || !result) {
+      await emitFailure(err ?? new Error("Failed to determine current IP"), LOGIN_INSTRUCTIONS);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ApmsMyIpGet",
+      Data: result.body
+    });
+  });
+};
+
+// ../apms-tool/src/commands/apms.ts
+var registerIpRestrictionCommand = (program) => {
+  const ipRestriction = program.command("ip-restriction").description([
+    "Manage UiPath IP-restriction policies (Access Policy Management Service).",
+    "",
+    "Subcommand groups:",
+    "  ip-ranges      — IP range allowlist entries for the organization.",
+    "  enforcement    — Turn IP-range enforcement on/off (the switch).",
+    "  bypass-rules   — URL-pattern exceptions to IP allowlisting.",
+    "  my-ip          — Show the public IP the platform sees for this caller."
+  ].join(`
+`));
+  registerIpRangesCommands(ipRestriction);
+  registerEnforcementCommands(ipRestriction);
+  registerBypassRulesCommands(ipRestriction);
+  registerMyIpCommand(ipRestriction);
+};
+
+// ../apms-tool/src/tool.ts
+var metadata = {
+  name: "apms-tool",
+  version: package_default.version,
+  description: "Manage UiPath IP-restriction policies (Access Policy Management Service).",
+  commandPrefix: "admin"
+};
+var registerCommands = async (program) => {
+  registerIpRestrictionCommand(program);
+};
+export {
+  metadata,
+  registerCommands
+};
+
+//# debugId=046780DE9022A95E64756E2164756E21