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

package/dist/index-f7cp1ap1.js

@@ -0,0 +1,2411 @@
+import {
+  getLoginStatusAsync
+} from "./tool-016jy57n.js";
+import {
+  EXIT_CODES,
+  OutputFormatter,
+  RESULTS,
+  addSdkUserAgentHeader,
+  catchError,
+  extractErrorDetails,
+  extractErrorMessage,
+  getFileSystem,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  isGuid,
+  logger,
+  parseLimit,
+  processContext
+} from "./tool-v13kh7v7.js";
+import"./tool-1yh8g550.js";
+
+// ../audit-sdk/generated/src/runtime.ts
+var BASE_PATH = "https://localhost:7008".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;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+}
+
+class RequiredError extends Error {
+  field;
+  name = "RequiredError";
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+}
+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;
+  }
+}
+// ../audit-sdk/package.json
+var package_default = {
+  name: "@uipath/audit-sdk",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.204.0",
+  description: "SDK for the UiPath Audit Service — query audit event sources, list events, download long-term-store exports, and manage audit exclusion rules.",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/admin/audit-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "audit",
+    "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.0",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../audit-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+
+// ../audit-sdk/generated/src/models/AuditEventStatus.ts
+var AuditEventStatus = {
+  NUMBER_0: 0,
+  NUMBER_1: 1
+};
+function AuditEventStatusFromJSON(json) {
+  return AuditEventStatusFromJSONTyped(json, false);
+}
+function AuditEventStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../audit-sdk/generated/src/models/ClientInfoDto.ts
+function ClientInfoDtoFromJSON(json) {
+  return ClientInfoDtoFromJSONTyped(json, false);
+}
+function ClientInfoDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    ipAddress: json["ipAddress"] == null ? undefined : json["ipAddress"],
+    ipCountry: json["ipCountry"] == null ? undefined : json["ipCountry"]
+  };
+}
+
+// ../audit-sdk/generated/src/models/AuditEventDto.ts
+function AuditEventDtoFromJSON(json) {
+  return AuditEventDtoFromJSONTyped(json, false);
+}
+function AuditEventDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    createdOn: json["createdOn"] == null ? undefined : new Date(json["createdOn"]),
+    organizationId: json["organizationId"] == null ? undefined : json["organizationId"],
+    organizationName: json["organizationName"] == null ? undefined : json["organizationName"],
+    tenantId: json["tenantId"] == null ? undefined : json["tenantId"],
+    tenantName: json["tenantName"] == null ? undefined : json["tenantName"],
+    actorId: json["actorId"] == null ? undefined : json["actorId"],
+    actorName: json["actorName"] == null ? undefined : json["actorName"],
+    actorEmail: json["actorEmail"] == null ? undefined : json["actorEmail"],
+    eventType: json["eventType"] == null ? undefined : json["eventType"],
+    eventSource: json["eventSource"] == null ? undefined : json["eventSource"],
+    eventTarget: json["eventTarget"] == null ? undefined : json["eventTarget"],
+    eventDetails: json["eventDetails"] == null ? undefined : json["eventDetails"],
+    eventSummary: json["eventSummary"] == null ? undefined : json["eventSummary"],
+    status: json["status"] == null ? undefined : AuditEventStatusFromJSON(json["status"]),
+    clientInfo: json["clientInfo"] == null ? undefined : ClientInfoDtoFromJSON(json["clientInfo"])
+  };
+}
+
+// ../audit-sdk/generated/src/models/AuditEventQueryResultDto.ts
+function AuditEventQueryResultDtoFromJSON(json) {
+  return AuditEventQueryResultDtoFromJSONTyped(json, false);
+}
+function AuditEventQueryResultDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    auditEvents: json["auditEvents"] == null ? undefined : json["auditEvents"].map(AuditEventDtoFromJSON),
+    next: json["next"] == null ? undefined : json["next"],
+    previous: json["previous"] == null ? undefined : json["previous"]
+  };
+}
+
+// ../audit-sdk/generated/src/models/AuditEventTypeDto.ts
+function AuditEventTypeDtoFromJSON(json) {
+  return AuditEventTypeDtoFromJSONTyped(json, false);
+}
+function AuditEventTypeDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    name: json["name"] == null ? undefined : json["name"]
+  };
+}
+
+// ../audit-sdk/generated/src/models/AuditEventTargetDto.ts
+function AuditEventTargetDtoFromJSON(json) {
+  return AuditEventTargetDtoFromJSONTyped(json, false);
+}
+function AuditEventTargetDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    name: json["name"] == null ? undefined : json["name"],
+    eventTypes: json["eventTypes"] == null ? undefined : json["eventTypes"].map(AuditEventTypeDtoFromJSON)
+  };
+}
+
+// ../audit-sdk/generated/src/models/AuditEventSourceDto.ts
+function AuditEventSourceDtoFromJSON(json) {
+  return AuditEventSourceDtoFromJSONTyped(json, false);
+}
+function AuditEventSourceDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"] == null ? undefined : json["id"],
+    name: json["name"] == null ? undefined : json["name"],
+    eventTargets: json["eventTargets"] == null ? undefined : json["eventTargets"].map(AuditEventTargetDtoFromJSON)
+  };
+}
+
+// ../audit-sdk/generated/src/models/ExclusionSelectorDto.ts
+function ExclusionSelectorDtoFromJSON(json) {
+  return ExclusionSelectorDtoFromJSONTyped(json, false);
+}
+function ExclusionSelectorDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    type: json["type"] == null ? undefined : json["type"],
+    values: json["values"] == null ? undefined : json["values"]
+  };
+}
+function ExclusionSelectorDtoToJSON(json) {
+  return ExclusionSelectorDtoToJSONTyped(json, false);
+}
+function ExclusionSelectorDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    type: value["type"],
+    values: value["values"]
+  };
+}
+
+// ../audit-sdk/generated/src/models/ExclusionRuleDto.ts
+function ExclusionRuleDtoFromJSON(json) {
+  return ExclusionRuleDtoFromJSONTyped(json, false);
+}
+function ExclusionRuleDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    policyId: json["policyId"] == null ? undefined : json["policyId"],
+    name: json["name"] == null ? undefined : json["name"],
+    enforcement: json["enforcement"] == null ? undefined : json["enforcement"],
+    isActive: json["isActive"] == null ? undefined : json["isActive"],
+    activatedOn: json["activatedOn"] == null ? undefined : new Date(json["activatedOn"]),
+    selectors: json["selectors"] == null ? undefined : json["selectors"].map(ExclusionSelectorDtoFromJSON),
+    createdOn: json["createdOn"] == null ? undefined : new Date(json["createdOn"]),
+    lastModifiedOn: json["lastModifiedOn"] == null ? undefined : new Date(json["lastModifiedOn"])
+  };
+}
+
+// ../audit-sdk/generated/src/models/ExclusionRuleWriteDto.ts
+function ExclusionRuleWriteDtoToJSON(json) {
+  return ExclusionRuleWriteDtoToJSONTyped(json, false);
+}
+function ExclusionRuleWriteDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    name: value["name"],
+    enforcement: value["enforcement"],
+    isActive: value["isActive"],
+    selectors: value["selectors"] == null ? undefined : value["selectors"].map(ExclusionSelectorDtoToJSON)
+  };
+}
+
+// ../audit-sdk/generated/src/apis/EventConfigApi.ts
+class EventConfigApi extends BaseAPI {
+  async eventConfigCreateRuleRequestOpts(requestParameters) {
+    if (requestParameters["exclusionRuleWriteDto"] == null) {
+      throw new RequiredError("exclusionRuleWriteDto", 'Required parameter "exclusionRuleWriteDto" was null or undefined when calling eventConfigCreateRule().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/EventConfig/rules`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: ExclusionRuleWriteDtoToJSON(requestParameters["exclusionRuleWriteDto"])
+    };
+  }
+  async eventConfigCreateRuleRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.eventConfigCreateRuleRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ExclusionRuleDtoFromJSON(jsonValue));
+  }
+  async eventConfigCreateRule(requestParameters, initOverrides) {
+    const response = await this.eventConfigCreateRuleRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async eventConfigDeleteRuleRequestOpts(requestParameters) {
+    if (requestParameters["policyId"] == null) {
+      throw new RequiredError("policyId", 'Required parameter "policyId" was null or undefined when calling eventConfigDeleteRule().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/EventConfig/rules/{policyId}`;
+    urlPath = urlPath.replace(`{${"policyId"}}`, encodeURIComponent(String(requestParameters["policyId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async eventConfigDeleteRuleRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.eventConfigDeleteRuleRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async eventConfigDeleteRule(requestParameters, initOverrides) {
+    await this.eventConfigDeleteRuleRaw(requestParameters, initOverrides);
+  }
+  async eventConfigGetRuleRequestOpts(requestParameters) {
+    if (requestParameters["policyId"] == null) {
+      throw new RequiredError("policyId", 'Required parameter "policyId" was null or undefined when calling eventConfigGetRule().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/EventConfig/rules/{policyId}`;
+    urlPath = urlPath.replace(`{${"policyId"}}`, encodeURIComponent(String(requestParameters["policyId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async eventConfigGetRuleRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.eventConfigGetRuleRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ExclusionRuleDtoFromJSON(jsonValue));
+  }
+  async eventConfigGetRule(requestParameters, initOverrides) {
+    const response = await this.eventConfigGetRuleRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async eventConfigGetRulesRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/EventConfig/rules`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async eventConfigGetRulesRaw(initOverrides) {
+    const requestOptions = await this.eventConfigGetRulesRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(ExclusionRuleDtoFromJSON));
+  }
+  async eventConfigGetRules(initOverrides) {
+    const response = await this.eventConfigGetRulesRaw(initOverrides);
+    return await response.value();
+  }
+  async eventConfigReplaceRuleRequestOpts(requestParameters) {
+    if (requestParameters["policyId"] == null) {
+      throw new RequiredError("policyId", 'Required parameter "policyId" was null or undefined when calling eventConfigReplaceRule().');
+    }
+    if (requestParameters["exclusionRuleWriteDto"] == null) {
+      throw new RequiredError("exclusionRuleWriteDto", 'Required parameter "exclusionRuleWriteDto" was null or undefined when calling eventConfigReplaceRule().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/EventConfig/rules/{policyId}`;
+    urlPath = urlPath.replace(`{${"policyId"}}`, encodeURIComponent(String(requestParameters["policyId"])));
+    return {
+      path: urlPath,
+      method: "PUT",
+      headers: headerParameters,
+      query: queryParameters,
+      body: ExclusionRuleWriteDtoToJSON(requestParameters["exclusionRuleWriteDto"])
+    };
+  }
+  async eventConfigReplaceRuleRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.eventConfigReplaceRuleRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ExclusionRuleDtoFromJSON(jsonValue));
+  }
+  async eventConfigReplaceRule(requestParameters, initOverrides) {
+    const response = await this.eventConfigReplaceRuleRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+
+// ../audit-sdk/generated/src/apis/QueryApi.ts
+class QueryApi extends BaseAPI {
+  async queryDownloadAuditEventsFromLongTermStoreRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["from"] != null) {
+      queryParameters["from"] = requestParameters["from"].toISOString();
+    }
+    if (requestParameters["to"] != null) {
+      queryParameters["to"] = requestParameters["to"].toISOString();
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Query/downloadeventsfromlongtermstore`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async queryDownloadAuditEventsFromLongTermStoreRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.queryDownloadAuditEventsFromLongTermStoreRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async queryDownloadAuditEventsFromLongTermStore(requestParameters = {}, initOverrides) {
+    await this.queryDownloadAuditEventsFromLongTermStoreRaw(requestParameters, initOverrides);
+  }
+  async queryGetAuditEventSourcesRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Query/sources`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async queryGetAuditEventSourcesRaw(initOverrides) {
+    const requestOptions = await this.queryGetAuditEventSourcesRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(AuditEventSourceDtoFromJSON));
+  }
+  async queryGetAuditEventSources(initOverrides) {
+    const response = await this.queryGetAuditEventSourcesRaw(initOverrides);
+    return await response.value();
+  }
+  async queryGetAuditEventsRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["from"] != null) {
+      queryParameters["from"] = requestParameters["from"].toISOString();
+    }
+    if (requestParameters["to"] != null) {
+      queryParameters["to"] = requestParameters["to"].toISOString();
+    }
+    if (requestParameters["source"] != null) {
+      queryParameters["source"] = requestParameters["source"];
+    }
+    if (requestParameters["target"] != null) {
+      queryParameters["target"] = requestParameters["target"];
+    }
+    if (requestParameters["type"] != null) {
+      queryParameters["type"] = requestParameters["type"];
+    }
+    if (requestParameters["userIds"] != null) {
+      queryParameters["userIds"] = requestParameters["userIds"];
+    }
+    if (requestParameters["searchTerm"] != null) {
+      queryParameters["searchTerm"] = requestParameters["searchTerm"];
+    }
+    if (requestParameters["before"] != null) {
+      queryParameters["before"] = requestParameters["before"].toISOString();
+    }
+    if (requestParameters["beforeId"] != null) {
+      queryParameters["beforeId"] = requestParameters["beforeId"];
+    }
+    if (requestParameters["after"] != null) {
+      queryParameters["after"] = requestParameters["after"].toISOString();
+    }
+    if (requestParameters["afterId"] != null) {
+      queryParameters["afterId"] = requestParameters["afterId"];
+    }
+    if (requestParameters["maxCount"] != null) {
+      queryParameters["maxCount"] = requestParameters["maxCount"];
+    }
+    if (requestParameters["status"] != null) {
+      queryParameters["status"] = requestParameters["status"];
+    }
+    if (requestParameters["psu"] != null) {
+      queryParameters["psu"] = requestParameters["psu"];
+    }
+    if (requestParameters["qw"] != null) {
+      queryParameters["qw"] = requestParameters["qw"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Authorization"] = await this.configuration.apiKey("Authorization");
+    }
+    let urlPath = `/api/Query/events`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  async queryGetAuditEventsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.queryGetAuditEventsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => AuditEventQueryResultDtoFromJSON(jsonValue));
+  }
+  async queryGetAuditEvents(requestParameters = {}, initOverrides) {
+    const response = await this.queryGetAuditEventsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+// ../audit-sdk/src/client-factory.ts
+async function createAuditConfig(options) {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options.loginValidity
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    const message = status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.";
+    throw new Error(message);
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  let suffix;
+  if (options.scope === "tenant") {
+    const tenantId = options.tenantId ?? status.tenantId;
+    if (!tenantId) {
+      throw new Error("Tenant ID required for tenant-scoped audit calls. Pass --tenant-id or select a tenant via 'uip login'.");
+    }
+    suffix = `${status.organizationId}/${tenantId}/tenantaudit_`;
+  } else {
+    suffix = `${status.organizationId}/orgaudit_`;
+  }
+  const basePath = `${status.baseUrl}/${suffix}`;
+  const bearerToken = options.s2sToken ?? status.accessToken;
+  return new Configuration({
+    basePath,
+    apiKey: () => `Bearer ${bearerToken}`,
+    headers: addSdkUserAgentHeader(undefined, SDK_USER_AGENT)
+  });
+}
+async function createApiClient(ApiClass, options) {
+  const config = await createAuditConfig(options);
+  return new ApiClass(config);
+}
+// ../audit-sdk/src/exclusion-rules.ts
+class ExclusionRuleLookupError extends Error {
+  reason;
+  candidates;
+  constructor(message, reason, candidates = []) {
+    super(message);
+    this.name = "ExclusionRuleLookupError";
+    this.reason = reason;
+    this.candidates = candidates;
+  }
+}
+function describe(rule) {
+  return `${rule.policyId} (${rule.isActive ? "active" : "inactive"})`;
+}
+async function resolveExclusionRule(api, nameOrId) {
+  const value = nameOrId.trim();
+  if (isGuid(value)) {
+    return { policyId: value };
+  }
+  const rules = await api.eventConfigGetRules() ?? [];
+  const matches = rules.filter((rule) => rule.name === value);
+  const resolved = matches.length > 0 ? matches : rules.filter((rule) => rule.name?.toLowerCase() === value.toLowerCase());
+  if (resolved.length === 1) {
+    const rule = resolved[0];
+    if (rule.policyId) {
+      return { policyId: rule.policyId, rule };
+    }
+    throw new ExclusionRuleLookupError(`The rule named '${value}' was listed without a policy id, so it cannot be addressed.`, "unidentifiable");
+  }
+  if (resolved.length > 1) {
+    const candidates = resolved.map((rule) => rule.policyId).filter((id) => typeof id === "string");
+    throw new ExclusionRuleLookupError(`'${value}' matches ${resolved.length} rules: ${resolved.map(describe).join(", ")}.`, "ambiguous", candidates);
+  }
+  throw new ExclusionRuleLookupError(`No exclusion rule named '${value}' exists in this organization.`, "not-found");
+}
+// ../audit-commands/src/commands/exclusions.ts
+var ENFORCEMENT = "Exclude";
+var ID_DIMENSIONS = [
+  { option: "excludeTenant", flag: "--exclude-tenant", dimension: "Tenant" },
+  { option: "source", flag: "--source", dimension: "EventSource" },
+  { option: "target", flag: "--target", dimension: "EventTarget" },
+  { option: "type", flag: "--type", dimension: "EventType" }
+];
+var STATUS_VALUES = ["Success", "Failure"];
+var SELECTOR_FLAGS = [
+  ...ID_DIMENSIONS.map((d) => d.flag),
+  "--status"
+];
+var GUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
+var WRITE_BODY_KEYS = ["name", "enforcement", "isActive", "selectors"];
+var SELECTOR_KEYS = ["type", "values"];
+var MAX_FILE_LENGTH = 64 * 1024;
+var SAMPLE_ID = "3f6b1d84-9a1e-4c2b-8e71-2f9c5d0a7b13";
+var SAMPLE_NAME = "Mute successful robot logins";
+var SAMPLE_TYPE_ID = "0f54d68a-15fd-427d-a86a-2812bb7fbb28";
+var CODE_INSTRUCTIONS = {
+  RuleNotFound: "Check the name or id with 'uip admin audit org exclusions list'. A rule owned by another organization also reads as not found.",
+  DuplicateRuleName: "Another ACTIVE rule already uses that name. Pick a different --name, or update the existing rule. An inactive rule may keep a name in use.",
+  OverlappingRuleExists: "An active rule already excludes everything this one would — its id is in the message. Delete or narrow that rule, or save this one with --inactive to stage it alongside.",
+  RuleLimitExceeded: "The organization is at its exclusion-rule cap. Delete a rule with 'uip admin audit org exclusions delete <rule>' before adding another.",
+  EmptySelectorsNotAllowed: `Pass at least one of ${SELECTOR_FLAGS.join(" / ")}. A rule that constrains nothing would exclude every event in the organization.`,
+  InvalidSelectorValue: "Selector values are GUIDs, except --status which takes 'Success' or 'Failure'.",
+  UnknownSelectorValue: "No audit metadata defines that id. Discover valid source / target / type ids with 'uip admin audit org sources --output json'.",
+  SelectorValueNotPermitted: "That value cannot be excluded: UiPath's own monitoring events and audit-configuration changes always stay in the trail. Narrow the rule to the events you own.",
+  SelectorLimitExceeded: "Too many selectors, or too many values in one selector. Split the rule into several narrower ones.",
+  RuleModifiedConcurrently: "Another admin changed the rule while this call was in flight. Re-read it with 'exclusions get <rule>' and retry.",
+  InvalidRequest: "The body was rejected before it reached the rule logic — the message names the field. Server-owned fields (policyId, timestamps) may not be sent."
+};
+function fallbackInstructions(verb, message, status) {
+  if (/Not logged in/i.test(message))
+    return "Run 'uip login' and retry.";
+  if (status === 401)
+    return "Token may be missing the 'Audit.Read' scope. Run 'uip logout && uip login' to mint a fresh token.";
+  if (status === 403)
+    return "Reading rules needs audit-read permission; creating, replacing or deleting one needs an Administrators-group membership and a user token — a service-to-service token is refused on writes.";
+  if (verb === "list" || verb === "get")
+    return "Confirm you are logged in against the right organization with 'uip login status'.";
+  if (verb === "delete")
+    return "Check the name or id with 'uip admin audit org exclusions list'.";
+  return `Pass --name plus at least one of ${SELECTOR_FLAGS.join(" / ")}, or --file with an ExclusionRuleWriteDto body.`;
+}
+async function emitFailure(verb, error) {
+  const details = await extractErrorDetails(error);
+  OutputFormatter.error({
+    Result: details.result,
+    ErrorCode: details.errorCode,
+    Retry: details.retry,
+    Message: details.message,
+    Instructions: codeInstructions(details.context?.errorCode) ?? fallbackInstructions(verb, details.message, details.context?.httpStatus),
+    ...details.context ? { Context: details.context } : {}
+  });
+  processContext.exit(EXIT_CODES[details.result] ?? EXIT_CODES.Failure);
+}
+function codeInstructions(code) {
+  if (code === undefined)
+    return;
+  return Object.hasOwn(CODE_INSTRUCTIONS, code) ? CODE_INSTRUCTIONS[code] : undefined;
+}
+var LOOKUP_INSTRUCTIONS = {
+  ambiguous: "A name is unique only among ACTIVE rules, so an inactive rule may share it. Pass the policy id of the one you mean.",
+  unidentifiable: "Nothing can address that rule - not even the id, which the service did not return. Re-read the list with 'uip admin audit org exclusions list'; a rule still listed without a policyId needs fixing server-side.",
+  "not-found": "Check the name with 'uip admin audit org exclusions list', or pass the rule's policy id instead."
+};
+function emitLookupError(verb, error) {
+  const isCallerError = error.reason === "ambiguous";
+  OutputFormatter.error({
+    Result: isCallerError ? RESULTS.ValidationError : RESULTS.Failure,
+    ErrorCode: isCallerError ? "invalid_argument" : "not_found",
+    Retry: "RetryWillNotFix",
+    Message: error.message,
+    Instructions: error.reason === "not-found" ? `${LOOKUP_INSTRUCTIONS["not-found"]} ('${verb}' takes either.)` : LOOKUP_INSTRUCTIONS[error.reason]
+  });
+  processContext.exit(isCallerError ? EXIT_CODES.ValidationError : EXIT_CODES.Failure);
+}
+
+class BodyError extends Error {
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "BodyError";
+    this.instructions = instructions;
+  }
+}
+async function emitBodyFailure(verb, error) {
+  if (!(error instanceof BodyError)) {
+    await emitFailure(verb, error);
+    return;
+  }
+  OutputFormatter.error({
+    Result: RESULTS.ValidationError,
+    Message: error.message,
+    Instructions: error.instructions
+  });
+  processContext.exit(EXIT_CODES.ValidationError);
+}
+var FILE_BODY_INSTRUCTIONS = "A rule body carries only name, enforcement, isActive and selectors. policyId and the timestamps are server-owned and are rejected rather than ignored.";
+var FILE_READ_INSTRUCTIONS = "Check the --file path and that the file holds one JSON object shaped like an ExclusionRuleWriteDto.";
+var ID_INSTRUCTIONS = "Selector ids are GUIDs. Discover source / target / type ids with 'uip admin audit org sources --output json'.";
+function assertIds(label, values) {
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (!GUID_RE.test(trimmed) || trimmed.toLowerCase() === EMPTY_GUID) {
+      throw new BodyError(`${label} expects a GUID, got '${value}'.`, ID_INSTRUCTIONS);
+    }
+  }
+}
+function assertNotGuidShaped(name) {
+  if (isGuid(name)) {
+    throw new BodyError(`'${name}' cannot be used as a rule name: it is shaped like a policy id.`, "Pick a name that is not a bare GUID. 'get', 'update' and 'delete' read a GUID as a policy id, so a rule named like one could not be reached by name — and would shadow whichever rule owns that id.");
+  }
+}
+var STATUS_ALIASES = new Map([
+  ["success", "Success"],
+  ["0", "Success"],
+  ["failure", "Failure"],
+  ["1", "Failure"]
+]);
+var DIMENSION_NAMES = [
+  ...ID_DIMENSIONS.map((dimension) => dimension.dimension),
+  "Status"
+];
+function validateSelector(raw, seen) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new BodyError("Each selector must be a JSON object.", FILE_BODY_INSTRUCTIONS);
+  }
+  const selector = raw;
+  const unknownKeys = Object.keys(selector).filter((key) => !SELECTOR_KEYS.includes(key));
+  if (unknownKeys.length > 0) {
+    throw new BodyError(`Unsupported field(s) in a selector: ${unknownKeys.join(", ")}.`, `A selector carries only ${SELECTOR_KEYS.join(" and ")}: a 'type' naming the dimension and its 'values'.`);
+  }
+  const type = selector.type;
+  if (typeof type !== "string" || !DIMENSION_NAMES.includes(type)) {
+    throw new BodyError(`'${String(type)}' is not an exclusion dimension.`, `A selector's 'type' is one of ${DIMENSION_NAMES.join(", ")}.`);
+  }
+  if (seen.has(type)) {
+    throw new BodyError(`Two selectors constrain '${type}'.`, "A rule constrains each dimension at most once. Put every value for a dimension in that one selector's 'values'.");
+  }
+  seen.add(type);
+  const values = selector.values;
+  if (!Array.isArray(values) || values.length === 0 || values.some((value) => typeof value !== "string")) {
+    throw new BodyError(`The '${type}' selector needs a non-empty 'values' array of strings.`, "A selector names the values it matches; an empty one would constrain nothing on that dimension.");
+  }
+  const label = `selector '${type}'`;
+  if (type === "Status") {
+    return {
+      type,
+      values: values.map((value) => canonicalStatus(value, label))
+    };
+  }
+  assertIds(label, values);
+  return { type, values: values.map((value) => value.trim()) };
+}
+function canonicalStatus(value, label = "--status") {
+  const match = STATUS_ALIASES.get(value.trim().toLowerCase());
+  if (!match) {
+    throw new BodyError(`${label} expects ${STATUS_VALUES.join(" or ")}, got '${value}'.`, "Use --status Success or --status Failure (case-insensitive; 0 and 1 work too, as on `audit <scope> events`). One or the other: a rule that excludes both outcomes constrains nothing on this dimension.");
+  }
+  return match;
+}
+function bodyFromFlags(options) {
+  const name = options.name?.trim();
+  if (!name) {
+    throw new BodyError("--name is required.", `Pass --name "<rule name>". It must be unique among the organization's active rules.`);
+  }
+  assertNotGuidShaped(name);
+  const selectors = [];
+  for (const { option, flag, dimension } of ID_DIMENSIONS) {
+    const values = options[option];
+    if (!values?.length)
+      continue;
+    assertIds(flag, values);
+    selectors.push({
+      type: dimension,
+      values: values.map((v) => v.trim())
+    });
+  }
+  if (options.status !== undefined) {
+    selectors.push({
+      type: "Status",
+      values: [canonicalStatus(options.status)]
+    });
+  }
+  if (selectors.length === 0) {
+    throw new BodyError("A rule must constrain at least one dimension.", CODE_INSTRUCTIONS.EmptySelectorsNotAllowed);
+  }
+  return {
+    name,
+    enforcement: ENFORCEMENT,
+    isActive: options.inactive !== true,
+    selectors
+  };
+}
+function validateWriteBody(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new BodyError("The file must contain a JSON object.", FILE_READ_INSTRUCTIONS);
+  }
+  const body = parsed;
+  const unknown = Object.keys(body).filter((key) => !WRITE_BODY_KEYS.includes(key));
+  if (unknown.length > 0) {
+    throw new BodyError(`Unsupported field(s) in --file: ${unknown.join(", ")}.`, FILE_BODY_INSTRUCTIONS);
+  }
+  if (typeof body.name !== "string" || body.name.trim() === "") {
+    throw new BodyError("The file must set a non-empty 'name'.", "Give the rule a name in the file's 'name' field. It must be unique among the organization's active rules.");
+  }
+  const name = body.name.trim();
+  assertNotGuidShaped(name);
+  if (body.selectors !== undefined && body.selectors !== null && !Array.isArray(body.selectors)) {
+    throw new BodyError("'selectors' must be an array.", FILE_BODY_INSTRUCTIONS);
+  }
+  const seenDimensions = new Set;
+  const selectors = Array.isArray(body.selectors) ? body.selectors.map((selector) => validateSelector(selector, seenDimensions)) : [];
+  if (selectors.length === 0) {
+    throw new BodyError("A rule must constrain at least one dimension.", "Give the file's 'selectors' at least one entry. A rule that constrains nothing would exclude every event in the organization.");
+  }
+  return {
+    ...body,
+    name,
+    selectors,
+    enforcement: body.enforcement ?? ENFORCEMENT,
+    isActive: body.isActive ?? true
+  };
+}
+function tooLarge(amount, unit) {
+  return new BodyError(`--file is ${amount} ${unit}; a rule body may not exceed ${MAX_FILE_LENGTH}.`, "Point --file at a single rule body. The file is one rule, not an export of many.");
+}
+async function bodyFromFile(file) {
+  const fs = getFileSystem();
+  const stats = await fs.stat(file);
+  if (stats && stats.size > MAX_FILE_LENGTH) {
+    throw tooLarge(stats.size, "bytes");
+  }
+  const content = await fs.readFile(file, "utf-8");
+  if (content === null || content === undefined) {
+    throw new BodyError(`File not found: ${file}`, FILE_READ_INSTRUCTIONS);
+  }
+  const raw = String(content);
+  const byteLength = new TextEncoder().encode(raw).length;
+  if (byteLength > MAX_FILE_LENGTH) {
+    throw tooLarge(byteLength, "bytes");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new BodyError(`--file is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, FILE_READ_INSTRUCTIONS);
+  }
+  return validateWriteBody(parsed);
+}
+async function resolveBody(options) {
+  const inlineFlags = [
+    options.name !== undefined && "--name",
+    options.inactive === true && "--inactive",
+    ...ID_DIMENSIONS.map(({ option, flag }) => options[option]?.length && flag),
+    options.status !== undefined && "--status"
+  ].filter((flag) => typeof flag === "string");
+  if (options.file !== undefined) {
+    if (inlineFlags.length > 0) {
+      throw new BodyError(`--file cannot be combined with ${inlineFlags.join(", ")}.`, "Pass either --file with the whole body, or the inline flags — not both. Merging them would leave it ambiguous which input owns a field both set.");
+    }
+    return await bodyFromFile(options.file);
+  }
+  return bodyFromFlags(options);
+}
+async function getApi(options) {
+  return await createApiClient(EventConfigApi, {
+    scope: "org",
+    loginValidity: options.loginValidity
+  });
+}
+var RULE_ARGUMENT = [
+  "<rule>",
+  "Rule name, or its policy id. A name is matched against the organization's rules; an id is used as it stands."
+];
+async function resolveTarget(verb, rule, options) {
+  const [apiError, api] = await catchError(getApi(options));
+  if (apiError || !api) {
+    await emitFailure(verb, apiError);
+    return;
+  }
+  const [lookupError, target] = await catchError(resolveExclusionRule(api, rule));
+  if (lookupError || !target) {
+    if (lookupError instanceof ExclusionRuleLookupError) {
+      emitLookupError(verb, lookupError);
+    } else {
+      await emitFailure(verb, lookupError);
+    }
+    return;
+  }
+  return { api, policyId: target.policyId, resolved: target.rule };
+}
+function withLoginValidity(cmd) {
+  return cmd.option("--login-validity <minutes>", "Override the interactive-login token lifetime for this call. Rarely needed.", (v) => Number.parseInt(v, 10));
+}
+function withWriteOptions(cmd) {
+  return withLoginValidity(cmd.option("--name <name>", "Rule name, unique among the organization's ACTIVE rules. Max 256 characters.").option("--exclude-tenant <guid...>", "Tenant selector: exclude events from these tenants only. Repeatable. Not spelled --tenant-id, which on the read verbs picks the tenant a call runs against rather than the tenants a rule matches. A tenant outside this organization is accepted but matches nothing, so a typo reads as a rule that silently never fires.").option("--source <guid...>", "EventSource selector. Repeatable. Discover ids with `audit org sources`.").option("--target <guid...>", "EventTarget selector. Repeatable. Discover ids with `audit org sources`.").option("--type <guid...>", "EventType selector. Repeatable. Discover ids with `audit org sources`.").option("--status <status>", "Status selector: 'Success' or 'Failure' (case-insensitive). Single-valued, like --status on `audit <scope> events` — a selector holding both statuses matches every event, which is what omitting the flag already does.").option("--inactive", "Save the rule without activating it. Nothing is excluded until it is active, and an inactive rule may reuse an active rule's name or match set.").option("--file <path>", "Path to a JSON file holding the whole rule body (name, enforcement, isActive, selectors). Mutually exclusive with the flags above."));
+}
+var SAMPLE_RULE = {
+  policyId: SAMPLE_ID,
+  name: SAMPLE_NAME,
+  enforcement: ENFORCEMENT,
+  isActive: true,
+  activatedOn: "2026-09-17T09:14:22.000Z",
+  selectors: [
+    { type: "EventType", values: [SAMPLE_TYPE_ID] },
+    { type: "Status", values: ["Success"] }
+  ],
+  createdOn: "2026-09-17T09:14:22.000Z",
+  lastModifiedOn: "2026-09-17T09:14:22.000Z"
+};
+var LIST_EXAMPLES = [
+  {
+    Description: "List the organization's exclusion rules, ordered by name",
+    Command: "uip admin audit org exclusions list",
+    Output: { Code: "AuditOrgExclusionsList", Data: [SAMPLE_RULE] }
+  }
+];
+var GET_EXAMPLES = [
+  {
+    Description: "Read one rule by the name it was given",
+    Command: `uip admin audit org exclusions get "${SAMPLE_NAME}"`,
+    Output: { Code: "AuditOrgExclusionsGet", Data: SAMPLE_RULE }
+  },
+  {
+    Description: "Read it by policy id instead, which skips the name lookup",
+    Command: `uip admin audit org exclusions get ${SAMPLE_ID}`,
+    Output: { Code: "AuditOrgExclusionsGet", Data: SAMPLE_RULE }
+  }
+];
+var CREATE_EXAMPLES = [
+  {
+    Description: "Stop recording successful events of one event type (the two selectors are AND-ed)",
+    Command: `uip admin audit org exclusions create --name "Mute successful robot logins" --type ${SAMPLE_TYPE_ID} --status Success`,
+    Output: { Code: "AuditOrgExclusionsCreated", Data: SAMPLE_RULE }
+  },
+  {
+    Description: "Stage a rule without activating it, so it excludes nothing until it is turned on",
+    Command: `uip admin audit org exclusions create --name "Staged" --source ${SAMPLE_ID} --inactive`,
+    Output: {
+      Code: "AuditOrgExclusionsCreated",
+      Data: { ...SAMPLE_RULE, isActive: false, activatedOn: null }
+    }
+  },
+  {
+    Description: "Create from a JSON body instead of flags",
+    Command: "uip admin audit org exclusions create --file ./rule.json",
+    Output: { Code: "AuditOrgExclusionsCreated", Data: SAMPLE_RULE }
+  }
+];
+var UPDATE_EXAMPLES = [
+  {
+    Description: "Replace a rule in full — every field is resent, and omitted selectors are dropped",
+    Command: `uip admin audit org exclusions update "${SAMPLE_NAME}" --name "${SAMPLE_NAME}" --type ${SAMPLE_TYPE_ID} --status Success`,
+    Output: { Code: "AuditOrgExclusionsUpdated", Data: SAMPLE_RULE }
+  }
+];
+var DELETE_EXAMPLES = [
+  {
+    Description: "Delete a rule, so its events are recorded again from now on",
+    Command: `uip admin audit org exclusions delete "${SAMPLE_NAME}"`,
+    Output: { Code: "AuditOrgExclusionsDeleted", Data: {} }
+  }
+];
+function registerExclusionCommands(org) {
+  const exclusions = org.command("exclusions").description([
+    "Manage the organization's audit exclusion rules — which events the audit trail stops recording.",
+    "",
+    "A rule carries one selector per dimension (Tenant, EventSource, EventTarget, EventType, Status).",
+    "Values inside a selector are OR-ed, and selectors are AND-ed: `--type A --type B --status Success`",
+    "excludes successful events of type A or B. A rule with no selector is refused — it would",
+    "exclude everything.",
+    "",
+    "Exclusion starts when the rule becomes active and is never retroactive: events already in the",
+    "trail stay there, and widening a rule's match set re-stamps that start time. An inactive rule",
+    "excludes nothing, which is how you stage a replacement next to the rule it takes over from.",
+    "",
+    "`get`, `update` and `delete` take the rule's name or its policy id. A name is unique only",
+    "among ACTIVE rules, so if an inactive rule shares one the CLI asks for the id rather than",
+    "guessing which you meant.",
+    "",
+    "Org-scoped only (there is no `audit tenant exclusions`): name the tenants a rule applies to with",
+    "--exclude-tenant. Reading rules needs audit-read permission; every write needs a user token whose",
+    "identity is in the Administrators group.",
+    "",
+    "Two things can never be excluded: UiPath's own monitoring events, and audit-configuration",
+    "changes — including the rules themselves."
+  ].join(`
+`));
+  withLoginValidity(exclusions.command("list").description([
+    "List every exclusion rule in the organization, ordered by name.",
+    "",
+    "The set is capped server-side, so there is no pagination. A rule whose stored",
+    "document cannot be parsed is still listed, with an empty `selectors` array, so",
+    "it can be deleted."
+  ].join(`
+`)).examples(LIST_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => await (await getApi(options)).eventConfigGetRules())());
+    if (error) {
+      await emitFailure("list", error);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "AuditOrgExclusionsList",
+      Data: result ?? []
+    });
+  });
+  withLoginValidity(exclusions.command("get").description("Read one exclusion rule, by name or by policy id.").argument(...RULE_ARGUMENT).examples(GET_EXAMPLES)).trackedAction(processContext, async (rule, options) => {
+    const target = await resolveTarget("get", rule, options);
+    if (!target)
+      return;
+    if (target.resolved) {
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "AuditOrgExclusionsGet",
+        Data: target.resolved
+      });
+      return;
+    }
+    const [error, result] = await catchError(target.api.eventConfigGetRule({ policyId: target.policyId }));
+    if (error) {
+      await emitFailure("get", error);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "AuditOrgExclusionsGet",
+      Data: result
+    });
+  });
+  withWriteOptions(exclusions.command("create").description([
+    "Create an exclusion rule.",
+    "",
+    "The rule is active unless --inactive is passed, and an active rule is refused when",
+    "another active rule already carries the same name or already excludes everything",
+    "this one would."
+  ].join(`
+`)).examples(CREATE_EXAMPLES)).trackedAction(processContext, async (options) => {
+    const [bodyError, body] = await catchError(resolveBody(options));
+    if (bodyError) {
+      await emitBodyFailure("create", bodyError);
+      return;
+    }
+    const [error, result] = await catchError((async () => await (await getApi(options)).eventConfigCreateRule({
+      exclusionRuleWriteDto: body
+    }))());
+    if (error) {
+      await emitFailure("create", error);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "AuditOrgExclusionsCreated",
+      Data: result
+    });
+  });
+  withWriteOptions(exclusions.command("update").description([
+    "Replace an exclusion rule in full.",
+    "",
+    "This is a replacement, not a patch: whatever you leave out is dropped, so resend",
+    "every flag the rule should keep (read it first with `exclusions get`). Renaming a",
+    "rule leaves its exclusion start time alone; changing which events it matches",
+    "re-stamps that time, so the widened rule does not cover events it never matched.",
+    "",
+    "Activation is part of the replacement: without --inactive the rule comes back",
+    "ACTIVE, so editing a rule you deliberately staged inactive starts it excluding",
+    "events. Pass --inactive again to keep it staged.",
+    "",
+    "Pass <rule> before the selector flags. Those flags take a list, so a value",
+    "written after one is read as another of its values."
+  ].join(`
+`)).argument(...RULE_ARGUMENT).examples(UPDATE_EXAMPLES)).trackedAction(processContext, async (rule, options) => {
+    const [bodyError, body] = await catchError(resolveBody(options));
+    if (bodyError) {
+      await emitBodyFailure("update", bodyError);
+      return;
+    }
+    const target = await resolveTarget("update", rule, options);
+    if (!target)
+      return;
+    const [error, result] = await catchError(target.api.eventConfigReplaceRule({
+      policyId: target.policyId,
+      exclusionRuleWriteDto: body
+    }));
+    if (error) {
+      await emitFailure("update", error);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "AuditOrgExclusionsUpdated",
+      Data: result
+    });
+  });
+  withLoginValidity(exclusions.command("delete").description([
+    "Delete an exclusion rule.",
+    "",
+    "Events it was excluding are recorded again from now on. Events suppressed while",
+    "it was active are gone for good — deleting the rule does not bring them back."
+  ].join(`
+`)).argument(...RULE_ARGUMENT).examples(DELETE_EXAMPLES)).trackedAction(processContext, async (rule, options) => {
+    const target = await resolveTarget("delete", rule, options);
+    if (!target)
+      return;
+    const [error] = await catchError(target.api.eventConfigDeleteRule({
+      policyId: target.policyId
+    }));
+    if (error) {
+      await emitFailure("delete", error);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "AuditOrgExclusionsDeleted",
+      Data: {}
+    });
+  });
+}
+
+// ../audit-commands/src/utils/chunked-export.ts
+import { Buffer } from "node:buffer";
+
+// ../../../node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0;i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1;i < 30; ++i) {
+    for (var j = b[i];j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0;i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (;i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1;i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+};
+var flt = new u8(288);
+for (i = 0;i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144;i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256;i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280;i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0;i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {}
+var dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+};
+var z64hs = function(d, b, l, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+  var nf = nsc + nsu + noff;
+  if (z && nf) {
+    for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
+      if (b2(d, b) == 1) {
+        return [
+          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+          nsu ? b8(d, b + 4) : su,
+          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+          1
+        ];
+      }
+    }
+    if (z < 2)
+      err(13);
+  }
+  return [sc, su, off, 0];
+};
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = b4(data, e - 20) == 117853008;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
+
+// ../audit-commands/src/utils/chunked-export.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+function startOfUtcDay(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), 0, 0, 0, 0));
+}
+function endOfUtcDay(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), 23, 59, 59, 999));
+}
+function* dayChunks(from, to) {
+  if (from.getTime() > to.getTime())
+    return;
+  let cursor = startOfUtcDay(from);
+  while (cursor.getTime() <= to.getTime()) {
+    const chunkFrom = cursor.getTime() < from.getTime() ? from : cursor;
+    const dayEnd = endOfUtcDay(cursor);
+    const chunkTo = dayEnd.getTime() > to.getTime() ? to : dayEnd;
+    yield {
+      chunkFrom,
+      chunkTo,
+      isoDay: cursor.toISOString().slice(0, 10)
+    };
+    cursor = new Date(cursor.getTime() + DAY_MS);
+  }
+}
+function basenameNoExt(name) {
+  const last = name.split(/[\\/]/).pop() ?? name;
+  return last.replace(/\.[^.]+$/, "");
+}
+function basename(name) {
+  return name.split(/[\\/]/).pop() ?? name;
+}
+async function forEachExportEntry(api, from, to, onEntry) {
+  const chunks = [...dayChunks(from, to)];
+  if (chunks.length === 0) {
+    throw new Error(`Empty time window: --from (${from.toISOString()}) is after --to (${to.toISOString()}).`);
+  }
+  let nonEmptyDays = 0;
+  for (const { chunkFrom, chunkTo, isoDay } of chunks) {
+    let response;
+    try {
+      response = await api.queryDownloadAuditEventsFromLongTermStoreRaw({
+        from: chunkFrom,
+        to: chunkTo
+      });
+    } catch (err2) {
+      if (err2 instanceof ResponseError) {
+        const body = await err2.response.text().catch(() => "");
+        throw new Error(`Audit export failed for ${isoDay} (HTTP ${err2.response.status}): ${body.slice(0, 500)}`);
+      }
+      throw new Error(`Audit export failed for ${isoDay}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+    const dayBuffer = Buffer.from(await response.raw.arrayBuffer());
+    if (dayBuffer.byteLength === 0)
+      continue;
+    let dayHadEntries = false;
+    for (const [entryName, entryData] of Object.entries(unzipSync(new Uint8Array(dayBuffer)))) {
+      if (entryName.endsWith("/"))
+        continue;
+      if (/\.zip$/i.test(entryName)) {
+        const outerBase = basenameNoExt(entryName);
+        for (const [innerName, innerData] of Object.entries(unzipSync(entryData))) {
+          if (innerName.endsWith("/"))
+            continue;
+          const innerBase = basenameNoExt(innerName);
+          onEntry({
+            isoDay,
+            preferredName: `${innerBase}_${outerBase}.txt`,
+            data: Buffer.from(innerData)
+          });
+          dayHadEntries = true;
+        }
+      } else {
+        onEntry({
+          isoDay,
+          preferredName: basename(entryName),
+          data: Buffer.from(entryData)
+        });
+        dayHadEntries = true;
+      }
+    }
+    if (dayHadEntries)
+      nonEmptyDays += 1;
+  }
+  return { days: chunks.length, nonEmptyDays };
+}
+function exportBaseName(from, to, generatedAt) {
+  const day = (d) => d.toISOString().slice(0, 10);
+  const stamp = generatedAt.toISOString().slice(0, 19).replace(/[-:]/g, "");
+  return `audit_${day(from)}_${day(to)}_${stamp}`;
+}
+function toJsonFileName(preferredName) {
+  return `${basenameNoExt(preferredName)}.json`;
+}
+function isSafeExportEntryName(name) {
+  return name.length > 0 && name !== "." && name !== ".." && !name.includes("/") && !name.includes("\\") && !name.includes("\x00");
+}
+function isWithinDir(dir, resolved) {
+  let end = dir.length;
+  while (end > 0 && (dir[end - 1] === "/" || dir[end - 1] === "\\")) {
+    end -= 1;
+  }
+  const base = dir.slice(0, end);
+  return resolved === base || resolved.startsWith(`${base}/`) || resolved.startsWith(`${base}\\`);
+}
+async function downloadChunkedJsonExport(api, from, to) {
+  const files = [];
+  const used = new Set;
+  function addUnique(preferredName, isoDay, data) {
+    let name = preferredName;
+    if (used.has(name)) {
+      const stem = basenameNoExt(preferredName);
+      const ext = preferredName.slice(stem.length);
+      name = `${stem}_${isoDay}${ext}`;
+      let n = 2;
+      while (used.has(name)) {
+        name = `${stem}_${isoDay}_${n}${ext}`;
+        n += 1;
+      }
+    }
+    used.add(name);
+    files.push({ name, data });
+  }
+  const { days, nonEmptyDays } = await forEachExportEntry(api, from, to, ({ isoDay, preferredName, data }) => addUnique(toJsonFileName(preferredName), isoDay, data));
+  return { files, days, nonEmptyDays };
+}
+var PREFERRED_CSV_COLUMNS = [
+  "Identifier",
+  "DateCreatedUtc",
+  "OrganizationId",
+  "OrganizationName",
+  "TenantId",
+  "TenantName",
+  "ActorId",
+  "User",
+  "ActorEmail",
+  "ActorDetails",
+  "Action",
+  "Source",
+  "Category",
+  "EventDetails",
+  "EventSummary",
+  "Status",
+  "ClientInformation"
+];
+function parseDailyEvents(data, isoDay, fileName) {
+  let text = data.toString("utf8");
+  if (text.charCodeAt(0) === 65279)
+    text = text.slice(1);
+  text = text.trim();
+  if (text.length === 0)
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err2) {
+    throw new Error(`Audit export for ${isoDay} returned a file (${fileName}) that is not valid JSON: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  }
+  if (Array.isArray(parsed))
+    return parsed;
+  if (parsed && typeof parsed === "object")
+    return [parsed];
+  throw new Error(`Audit export for ${isoDay} file ${fileName} did not contain a JSON array of events.`);
+}
+function deriveCsvColumns(events) {
+  const seen = new Set;
+  for (const ev of events) {
+    for (const key of Object.keys(ev))
+      seen.add(key);
+  }
+  if (seen.size === 0)
+    return [...PREFERRED_CSV_COLUMNS];
+  const ordered = [];
+  for (const col of PREFERRED_CSV_COLUMNS) {
+    if (seen.delete(col))
+      ordered.push(col);
+  }
+  for (const col of seen)
+    ordered.push(col);
+  return ordered;
+}
+function csvField(value) {
+  if (value === null || value === undefined)
+    return "";
+  let s = typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (typeof value === "string" && /^[=+\-@\t\r]/.test(s)) {
+    s = `'${s}`;
+  }
+  return /["\r\n,]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function eventsToCsv(events) {
+  const columns = deriveCsvColumns(events);
+  const rows = [columns.map(csvField).join(",")];
+  for (const ev of events) {
+    rows.push(columns.map((col) => csvField(ev[col])).join(","));
+  }
+  return `${rows.join(`\r
+`)}\r
+`;
+}
+async function downloadChunkedCsvExport(api, from, to) {
+  const events = [];
+  const { days, nonEmptyDays } = await forEachExportEntry(api, from, to, ({ isoDay, preferredName, data }) => {
+    events.push(...parseDailyEvents(data, isoDay, preferredName));
+  });
+  const csv = eventsToCsv(events);
+  return {
+    buffer: Buffer.from(csv, "utf8"),
+    days,
+    nonEmptyDays,
+    eventCount: events.length
+  };
+}
+
+// ../audit-commands/src/commands/shared.ts
+var SERVER_MAX_PAGE = 200;
+function instructionsFor(verb, error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  if (/Not logged in/i.test(msg))
+    return "Run 'uip login' and retry.";
+  if (/Tenant ID required/i.test(msg))
+    return "Pass --tenant-id <guid>, or run 'uip login' and select a tenant before retrying.";
+  if (/HTTP 401/.test(msg))
+    return "Token may be missing the 'Audit.Read' scope. Run 'uip logout && uip login' to mint a fresh token.";
+  if (/HTTP 403/.test(msg))
+    return "Logged-in user lacks audit-read permission on this tenant. Check role assignments in Automation Cloud.";
+  if (/HTTP 504/.test(msg) || /Audit export failed for \d{4}-\d{2}-\d{2}/.test(msg))
+    return "A single day's chunk timed out. Re-run; the export is idempotent. If it persists, narrow --from-date/--to-date to skip the failing day.";
+  if (/Empty time window/i.test(msg) || /Invalid Date/.test(msg))
+    return "Verify --from-date and --to-date are valid ISO 8601 (e.g. '2026-01-01' or '2026-01-01T14:30:00Z').";
+  if (/Invalid --status/.test(msg))
+    return "Use --status Success or --status Failure (case-insensitive).";
+  if (/Invalid --file-format/.test(msg))
+    return "Use --file-format json (default) or --file-format csv.";
+  if (/unsafe name|outside the output folder/i.test(msg))
+    return "The export contained a file whose name would escape --output-path. This indicates a malformed server response — re-run, and report it if it persists.";
+  if (verb === "sources")
+    return "Confirm scope (org vs tenant) matches your intent and that you are logged in.";
+  if (verb === "events")
+    return "Discover GUIDs via 'audit <scope> sources --output json' before passing --source/--target/--type. Verify --from-date/--to-date are ISO 8601.";
+  return "Verify --from-date/--to-date are ISO 8601 and the --output-path directory is writable. Single-day chunk failures are transient — re-run.";
+}
+function registerScopeCommands(parent, opts) {
+  registerSources(parent, opts);
+  registerEvents(parent, opts);
+  registerExport(parent, opts);
+}
+function sourcesExamples({
+  scope,
+  codeSuffix
+}) {
+  return [
+    {
+      Description: `List audit event sources visible at the ${scope} scope`,
+      Command: `uip admin audit ${scope} sources`,
+      Output: {
+        Code: `Audit${codeSuffix}Sources`,
+        Data: [
+          {
+            id: "11111111-1111-1111-1111-111111111111",
+            name: "Identity",
+            eventTargets: []
+          }
+        ]
+      }
+    }
+  ];
+}
+function registerSources(parent, opts) {
+  const { scope, codeSuffix } = opts;
+  const cmd = parent.command("sources").description([
+    `List audit event sources visible at the ${scope} scope.`,
+    "",
+    "Each source is a top-level event category (e.g. Identity, Tenant, Robot).",
+    "Use the returned `id` values with `events --source <guid>` to filter."
+  ].join(`
+`)).option("--login-validity <minutes>", "Override the interactive-login token lifetime for this call. Rarely needed.", (v) => Number.parseInt(v, 10));
+  if (scope === "tenant") {
+    cmd.option("--tenant-id <guid>", "Override the tenant ID from login context.");
+  }
+  cmd.examples(sourcesExamples(opts)).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => {
+      const api = await createApiClient(QueryApi, {
+        scope,
+        tenantId: options.tenantId,
+        loginValidity: options.loginValidity
+      });
+      return await api.queryGetAuditEventSources();
+    })());
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: await extractErrorMessage(error),
+        Instructions: instructionsFor("sources", error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: `Audit${codeSuffix}Sources`,
+      Data: result ?? []
+    });
+  });
+}
+function parseStatus(raw) {
+  if (raw === undefined)
+    return;
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "success" || normalized === "0")
+    return AuditEventStatus.NUMBER_0;
+  if (normalized === "failure" || normalized === "1")
+    return AuditEventStatus.NUMBER_1;
+  throw new Error(`Invalid --status '${raw}'. Use 'Success' or 'Failure'.`);
+}
+function cursorToArgs(cursor) {
+  const url = new URL(cursor, "https://placeholder.invalid");
+  const out = {};
+  const before = url.searchParams.get("before");
+  const beforeId = url.searchParams.get("beforeId");
+  const after = url.searchParams.get("after");
+  const afterId = url.searchParams.get("afterId");
+  if (before)
+    out.before = new Date(before);
+  if (beforeId)
+    out.beforeId = beforeId;
+  if (after)
+    out.after = new Date(after);
+  if (afterId)
+    out.afterId = afterId;
+  return out;
+}
+async function paginateEvents(api, baseArgs, limit) {
+  const collected = [];
+  let cursor;
+  let lastPrevious = null;
+  let lastNext = null;
+  while (collected.length < limit) {
+    const remaining = limit - collected.length;
+    const args = {
+      ...baseArgs,
+      maxCount: Math.min(remaining, SERVER_MAX_PAGE),
+      ...cursor ? cursorToArgs(cursor) : {}
+    };
+    const result = await api.queryGetAuditEvents(args);
+    const batch = result.auditEvents ?? [];
+    collected.push(...batch);
+    lastPrevious = result.previous ?? null;
+    lastNext = result.next ?? null;
+    const nextCursor = lastPrevious ?? lastNext;
+    if (!nextCursor || batch.length === 0)
+      break;
+    cursor = nextCursor;
+  }
+  return {
+    auditEvents: collected.slice(0, limit),
+    next: lastNext,
+    previous: lastPrevious
+  };
+}
+function eventsExamples({
+  scope,
+  codeSuffix
+}) {
+  return [
+    {
+      Description: `Fetch the latest 50 ${scope} audit events`,
+      Command: `uip admin audit ${scope} events --limit 50`,
+      Output: {
+        Code: `Audit${codeSuffix}Events`,
+        Data: {
+          auditEvents: [],
+          next: null,
+          previous: null
+        }
+      }
+    },
+    {
+      Description: `Filter by source and a 7-day window`,
+      Command: `uip admin audit ${scope} events --source 11111111-1111-1111-1111-111111111111 --from-date 2026-04-22T00:00:00Z --to-date 2026-04-29T00:00:00Z`,
+      Output: {
+        Code: `Audit${codeSuffix}Events`,
+        Data: {
+          auditEvents: [],
+          next: null,
+          previous: null
+        }
+      }
+    }
+  ];
+}
+function registerEvents(parent, opts) {
+  const { scope, codeSuffix } = opts;
+  const cmd = parent.command("events").description([
+    `Query audit events at the ${scope} scope.`,
+    "",
+    "Returns `{ auditEvents, next, previous }` — NOT a bare array. Pagination cursors live alongside the rows.",
+    "Cursor naming is chronological: `next` = newer events, `previous` = older events.",
+    "When --limit > 200 the tool paginates internally by following `previous` (server clamps each call to 200)."
+  ].join(`
+`)).option("--from-date <iso>", "Start of time interval (ISO 8601). Inclusive.").option("--to-date <iso>", "End of time interval (ISO 8601). Inclusive.").option("--source <guid...>", "Filter by event source IDs. Repeatable. Use `sources` to discover IDs.").option("--target <guid...>", "Filter by event target IDs. Repeatable.").option("--type <guid...>", "Filter by event type IDs. Repeatable.").option("--user-id <guid...>", "Filter by acting user IDs. Repeatable.").option("--search <term>", "Server-side substring search.").option("--status <status>", "Event status filter: 'Success' or 'Failure' (case-insensitive).").option("--limit <n>", "Total number of events to return. The server clamps each individual call to 200; values >200 are paginated client-side. Must be a positive integer between 1 and 10000.", parseLimit).option("--login-validity <minutes>", "Override the interactive-login token lifetime for this call. Rarely needed.", (v) => Number.parseInt(v, 10));
+  if (scope === "tenant") {
+    cmd.option("--tenant-id <guid>", "Override the tenant ID from login context.");
+  }
+  cmd.examples(eventsExamples(opts)).trackedAction(processContext, async (options) => {
+    const [error, result] = await catchError((async () => {
+      const status = parseStatus(options.status);
+      const api = await createApiClient(QueryApi, {
+        scope,
+        tenantId: options.tenantId,
+        loginValidity: options.loginValidity
+      });
+      const baseArgs = {
+        from: options.fromDate ? new Date(options.fromDate) : undefined,
+        to: options.toDate ? new Date(options.toDate) : undefined,
+        source: options.source,
+        target: options.target,
+        type: options.type,
+        userIds: options.userId,
+        searchTerm: options.search,
+        status
+      };
+      const limit = options.limit;
+      if (limit !== undefined && limit > SERVER_MAX_PAGE) {
+        return await paginateEvents(api, baseArgs, limit);
+      }
+      const single = await api.queryGetAuditEvents({
+        ...baseArgs,
+        maxCount: limit
+      });
+      return {
+        auditEvents: single.auditEvents ?? [],
+        next: single.next ?? null,
+        previous: single.previous ?? null
+      };
+    })());
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: await extractErrorMessage(error),
+        Instructions: instructionsFor("events", error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: `Audit${codeSuffix}Events`,
+      Data: result
+    });
+  });
+}
+function parseFormat(raw) {
+  const normalized = (raw ?? "json").trim().toLowerCase();
+  if (normalized === "json" || normalized === "csv")
+    return normalized;
+  throw new Error(`Invalid --file-format '${raw}'. Use 'json' or 'csv'.`);
+}
+function exportExamples({
+  scope,
+  codeSuffix
+}) {
+  return [
+    {
+      Description: `Export ${scope} audit events for January 2026 — a timestamped folder of day-wise JSON files is created under the base dir`,
+      Command: `uip admin audit ${scope} export --from-date 2026-01-01 --to-date 2026-02-01 --output-path ./audit-exports`,
+      Output: {
+        Code: `Audit${codeSuffix}Export`,
+        Data: {
+          Path: `./audit-exports/audit_2026-01-01_2026-02-01_20260617T112630`,
+          Format: "json",
+          Files: 27,
+          Bytes: 12345,
+          Days: 31,
+          NonEmptyDays: 27,
+          GeneratedAt: "2026-06-17T11:26:30.000Z"
+        }
+      }
+    },
+    {
+      Description: `Export the same window into a single merged CSV (a uniquely-named .csv under the base dir) instead of a folder`,
+      Command: `uip admin audit ${scope} export --from-date 2026-01-01 --to-date 2026-02-01 --file-format csv --output-path ./audit-exports`,
+      Output: {
+        Code: `Audit${codeSuffix}Export`,
+        Data: {
+          Path: `./audit-exports/audit_2026-01-01_2026-02-01_20260617T112630.csv`,
+          Format: "csv",
+          Bytes: 98765,
+          Days: 31,
+          NonEmptyDays: 27,
+          Events: 1234,
+          GeneratedAt: "2026-06-17T11:26:30.000Z"
+        }
+      }
+    }
+  ];
+}
+function registerExport(parent, opts) {
+  const { scope, codeSuffix } = opts;
+  const cmd = parent.command("export").description([
+    `Export audit events from the long-term store at the ${scope} scope.`,
+    "",
+    "Issues one HTTP call per UTC day inside [--from-date, --to-date] and aggregates the daily",
+    "responses in memory before writing them out. The full window is fetched first: on any chunk",
+    "failure the export is aborted atomically — nothing is written, and the structured Failure",
+    "result identifies the day that failed.",
+    "",
+    "--output-path is a base DIRECTORY, not a file path — pass a folder and the CLI",
+    "generates the per-export name for you (you do NOT supply a filename). Each run creates",
+    "a uniquely-named output inside it, stamped with the window + generation time",
+    "(e.g. audit_2026-01-01_2026-02-01_20260617T112630), so repeated exports of the same",
+    "window never collide. --file-format controls the shape:",
+    "  json (default) — a folder of one JSON file per UTC day.",
+    "  csv            — a single CSV file with every event merged under a shared header."
+  ].join(`
+`)).option("--output-path <dir>", "Base directory for the export (created if missing). Pass a directory only — do NOT include a filename or extension; the CLI generates the per-export name. A uniquely-named output is created inside it — a folder of day-wise JSON files ('json') or a single '.csv' file ('csv'), named audit_<from>_<to>_<generated-at> (to the second) so repeated exports don't collide.").option("--output-file <dir>", "Deprecated alias for --output-path (kept for backward compatibility). Despite the name it is treated as a base DIRECTORY, not a file path. Prefer --output-path.").requiredOption("--from-date <iso>", "Start of time interval (ISO 8601). Required.").requiredOption("--to-date <iso>", "End of time interval (ISO 8601). Required.").option("--file-format <format>", "Output format: 'json' (default — day-wise JSON files written into the --output-path folder) or 'csv' (a single merged CSV of every event).", "json").option("--login-validity <minutes>", "Override the interactive-login token lifetime for this call. Rarely needed.", (v) => Number.parseInt(v, 10));
+  if (scope === "tenant") {
+    cmd.option("--tenant-id <guid>", "Override the tenant ID from login context.");
+  }
+  cmd.examples(exportExamples(opts)).trackedAction(processContext, async (options) => {
+    const [error, summary] = await catchError((async () => {
+      const format = parseFormat(options.fileFormat);
+      const outputPath = options.outputPath ?? options.outputFile;
+      if (outputPath === undefined) {
+        throw new Error("Missing required option '--output-path <dir>'.");
+      }
+      if (options.outputFile !== undefined) {
+        logger.warn(options.outputPath !== undefined ? "--output-file is deprecated and ignored when --output-path is also provided; using --output-path." : "--output-file is deprecated; use --output-path instead. It is treated as a base directory.");
+      }
+      const api = await createApiClient(QueryApi, {
+        scope,
+        tenantId: options.tenantId,
+        loginValidity: options.loginValidity
+      });
+      const from = new Date(options.fromDate);
+      const to = new Date(options.toDate);
+      const fs = getFileSystem();
+      const generatedAt = new Date;
+      const baseDir = fs.path.resolve(outputPath);
+      const baseName = exportBaseName(from, to, generatedAt);
+      if (format === "csv") {
+        const result2 = await downloadChunkedCsvExport(api, from, to);
+        await fs.mkdir(baseDir);
+        const target = fs.path.join(baseDir, `${baseName}.csv`);
+        await fs.writeFile(target, result2.buffer);
+        return {
+          Path: target,
+          Format: "csv",
+          Bytes: result2.buffer.byteLength,
+          Days: result2.days,
+          NonEmptyDays: result2.nonEmptyDays,
+          Events: result2.eventCount,
+          GeneratedAt: generatedAt.toISOString()
+        };
+      }
+      const result = await downloadChunkedJsonExport(api, from, to);
+      const outDir = fs.path.join(baseDir, baseName);
+      const targets = result.files.map((file) => {
+        if (!isSafeExportEntryName(file.name)) {
+          throw new Error(`Export contained a file with an unsafe name '${file.name}'.`);
+        }
+        const target = fs.path.join(outDir, file.name);
+        if (!isWithinDir(outDir, fs.path.resolve(target))) {
+          throw new Error(`Export file '${file.name}' resolves outside the output folder.`);
+        }
+        return { target, data: file.data };
+      });
+      await fs.mkdir(outDir);
+      let bytes = 0;
+      for (const { target, data } of targets) {
+        await fs.writeFile(target, data);
+        bytes += data.byteLength;
+      }
+      return {
+        Path: outDir,
+        Format: "json",
+        Files: result.files.length,
+        Bytes: bytes,
+        Days: result.days,
+        NonEmptyDays: result.nonEmptyDays,
+        GeneratedAt: generatedAt.toISOString()
+      };
+    })());
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: await extractErrorMessage(error),
+        Instructions: instructionsFor("export", error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: `Audit${codeSuffix}Export`,
+      Data: summary
+    });
+  });
+}
+
+// ../audit-commands/src/commands/audit.ts
+var registerAuditCommand = (program) => {
+  const audit = program.command("audit").description([
+    "Query and export UiPath audit events, and configure which events are recorded.",
+    "",
+    "Subject subgroups:",
+    "  org    — organization-scoped audit (admin events that are tenant-agnostic).",
+    "  tenant — tenant-scoped audit (events scoped to the active or --tenant-id-overridden tenant).",
+    "",
+    "Read verbs (the same three under each subject):",
+    "  sources — list event sources/targets/types visible at this scope.",
+    "  events  — paginated query of audit events with cursor and filters.",
+    "  export  — chunked download from the long-term store as a ZIP of day-wise files or a single merged CSV (requires --from-date / --to-date).",
+    "",
+    "Configuration (org only):",
+    "  exclusions — CRUD over the exclusion rules that stop matching events being recorded at all.",
+    "",
+    "Typical workflow: `audit <scope> sources` (discover IDs) → `audit <scope> events --source <guid>",
+    "--from-date … --to-date …` (find the rows) → `audit <scope> export --from-date … --to-date … --output-path …`."
+  ].join(`
+`));
+  const org = audit.command("org").description("Organization-scoped audit operations.");
+  registerScopeCommands(org, { scope: "org", codeSuffix: "Org" });
+  registerExclusionCommands(org);
+  const tenant = audit.command("tenant").description("Tenant-scoped audit operations.");
+  registerScopeCommands(tenant, { scope: "tenant", codeSuffix: "Tenant" });
+};
+
+// ../audit-commands/src/index.ts
+var registerCommands = async (program) => {
+  registerAuditCommand(program);
+};
+export {
+  registerCommands
+};
+
+//# debugId=FA243E6A665F869364756E2164756E21