@cdot65/prisma-airs-sdk 0.2.0 → 0.4.0

package/dist/index.js

@@ -23,7 +23,7 @@ var MAX_NUMBER_OF_BATCH_SCAN_OBJECTS = 5;
 var MAX_CONNECTION_POOL_SIZE = 100;
 var MAX_NUMBER_OF_RETRIES = 5;
 var HTTP_FORCE_RETRY_STATUS_CODES = [500, 502, 503, 504];
-var SDK_VERSION = "0.1.2";
+var SDK_VERSION = "0.4.0";
 var USER_AGENT = `PAN-AIRS/${SDK_VERSION}-typescript-sdk`;
 var DEFAULT_MGMT_ENDPOINT = "https://api.sase.paloaltonetworks.com/aisec";
 var DEFAULT_TOKEN_ENDPOINT = "https://auth.apps.paloaltonetworks.com/oauth2/access_token";
@@ -41,6 +41,41 @@ var MGMT_PROFILES_TSG_PATH = "/v1/mgmt/profiles/tsg";
 var MGMT_TOPIC_PATH = "/v1/mgmt/topic";
 var MGMT_TOPICS_TSG_PATH = "/v1/mgmt/topics/tsg";
 var MGMT_TOPIC_FORCE_PATH = "/v1/mgmt/topic/force";
+var DEFAULT_MODEL_SEC_DATA_ENDPOINT = "https://api.sase.paloaltonetworks.com/aims/data";
+var DEFAULT_MODEL_SEC_MGMT_ENDPOINT = "https://api.sase.paloaltonetworks.com/aims/mgmt";
+var MODEL_SEC_CLIENT_ID = "PANW_MODEL_SEC_CLIENT_ID";
+var MODEL_SEC_CLIENT_SECRET = "PANW_MODEL_SEC_CLIENT_SECRET";
+var MODEL_SEC_TSG_ID = "PANW_MODEL_SEC_TSG_ID";
+var MODEL_SEC_DATA_ENDPOINT = "PANW_MODEL_SEC_DATA_ENDPOINT";
+var MODEL_SEC_MGMT_ENDPOINT = "PANW_MODEL_SEC_MGMT_ENDPOINT";
+var MODEL_SEC_TOKEN_ENDPOINT = "PANW_MODEL_SEC_TOKEN_ENDPOINT";
+var MODEL_SEC_SCANS_PATH = "/v1/scans";
+var MODEL_SEC_EVALUATIONS_PATH = "/v1/evaluations";
+var MODEL_SEC_VIOLATIONS_PATH = "/v1/violations";
+var MODEL_SEC_SECURITY_GROUPS_PATH = "/v1/security-groups";
+var MODEL_SEC_SECURITY_RULES_PATH = "/v1/security-rules";
+var MODEL_SEC_PYPI_AUTH_PATH = "/v1/pypi/authenticate";
+var DEFAULT_RED_TEAM_DATA_ENDPOINT = "https://api.sase.paloaltonetworks.com/ai-red-teaming/data-plane";
+var DEFAULT_RED_TEAM_MGMT_ENDPOINT = "https://api.sase.paloaltonetworks.com/ai-red-teaming/mgmt-plane";
+var RED_TEAM_CLIENT_ID = "PANW_RED_TEAM_CLIENT_ID";
+var RED_TEAM_CLIENT_SECRET = "PANW_RED_TEAM_CLIENT_SECRET";
+var RED_TEAM_TSG_ID = "PANW_RED_TEAM_TSG_ID";
+var RED_TEAM_DATA_ENDPOINT = "PANW_RED_TEAM_DATA_ENDPOINT";
+var RED_TEAM_MGMT_ENDPOINT = "PANW_RED_TEAM_MGMT_ENDPOINT";
+var RED_TEAM_TOKEN_ENDPOINT = "PANW_RED_TEAM_TOKEN_ENDPOINT";
+var RED_TEAM_SCAN_PATH = "/v1/scan";
+var RED_TEAM_CATEGORIES_PATH = "/v1/categories";
+var RED_TEAM_REPORT_STATIC_PATH = "/v1/report/static";
+var RED_TEAM_REPORT_DYNAMIC_PATH = "/v1/report/dynamic";
+var RED_TEAM_REPORT_PATH = "/v1/report";
+var RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH = "/v1/custom-attacks";
+var RED_TEAM_DASHBOARD_PATH = "/v1/dashboard";
+var RED_TEAM_QUOTA_PATH = "/v1/metering/quota";
+var RED_TEAM_ERROR_LOG_PATH = "/v1/error-log/job";
+var RED_TEAM_SENTIMENT_PATH = "/v1/sentiment";
+var RED_TEAM_TARGET_PATH = "/v1/target";
+var RED_TEAM_CUSTOM_ATTACK_PATH = "/v1/custom-attack";
+var RED_TEAM_MGMT_DASHBOARD_PATH = "/v1/dashboard/overview";
 
 // src/errors.ts
 var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
@@ -54,6 +89,10 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
 })(ErrorType || {});
 var AISecSDKException = class _AISecSDKException extends Error {
   errorType;
+  /**
+   * @param message - Human-readable error description.
+   * @param errorType - Classification of the error.
+   */
   constructor(message, errorType) {
     super(errorType ? `${errorType}:${message}` : message);
     this.name = "AISecSDKException";
@@ -135,6 +174,68 @@ function init(opts = {}) {
   globalConfiguration.init(opts);
 }
 
+// src/http-retry.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelay(attempt) {
+  return Math.pow(2, attempt) * 1e3;
+}
+function isRetryableStatus(status) {
+  return HTTP_FORCE_RETRY_STATUS_CODES.includes(status);
+}
+function classifyErrorType(status) {
+  return status >= 500 ? "AISEC_SERVER_SIDE_ERROR" /* SERVER_SIDE_ERROR */ : "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */;
+}
+function extractErrorMessage(body, status) {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.error_message ?? parsed.message ?? parsed.error?.message ?? `API error ${status}`;
+  } catch {
+    return body ? `API error ${status}: ${body}` : `API error ${status}`;
+  }
+}
+async function executeWithRetry(opts) {
+  const { maxRetries, execute, onRetryableFailure } = opts;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    let response;
+    try {
+      response = await execute(attempt);
+    } catch (err) {
+      if (err instanceof AISecSDKException) throw err;
+      lastError = err;
+      if (attempt < maxRetries) {
+        await sleep(backoffDelay(attempt));
+        continue;
+      }
+      throw new AISecSDKException(
+        lastError.message ?? "Network error",
+        "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */
+      );
+    }
+    if (response.ok) return response;
+    if (onRetryableFailure) {
+      const handled = await onRetryableFailure(response, attempt);
+      if (handled) {
+        attempt--;
+        continue;
+      }
+    }
+    if (isRetryableStatus(response.status) && attempt < maxRetries) {
+      await sleep(backoffDelay(attempt));
+      continue;
+    }
+    const errorText = await response.text();
+    const errorMessage = extractErrorMessage(errorText, response.status);
+    throw new AISecSDKException(errorMessage, classifyErrorType(response.status));
+  }
+  throw new AISecSDKException(
+    lastError?.message ?? "Max retries exceeded",
+    "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */
+  );
+}
+
 // src/utils.ts
 import { createHmac } from "crypto";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -160,9 +261,6 @@ function buildHeaders() {
   }
   return headers;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 async function httpRequest(opts) {
   if (!globalConfiguration.initialized) {
     throw new AISecSDKException(
@@ -185,48 +283,27 @@ async function httpRequest(opts) {
       headers[PAYLOAD_HASH] = generatePayloadHash(bodyStr, globalConfiguration.apiKey);
     }
   }
-  const maxRetries = globalConfiguration.numRetries;
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const response = await fetch(url.toString(), {
-        method: opts.method,
-        headers,
-        body: bodyStr
-      });
-      if (response.ok) {
-        const data = await response.json();
-        return { status: response.status, data };
-      }
-      if (HTTP_FORCE_RETRY_STATUS_CODES.includes(response.status) && attempt < maxRetries) {
-        await sleep(Math.pow(2, attempt) * 1e3);
-        continue;
-      }
-      let errorMessage;
-      try {
-        const errorBody = await response.json();
-        errorMessage = errorBody.message ?? errorBody.error?.message ?? `API error ${response.status}`;
-      } catch {
-        errorMessage = `API error ${response.status}`;
-      }
-      const errorType = response.status >= 500 ? "AISEC_SERVER_SIDE_ERROR" /* SERVER_SIDE_ERROR */ : "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */;
-      throw new AISecSDKException(errorMessage, errorType);
-    } catch (err) {
-      if (err instanceof AISecSDKException) {
-        throw err;
-      }
-      lastError = err;
-      if (attempt < maxRetries) {
-        await sleep(Math.pow(2, attempt) * 1e3);
-        continue;
-      }
-    }
-  }
-  throw new AISecSDKException(lastError?.message ?? "Network error", "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */);
+  const response = await executeWithRetry({
+    maxRetries: globalConfiguration.numRetries,
+    execute: () => fetch(url.toString(), {
+      method: opts.method,
+      headers,
+      body: bodyStr
+    })
+  });
+  const data = await response.json();
+  return { status: response.status, data };
 }
 
 // src/scan/scanner.ts
 var Scanner = class {
+  /**
+   * Perform a synchronous content scan.
+   * @param aiProfile - AI security profile to scan against.
+   * @param content - Content to scan.
+   * @param opts - Optional transaction/session IDs and metadata.
+   * @returns Scan response with verdict, action, and detection details.
+   */
   async syncScan(aiProfile, content, opts = {}) {
     if (opts.trId && opts.trId.length > MAX_TRANSACTION_ID_STR_LENGTH) {
       throw new AISecSDKException(
@@ -254,6 +331,11 @@ var Scanner = class {
     });
     return res.data;
   }
+  /**
+   * Submit content for asynchronous scanning.
+   * @param scanObjects - Array of scan objects (1–5 items).
+   * @returns Response containing scan IDs for later querying.
+   */
   async asyncScan(scanObjects) {
     if (scanObjects.length < 1) {
       throw new AISecSDKException(
@@ -274,6 +356,11 @@ var Scanner = class {
     });
     return res.data;
   }
+  /**
+   * Query scan results by scan IDs.
+   * @param scanIds - Array of scan UUIDs (1–5 items).
+   * @returns Array of scan results with status and response data.
+   */
   async queryByScanIds(scanIds) {
     if (scanIds.length < 1) {
       throw new AISecSDKException(
@@ -299,6 +386,11 @@ var Scanner = class {
     });
     return res.data;
   }
+  /**
+   * Query detailed threat reports by report IDs.
+   * @param reportIds - Array of report IDs (1–5 items).
+   * @returns Array of threat scan reports with detection details.
+   */
   async queryByReportIds(reportIds) {
     if (reportIds.length < 1) {
       throw new AISecSDKException(
@@ -410,6 +502,7 @@ var Content = class _Content {
   set toolEvent(value) {
     this._toolEvent = value;
   }
+  /** Total byte length of all text content fields. */
   get length() {
     let total = 0;
     if (this._prompt) total += Buffer.byteLength(this._prompt);
@@ -419,6 +512,7 @@ var Content = class _Content {
     if (this._codeResponse) total += Buffer.byteLength(this._codeResponse);
     return total;
   }
+  /** Serialize to the API request format. */
   toJSON() {
     const obj = {};
     if (this._prompt !== void 0) obj.prompt = this._prompt;
@@ -429,6 +523,10 @@ var Content = class _Content {
     if (this._toolEvent !== void 0) obj.tool_event = this._toolEvent;
     return obj;
   }
+  /**
+   * Create a Content instance from an API response object.
+   * @param json - Scan request contents inner object.
+   */
   static fromJSON(json) {
     return new _Content({
       prompt: json.prompt,
@@ -439,6 +537,10 @@ var Content = class _Content {
       toolEvent: json.tool_event
     });
   }
+  /**
+   * Load content from a JSON file.
+   * @param filePath - Path to JSON file containing scan request contents.
+   */
   static fromJSONFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -446,6 +548,23 @@ var Content = class _Content {
   }
 };
 
+// src/models/enums.ts
+var Verdict = {
+  BENIGN: "benign",
+  MALICIOUS: "malicious",
+  UNKNOWN: "unknown"
+};
+var Action = {
+  ALLOW: "allow",
+  BLOCK: "block",
+  ALERT: "alert"
+};
+var Category = {
+  BENIGN: "benign",
+  MALICIOUS: "malicious",
+  UNKNOWN: "unknown"
+};
+
 // src/models/ai-profile.ts
 import { z } from "zod";
 var AiProfileSchema = z.object({
@@ -791,13 +910,1402 @@ var DeleteTopicConflictSchema = z16.object({
   )
 }).passthrough();
 
-// src/models/oauth-token.ts
+// src/models/model-security-enums.ts
+var ErrorCodes = {
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  SCAN_ERROR: "SCAN_ERROR",
+  INVALID_RESPONSE: "INVALID_RESPONSE",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  MISSING_CREDENTIALS: "MISSING_CREDENTIALS",
+  NO_SUCH_KEY: "NO_SUCH_KEY",
+  NO_SUCH_BUCKET: "NO_SUCH_BUCKET",
+  INVALID_BUCKET_NAME: "INVALID_BUCKET_NAME",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  INVALID_OBJECT_STATE: "INVALID_OBJECT_STATE",
+  UNKNOWN_REMOTE_SERVICE_ERROR: "UNKNOWN_REMOTE_SERVICE_ERROR",
+  UNSUPPORTED_REMOTE_STORAGE: "UNSUPPORTED_REMOTE_STORAGE",
+  MISSING_ARTIFACTS: "MISSING_ARTIFACTS",
+  WORKER_ERROR: "WORKER_ERROR",
+  POLICY_EVAL_ERROR: "POLICY_EVAL_ERROR"
+};
+var EvalOutcome = {
+  PENDING: "PENDING",
+  ALLOWED: "ALLOWED",
+  BLOCKED: "BLOCKED",
+  ERROR: "ERROR"
+};
+var FileScanResult = {
+  SKIPPED: "SKIPPED",
+  SUCCESS: "SUCCESS",
+  ERROR: "ERROR",
+  FAILED: "FAILED"
+};
+var FileType = {
+  DIRECTORY: "DIRECTORY",
+  FILE: "FILE"
+};
+var ModelScanStatus = {
+  SCANNED: "SCANNED",
+  SKIPPED: "SKIPPED",
+  ERROR: "ERROR"
+};
+var RuleEvaluationResult = {
+  PASSED: "PASSED",
+  FAILED: "FAILED",
+  ERROR: "ERROR"
+};
+var RuleState = {
+  DISABLED: "DISABLED",
+  ALLOWING: "ALLOWING",
+  BLOCKING: "BLOCKING"
+};
+var ScanOrigin = {
+  MODEL_SECURITY_SDK: "MODEL_SECURITY_SDK",
+  HUGGING_FACE: "HUGGING_FACE"
+};
+var SortByDateField = {
+  CREATED_AT: "created_at",
+  UPDATED_AT: "updated_at"
+};
+var SortByFileField = {
+  PATH: "path",
+  TYPE: "type"
+};
+var SortDirection = {
+  ASC: "asc",
+  DESC: "desc"
+};
+var SourceType = {
+  LOCAL: "LOCAL",
+  HUGGING_FACE: "HUGGING_FACE",
+  S3: "S3",
+  GCS: "GCS",
+  AZURE: "AZURE",
+  ARTIFACTORY: "ARTIFACTORY",
+  GITLAB: "GITLAB",
+  ALL: "ALL"
+};
+var ThreatCategory = {
+  PAIT_ARV_100: "PAIT-ARV-100",
+  PAIT_GGUF_100: "PAIT-GGUF-100",
+  PAIT_GGUF_101: "PAIT-GGUF-101",
+  PAIT_KERAS_100: "PAIT-KERAS-100",
+  PAIT_KERAS_101: "PAIT-KERAS-101",
+  PAIT_KERAS_102: "PAIT-KERAS-102",
+  PAIT_JOBLIB_100: "PAIT-JOBLIB-100",
+  PAIT_JOBLIB_101: "PAIT-JOBLIB-101",
+  PAIT_PKL_100: "PAIT-PKL-100",
+  PAIT_PKL_101: "PAIT-PKL-101",
+  PAIT_PYTCH_100: "PAIT-PYTCH-100",
+  PAIT_PYTCH_101: "PAIT-PYTCH-101",
+  PAIT_EXDIR_100: "PAIT-EXDIR-100",
+  PAIT_EXDIR_101: "PAIT-EXDIR-101",
+  PAIT_ONNX_200: "PAIT-ONNX-200",
+  PAIT_TF_200: "PAIT-TF-200",
+  PAIT_LMAFL_300: "PAIT-LMAFL-300",
+  PAIT_LITERT_300: "PAIT-LITERT-300",
+  PAIT_LITERT_301: "PAIT-LITERT-301",
+  PAIT_LITERT_302: "PAIT-LITERT-302",
+  PAIT_KERAS_300: "PAIT-KERAS-300",
+  PAIT_KERAS_301: "PAIT-KERAS-301",
+  PAIT_TCHST_300: "PAIT-TCHST-300",
+  PAIT_TCHST_301: "PAIT-TCHST-301",
+  PAIT_TF_300: "PAIT-TF-300",
+  PAIT_TF_301: "PAIT-TF-301",
+  PAIT_TF_302: "PAIT-TF-302",
+  PAIT_TMT_300: "PAIT-TMT-300",
+  PAIT_TMT_301: "PAIT-TMT-301",
+  UNAPPROVED_FORMATS: "UNAPPROVED_FORMATS"
+};
+var ModelSecurityGroupState = {
+  PENDING: "PENDING",
+  ACTIVE: "ACTIVE"
+};
+var RuleType = {
+  METADATA: "METADATA",
+  ARTIFACT: "ARTIFACT"
+};
+var RuleEditableFieldType = {
+  SELECT: "SELECT",
+  LIST: "LIST"
+};
+var RuleFieldValueKey = {
+  APPROVED_FORMATS: "approved_formats",
+  APPROVED_LOCATIONS: "approved_locations",
+  APPROVED_LICENSES: "approved_licenses",
+  DENY_ORGS: "deny_orgs",
+  DENIED_ORG_MODELS: "denied_org_models",
+  APPROVED_ORG_MODELS: "approved_org_models"
+};
+
+// src/models/model-security.ts
 import { z as z17 } from "zod";
-var OAuthTokenResponseSchema = z17.object({
-  access_token: z17.string(),
-  token_type: z17.string().optional(),
-  expires_in: z17.number(),
-  scope: z17.string().optional()
+var ModelSecurityPaginationSchema = z17.object({
+  total_items: z17.number().int().nullable().optional()
+}).passthrough();
+var LabelSchema = z17.object({
+  key: z17.string(),
+  value: z17.string()
+});
+var LabelsCreateRequestSchema = z17.object({
+  labels: z17.array(LabelSchema)
+});
+var LabelsResponseSchema = z17.object({}).passthrough();
+var LabelKeyListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  keys: z17.array(z17.string())
+}).passthrough();
+var LabelValueListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  values: z17.array(z17.string())
+}).passthrough();
+var EvalSummarySchema = z17.object({
+  rules_failed: z17.number().int().optional().default(0),
+  rules_passed: z17.number().int().optional().default(0),
+  total_rules: z17.number().int().optional().default(0)
+}).passthrough();
+var ModelScanIssueSchema = z17.object({
+  description: z17.string(),
+  source: z17.string(),
+  threat: z17.string().nullable().optional(),
+  module: z17.string().nullable().optional(),
+  operator: z17.string().nullable().optional()
+}).passthrough();
+var FileScanDataSchema = z17.object({
+  file_path: z17.string(),
+  modelscan_status: z17.string(),
+  blob_id: z17.string(),
+  error_message: z17.string().nullable().optional(),
+  formats: z17.array(z17.string()).nullable().optional(),
+  issues_detected: z17.array(ModelScanIssueSchema).nullable().optional()
+}).passthrough();
+var ScanDetailsSchema = z17.object({
+  scanner_version: z17.string(),
+  time_started: z17.string(),
+  files: z17.array(FileScanDataSchema),
+  total_files_scanned: z17.number().int(),
+  total_files_skipped: z17.number().int(),
+  model_formats: z17.array(z17.string()),
+  model_size_bytes: z17.number().int(),
+  scan_duration_ms: z17.number().int(),
+  error_code: z17.string().nullable().optional(),
+  error_message: z17.string().nullable().optional()
+});
+var ScanCreateRequestSchema = z17.object({
+  model_uri: z17.string(),
+  security_group_uuid: z17.string(),
+  scan_origin: z17.string(),
+  allow_patterns: z17.array(z17.string()).nullable().optional(),
+  ignore_patterns: z17.array(z17.string()).nullable().optional(),
+  labels: z17.array(LabelSchema).nullable().optional(),
+  model_author: z17.string().nullable().optional(),
+  model_name: z17.string().nullable().optional(),
+  model_version: z17.string().nullable().optional(),
+  scan_details: ScanDetailsSchema.nullable().optional()
+});
+var ScanBaseResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  model_uri: z17.string(),
+  owner: z17.string(),
+  scan_origin: z17.string(),
+  security_group_uuid: z17.string(),
+  security_group_name: z17.string(),
+  model_version_uuid: z17.string(),
+  eval_outcome: z17.string(),
+  source_type: z17.string(),
+  created_by: z17.string().nullable().optional(),
+  enabled_rule_count_snapshot: z17.number().int().nullable().optional(),
+  error_code: z17.string().nullable().optional(),
+  error_message: z17.string().nullable().optional(),
+  eval_summary: EvalSummarySchema.nullable().optional(),
+  labels: z17.array(LabelSchema).optional(),
+  model_formats: z17.array(z17.string()).nullable().optional(),
+  scanner_version: z17.string().nullable().optional(),
+  time_started: z17.string().nullable().optional(),
+  total_files_scanned: z17.number().int().nullable().optional(),
+  total_files_skipped: z17.number().int().nullable().optional()
+}).passthrough();
+var ScanListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  scans: z17.array(ScanBaseResponseSchema)
+}).passthrough();
+var FileResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  path: z17.string(),
+  parent_path: z17.string(),
+  type: z17.string(),
+  result: z17.string(),
+  model_version_uuid: z17.string(),
+  blob_id: z17.string().nullable().optional(),
+  formats: z17.array(z17.string()).nullable().optional(),
+  scan_uuid: z17.string().nullable().optional()
+}).passthrough();
+var FileListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  files: z17.array(FileResponseSchema)
+}).passthrough();
+var RuleEvaluationResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  result: z17.string(),
+  violation_count: z17.number().int(),
+  rule_instance_uuid: z17.string(),
+  scan_uuid: z17.string(),
+  rule_name: z17.string(),
+  rule_description: z17.string(),
+  rule_instance_state: z17.string()
+}).passthrough();
+var RuleEvaluationListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  evaluations: z17.array(RuleEvaluationResponseSchema)
+}).passthrough();
+var ViolationResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  description: z17.string(),
+  rule_instance_uuid: z17.string(),
+  rule_name: z17.string(),
+  rule_description: z17.string(),
+  rule_instance_state: z17.string(),
+  file: z17.string().nullable().optional(),
+  hash: z17.string().nullable().optional(),
+  module: z17.string().nullable().optional(),
+  operator: z17.string().nullable().optional(),
+  threat: z17.string().nullable().optional(),
+  threat_description: z17.string().nullable().optional()
+}).passthrough();
+var ViolationListSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  violations: z17.array(ViolationResponseSchema)
+}).passthrough();
+var RuleEditableFieldDropdownSchema = z17.object({
+  value: z17.string(),
+  label: z17.string()
+}).passthrough();
+var RuleEditableFieldSchema = z17.object({
+  attribute_name: z17.string(),
+  type: z17.string(),
+  display_name: z17.string(),
+  display_type: z17.string(),
+  description: z17.string().nullable().optional(),
+  dropdown_values: z17.array(RuleEditableFieldDropdownSchema).nullable().optional()
+}).passthrough();
+var RuleRemediationSchema = z17.object({
+  description: z17.string(),
+  steps: z17.array(z17.string()),
+  url: z17.string()
+}).passthrough();
+var RuleConfigurationSchema = z17.object({
+  field_values: z17.record(z17.unknown()).optional(),
+  state: z17.string().nullable().optional()
+}).passthrough();
+var ModelSecurityRuleResponseSchema = z17.object({
+  uuid: z17.string(),
+  name: z17.string(),
+  description: z17.string(),
+  rule_type: z17.string(),
+  compatible_sources: z17.array(z17.string()),
+  default_state: z17.string(),
+  remediation: RuleRemediationSchema,
+  editable_fields: z17.array(RuleEditableFieldSchema),
+  constant_values: z17.record(z17.unknown()),
+  default_values: z17.record(z17.unknown())
+}).passthrough();
+var ListModelSecurityRulesResponseSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  rules: z17.array(ModelSecurityRuleResponseSchema)
+}).passthrough();
+var ModelSecurityRuleInstanceResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  security_group_uuid: z17.string(),
+  security_rule_uuid: z17.string(),
+  state: z17.string(),
+  rule: ModelSecurityRuleResponseSchema,
+  field_values: z17.record(z17.unknown()).optional()
+}).passthrough();
+var ModelSecurityRuleInstanceUpdateRequestSchema = z17.object({
+  security_group_uuid: z17.string(),
+  state: z17.string().nullable().optional(),
+  field_values: z17.record(z17.unknown()).nullable().optional()
+});
+var ListModelSecurityRuleInstancesResponseSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  rule_instances: z17.array(ModelSecurityRuleInstanceResponseSchema)
+}).passthrough();
+var ModelSecurityGroupCreateRequestSchema = z17.object({
+  name: z17.string(),
+  source_type: z17.string(),
+  description: z17.string().optional().default(""),
+  rule_configurations: z17.record(RuleConfigurationSchema).optional()
+});
+var ModelSecurityGroupResponseSchema = z17.object({
+  uuid: z17.string(),
+  tsg_id: z17.string(),
+  created_at: z17.string(),
+  updated_at: z17.string(),
+  name: z17.string(),
+  description: z17.string(),
+  source_type: z17.string(),
+  state: z17.string(),
+  is_tombstone: z17.boolean()
+}).passthrough();
+var ModelSecurityGroupUpdateRequestSchema = z17.object({
+  name: z17.string().nullable().optional(),
+  description: z17.string().nullable().optional()
+});
+var ListModelSecurityGroupsResponseSchema = z17.object({
+  pagination: ModelSecurityPaginationSchema,
+  security_groups: z17.array(ModelSecurityGroupResponseSchema)
+}).passthrough();
+var PyPIAuthResponseSchema = z17.object({
+  url: z17.string(),
+  expires_at: z17.string()
+}).passthrough();
+
+// src/models/red-team-enums.ts
+var ApiEndpointType = {
+  PUBLIC: "PUBLIC",
+  PRIVATE: "PRIVATE",
+  NETWORK_BROKER: "NETWORK_BROKER"
+};
+var AttackStatus = {
+  INIT: "INIT",
+  ATTACK: "ATTACK",
+  DETECTION: "DETECTION",
+  REPORT: "REPORT",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED"
+};
+var AttackType = {
+  NORMAL: "NORMAL",
+  CUSTOM: "CUSTOM"
+};
+var AuthType = {
+  OAUTH: "OAUTH",
+  ACCESS_TOKEN: "ACCESS_TOKEN"
+};
+var BrandSubCategory = {
+  COMPETITOR_ENDORSEMENTS: "COMPETITOR_ENDORSEMENTS",
+  BRAND_TARNISHING_SELF_CRITICISM: "BRAND_TARNISHING_SELF_CRITICISM",
+  DISCRIMINATING_CLAIMS: "DISCRIMINATING_CLAIMS",
+  POLITICAL_ENDORSEMENTS: "POLITICAL_ENDORSEMENTS"
+};
+var ComplianceSubCategory = {
+  OWASP: "OWASP",
+  MITRE_ATLAS: "MITRE_ATLAS",
+  NIST: "NIST",
+  DASF_V2: "DASF_V2"
+};
+var CountedQuotaEnum = {
+  HELD: "HELD",
+  COUNTED: "COUNTED",
+  NOT_COUNTED: "NOT_COUNTED"
+};
+var DateRangeFilter = {
+  LAST_7_DAYS: "LAST_7_DAYS",
+  LAST_15_DAYS: "LAST_15_DAYS",
+  LAST_30_DAYS: "LAST_30_DAYS",
+  ALL: "ALL"
+};
+var ErrorSource = {
+  TARGET: "TARGET",
+  JOB: "JOB",
+  SYSTEM: "SYSTEM",
+  VALIDATION: "VALIDATION",
+  TARGET_PROFILING: "TARGET_PROFILING"
+};
+var RedTeamErrorType = {
+  CONTENT_FILTER: "CONTENT_FILTER",
+  RATE_LIMIT: "RATE_LIMIT",
+  AUTHENTICATION: "AUTHENTICATION",
+  NETWORK: "NETWORK",
+  VALIDATION: "VALIDATION",
+  NETWORK_CHANNEL: "NETWORK_CHANNEL",
+  UNKNOWN: "UNKNOWN"
+};
+var FileFormat = {
+  CSV: "CSV",
+  JSON: "JSON",
+  ALL: "ALL"
+};
+var GoalType = {
+  BASE: "BASE",
+  TOOL_MISUSE: "TOOL_MISUSE",
+  GOAL_MANIPULATION: "GOAL_MANIPULATION"
+};
+var GoalTypeQueryParam = {
+  AGENT: "AGENT",
+  HUMAN_AUGMENTED: "HUMAN_AUGMENTED"
+};
+var GuardrailAction = {
+  ALLOW: "ALLOW",
+  BLOCK: "BLOCK"
+};
+var JobStatus = {
+  INIT: "INIT",
+  QUEUED: "QUEUED",
+  RUNNING: "RUNNING",
+  COMPLETED: "COMPLETED",
+  PARTIALLY_COMPLETE: "PARTIALLY_COMPLETE",
+  FAILED: "FAILED",
+  ABORTED: "ABORTED"
+};
+var JobStatusFilter = {
+  QUEUED: "QUEUED",
+  RUNNING: "RUNNING",
+  COMPLETED: "COMPLETED",
+  PARTIALLY_COMPLETE: "PARTIALLY_COMPLETE",
+  FAILED: "FAILED",
+  ABORTED: "ABORTED"
+};
+var JobType = {
+  STATIC: "STATIC",
+  DYNAMIC: "DYNAMIC",
+  CUSTOM: "CUSTOM"
+};
+var PolicyType = {
+  PROMPT_INJECTION: "PROMPT_INJECTION",
+  TOXIC_CONTENT: "TOXIC_CONTENT",
+  CUSTOM_TOPIC_GUARDRAILS: "CUSTOM_TOPIC_GUARDRAILS",
+  MALICIOUS_CODE_DETECTION: "MALICIOUS_CODE_DETECTION",
+  MALICIOUS_URL_DETECTION: "MALICIOUS_URL_DETECTION",
+  SENSITIVE_DATA_PROTECTION: "SENSITIVE_DATA_PROTECTION"
+};
+var ProfilingStatus = {
+  INIT: "INIT",
+  QUEUED: "QUEUED",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED"
+};
+var RedTeamCategory = {
+  SECURITY: "SECURITY",
+  SAFETY: "SAFETY",
+  COMPLIANCE: "COMPLIANCE",
+  BRAND: "BRAND"
+};
+var ResponseMode = {
+  REST: "REST",
+  STREAMING: "STREAMING"
+};
+var RiskRating = {
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH",
+  CRITICAL: "CRITICAL"
+};
+var SafetySubCategory = {
+  BIAS: "BIAS",
+  CBRN: "CBRN",
+  CYBERCRIME: "CYBERCRIME",
+  DRUGS: "DRUGS",
+  HATE_TOXIC_ABUSE: "HATE_TOXIC_ABUSE",
+  NON_VIOLENT_CRIMES: "NON_VIOLENT_CRIMES",
+  POLITICAL: "POLITICAL",
+  SELF_HARM: "SELF_HARM",
+  SEXUAL: "SEXUAL",
+  VIOLENT_CRIMES_WEAPONS: "VIOLENT_CRIMES_WEAPONS"
+};
+var SecuritySubCategory = {
+  ADVERSARIAL_SUFFIX: "ADVERSARIAL_SUFFIX",
+  EVASION: "EVASION",
+  INDIRECT_PROMPT_INJECTION: "INDIRECT_PROMPT_INJECTION",
+  JAILBREAK: "JAILBREAK",
+  MULTI_TURN: "MULTI_TURN",
+  PROMPT_INJECTION: "PROMPT_INJECTION",
+  REMOTE_CODE_EXECUTION: "REMOTE_CODE_EXECUTION",
+  SYSTEM_PROMPT_LEAK: "SYSTEM_PROMPT_LEAK",
+  TOOL_LEAK: "TOOL_LEAK",
+  MALWARE_GENERATION: "MALWARE_GENERATION"
+};
+var SeverityFilter = {
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH",
+  CRITICAL: "CRITICAL"
+};
+var StatusQueryParam = {
+  SUCCESSFUL: "SUCCESSFUL",
+  FAILED: "FAILED"
+};
+var StreamType = {
+  NORMAL: "NORMAL",
+  ADVERSARIAL: "ADVERSARIAL"
+};
+var TargetConnectionType = {
+  DATABRICKS: "DATABRICKS",
+  BEDROCK: "BEDROCK",
+  OPENAI: "OPENAI",
+  HUGGING_FACE: "HUGGING_FACE",
+  CUSTOM: "CUSTOM",
+  REST: "REST",
+  STREAMING: "STREAMING"
+};
+var TargetStatus = {
+  DRAFT: "DRAFT",
+  VALIDATING: "VALIDATING",
+  VALIDATED: "VALIDATED",
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+  FAILED: "FAILED",
+  PENDING_AUTH: "PENDING_AUTH"
+};
+var TargetType = {
+  APPLICATION: "APPLICATION",
+  AGENT: "AGENT",
+  MODEL: "MODEL"
+};
+
+// src/models/red-team.ts
+import { z as z18 } from "zod";
+var RedTeamPaginationSchema = z18.object({ total_items: z18.number().int().nullable().optional() }).passthrough();
+var CountByNameSchema = z18.object({ name: z18.string(), count: z18.number().int() });
+var ValidationErrorSchema = z18.object({
+  loc: z18.array(z18.union([z18.string(), z18.number()])),
+  msg: z18.string(),
+  type: z18.string()
+});
+var HTTPValidationErrorSchema = z18.object({ detail: z18.array(ValidationErrorSchema).optional() }).passthrough();
+var TargetBackgroundSchema = z18.object({
+  industry: z18.unknown().optional(),
+  use_case: z18.unknown().optional(),
+  competitors: z18.unknown().optional()
+}).passthrough();
+var TargetAdditionalContextSchema = z18.object({
+  base_model: z18.unknown().optional(),
+  core_architecture: z18.unknown().optional(),
+  system_prompt: z18.unknown().optional(),
+  languages_supported: z18.unknown().optional(),
+  banned_keywords: z18.unknown().optional(),
+  tools_accessible: z18.unknown().optional()
+}).passthrough();
+var TargetMetadataSchema = z18.object({
+  multi_turn: z18.boolean().optional(),
+  multi_turn_error_message: z18.unknown().optional(),
+  rate_limit: z18.unknown().optional(),
+  rate_limit_enabled: z18.boolean().optional(),
+  rate_limit_error_code: z18.unknown().optional(),
+  rate_limit_error_json: z18.unknown().optional(),
+  rate_limit_error_message: z18.unknown().optional(),
+  content_filter_enabled: z18.boolean().optional(),
+  content_filter_error_code: z18.unknown().optional(),
+  content_filter_error_json: z18.unknown().optional(),
+  content_filter_error_message: z18.unknown().optional(),
+  probe_message: z18.string().optional(),
+  request_timeout: z18.number().optional()
+}).passthrough();
+var TargetJobRequestSchema = z18.object({
+  uuid: z18.string(),
+  version: z18.number().int().nullable().optional()
+});
+var JobTimeRecordSchema = z18.object({
+  queued_at: z18.string().nullable().optional(),
+  started_at: z18.string().nullable().optional(),
+  completed_at: z18.string().nullable().optional(),
+  time_taken: z18.string().nullable().optional()
+}).passthrough();
+var StaticJobMetadataSchema = z18.object({
+  categories: z18.record(z18.unknown()),
+  rate_limit_enabled: z18.boolean().optional(),
+  rate_limit: z18.number().int().nullable().optional(),
+  rate_limit_error_code: z18.number().int().nullable().optional(),
+  rate_limit_error_message: z18.string().nullable().optional(),
+  rate_limit_error_json: z18.unknown().optional(),
+  content_filter_enabled: z18.boolean().optional(),
+  content_filter_error_code: z18.number().int().nullable().optional(),
+  content_filter_error_message: z18.string().nullable().optional(),
+  content_filter_error_json: z18.unknown().optional()
+}).passthrough();
+var DynamicJobMetadataSchema = z18.object({
+  rate_limit_enabled: z18.boolean().optional(),
+  rate_limit: z18.number().int().nullable().optional(),
+  rate_limit_error_code: z18.number().int().nullable().optional(),
+  rate_limit_error_message: z18.string().nullable().optional(),
+  rate_limit_error_json: z18.unknown().optional(),
+  content_filter_enabled: z18.boolean().optional(),
+  content_filter_error_code: z18.number().int().nullable().optional(),
+  content_filter_error_message: z18.string().nullable().optional(),
+  content_filter_error_json: z18.unknown().optional(),
+  stream_breadth: z18.number().int().optional(),
+  stream_depth: z18.number().int().optional(),
+  max_tokens: z18.number().int().optional(),
+  context_size: z18.number().int().optional(),
+  attack_goals: z18.array(z18.unknown()).optional(),
+  base_model: z18.string().nullable().optional(),
+  use_case: z18.string().nullable().optional(),
+  system_prompt: z18.string().nullable().optional()
+}).passthrough();
+var CustomJobMetadataSchema = z18.object({
+  custom_prompt_sets: z18.array(z18.unknown()),
+  rate_limit_enabled: z18.boolean().optional(),
+  rate_limit: z18.number().int().nullable().optional(),
+  rate_limit_error_code: z18.number().int().nullable().optional(),
+  rate_limit_error_message: z18.string().nullable().optional(),
+  rate_limit_error_json: z18.unknown().optional(),
+  content_filter_enabled: z18.boolean().optional(),
+  content_filter_error_code: z18.number().int().nullable().optional(),
+  content_filter_error_message: z18.string().nullable().optional(),
+  content_filter_error_json: z18.unknown().optional()
+}).passthrough();
+var JobCreateRequestSchema = z18.object({
+  name: z18.string(),
+  target: TargetJobRequestSchema,
+  job_type: z18.string(),
+  job_metadata: z18.union([
+    StaticJobMetadataSchema,
+    DynamicJobMetadataSchema,
+    CustomJobMetadataSchema
+  ]),
+  version: z18.number().int().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional()
+});
+var StaticJobReportStatsSchema = z18.object({
+  output_completion_percentage: z18.number(),
+  partial_report_unlocked: z18.boolean().optional(),
+  partial_report_unlocked_at: z18.string().nullable().optional(),
+  report_summary: z18.string().nullable().optional()
+}).passthrough();
+var DynamicJobReportStatsSchema = z18.object({
+  total_goals: z18.number().int().optional(),
+  total_streams: z18.number().int().optional(),
+  total_threats: z18.number().int().optional(),
+  goals_achieved: z18.number().int().optional(),
+  report_summary: z18.string().nullable().optional()
+}).passthrough();
+var TargetReferenceSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  name: z18.string(),
+  description: z18.string().nullable().optional(),
+  target_type: z18.string().nullable().optional(),
+  connection_type: z18.string().nullable().optional(),
+  api_endpoint_type: z18.string().nullable().optional(),
+  response_mode: z18.string().nullable().optional(),
+  session_supported: z18.boolean().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional(),
+  status: z18.string(),
+  active: z18.boolean(),
+  validated: z18.boolean(),
+  version: z18.number().int().nullable().optional(),
+  secret_version: z18.string().nullable().optional(),
+  created_by_user_id: z18.string().nullable().optional(),
+  updated_by_user_id: z18.string().nullable().optional(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  target_metadata: TargetMetadataSchema.optional(),
+  target_background: TargetBackgroundSchema.nullable().optional(),
+  profiling_status: z18.string().nullable().optional(),
+  additional_context: TargetAdditionalContextSchema.nullable().optional()
+}).passthrough();
+var JobResponseSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  name: z18.string(),
+  target: TargetReferenceSchema,
+  job_type: z18.string(),
+  job_metadata: z18.unknown(),
+  version: z18.number().int().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional(),
+  target_id: z18.string(),
+  target_type: z18.string(),
+  total: z18.number().int().nullable().optional(),
+  completed: z18.number().int().nullable().optional(),
+  status: z18.string().optional(),
+  score: z18.number().nullable().optional(),
+  asr: z18.number().nullable().optional(),
+  time_record: JobTimeRecordSchema.nullable().optional(),
+  created_at: z18.string().nullable().optional(),
+  updated_at: z18.string().nullable().optional(),
+  created_by_user_id: z18.string().nullable().optional(),
+  report_stats: z18.unknown().optional(),
+  metering_quota_uuid: z18.string().nullable().optional(),
+  counted_towards_quota: z18.string().optional(),
+  invocation_id: z18.string().nullable().optional()
+}).passthrough();
+var JobListResponseSchema = z18.object({
+  pagination: RedTeamPaginationSchema,
+  data: z18.array(JobResponseSchema)
+}).passthrough();
+var JobAbortResponseSchema = z18.object({
+  job_id: z18.string(),
+  message: z18.string()
+});
+var PrerequisiteModelSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string()
+});
+var SubCategoryModelSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string(),
+  preselect: z18.boolean().optional(),
+  prerequisites: z18.array(PrerequisiteModelSchema).nullable().optional(),
+  active: z18.boolean().optional()
+}).passthrough();
+var CategoryModelSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string(),
+  preselect: z18.boolean().optional(),
+  sub_categories: z18.array(SubCategoryModelSchema)
+}).passthrough();
+var AttackOutputSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  attack_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  output: z18.string(),
+  threat: z18.boolean().nullable().optional(),
+  marked_safe: z18.boolean().nullable().optional()
+}).passthrough();
+var AttackMultiTurnOutputSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  attack_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  output: z18.string(),
+  prompt: z18.string(),
+  turn: z18.number().int(),
+  threat: z18.boolean().nullable().optional(),
+  marked_safe: z18.boolean().nullable().optional(),
+  generation: z18.number().int().optional(),
+  multi_turn: z18.boolean().optional()
+}).passthrough();
+var AttackListItemSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  prompt: z18.string(),
+  prompt_mapping_id: z18.string(),
+  prompt_id: z18.string(),
+  category: z18.string(),
+  sub_category: z18.string(),
+  category_display_name: z18.string(),
+  sub_category_display_name: z18.string(),
+  status: z18.string().optional(),
+  marked_safe: z18.boolean().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).optional(),
+  threat: z18.boolean().nullable().optional(),
+  attack_type: z18.string().optional(),
+  multi_turn: z18.boolean().optional(),
+  asr: z18.number().nullable().optional(),
+  version: z18.number().int().nullable().optional(),
+  severity: z18.string().optional()
+}).passthrough();
+var AttackListResponseSchema = z18.object({
+  pagination: RedTeamPaginationSchema,
+  data: z18.array(AttackListItemSchema)
+}).passthrough();
+var AttackDetailResponseSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  prompt: z18.string(),
+  prompt_mapping_id: z18.string(),
+  prompt_id: z18.string(),
+  category: z18.string(),
+  sub_category: z18.string(),
+  category_display_name: z18.string(),
+  sub_category_display_name: z18.string(),
+  compliance_frameworks: z18.array(z18.unknown()),
+  goal: z18.string().nullable(),
+  status: z18.string().optional(),
+  marked_safe: z18.boolean().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).optional(),
+  threat: z18.boolean().nullable().optional(),
+  attack_type: z18.string().optional(),
+  multi_turn: z18.boolean().optional(),
+  asr: z18.number().nullable().optional(),
+  version: z18.number().int().nullable().optional(),
+  severity: z18.string().optional(),
+  outputs: z18.array(AttackOutputSchema).optional()
+}).passthrough();
+var AttackMultiTurnDetailResponseSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  prompt: z18.string(),
+  prompt_mapping_id: z18.string(),
+  prompt_id: z18.string(),
+  category: z18.string(),
+  sub_category: z18.string(),
+  category_display_name: z18.string(),
+  sub_category_display_name: z18.string(),
+  compliance_frameworks: z18.array(z18.unknown()),
+  goal: z18.string().nullable(),
+  status: z18.string().optional(),
+  marked_safe: z18.boolean().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).optional(),
+  threat: z18.boolean().nullable().optional(),
+  attack_type: z18.string().optional(),
+  multi_turn: z18.boolean().optional(),
+  asr: z18.number().nullable().optional(),
+  version: z18.number().int().nullable().optional(),
+  severity: z18.string().optional(),
+  outputs: z18.array(AttackMultiTurnOutputSchema).optional()
+}).passthrough();
+var SubCategoryStatsSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string(),
+  preselect: z18.boolean().optional(),
+  prerequisites: z18.array(PrerequisiteModelSchema).nullable().optional(),
+  active: z18.boolean().optional(),
+  successful: z18.number().int(),
+  failed: z18.number().int(),
+  total: z18.number().int().optional()
+}).passthrough();
+var CategoryReportSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string(),
+  preselect: z18.boolean().optional(),
+  sub_categories: z18.array(SubCategoryStatsSchema),
+  asr: z18.number(),
+  total_prompts: z18.number().int(),
+  total_attacks: z18.number().int(),
+  successful: z18.number().int(),
+  failed: z18.number().int()
+}).passthrough();
+var SeverityStatsSchema = z18.object({
+  severity: z18.string(),
+  successful: z18.number().int().optional(),
+  failed: z18.number().int().optional()
+}).passthrough();
+var SeverityReportSchema = z18.object({
+  stats: z18.array(SeverityStatsSchema),
+  successful: z18.number().int().optional(),
+  failed: z18.number().int().optional(),
+  total_attacks: z18.number().int().optional()
+}).passthrough();
+var ComplianceTechniqueSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  compliance_id: z18.string(),
+  description: z18.string(),
+  link: z18.string(),
+  version: z18.string(),
+  active: z18.boolean(),
+  successful: z18.number().int().optional(),
+  failed: z18.number().int().optional(),
+  total: z18.number().int().optional()
+}).passthrough();
+var ComplianceReportSchema = z18.object({
+  id: z18.string(),
+  display_name: z18.string(),
+  description: z18.string(),
+  active: z18.boolean(),
+  version: z18.string(),
+  link: z18.string(),
+  techniques: z18.array(ComplianceTechniqueSchema),
+  score: z18.number().int().optional()
+}).passthrough();
+var RuntimeSecurityPolicySchema = z18.object({
+  policy_id: z18.string(),
+  display_name: z18.string(),
+  config: z18.record(z18.unknown())
+}).passthrough();
+var StaticJobRemediationSchema = z18.object({
+  remediation: z18.string(),
+  description: z18.string(),
+  mapping_remediation_id: z18.string().nullable().optional(),
+  subcategories: z18.array(z18.string()).nullable().optional(),
+  effectiveness: z18.number().int().optional(),
+  ease_of_implementation: z18.number().int().optional(),
+  priority: z18.number().int().optional(),
+  resource_links: z18.array(z18.string()).optional(),
+  categories: z18.array(z18.string()).nullable().optional()
+}).passthrough();
+var StaticJobRemediationRecommendationSchema = z18.object({
+  runtime_security_policy_configuration: z18.array(RuntimeSecurityPolicySchema).nullable().optional(),
+  other_measures: z18.array(StaticJobRemediationSchema).optional()
+}).passthrough();
+var StaticJobReportSchema = z18.object({
+  severity_report: SeverityReportSchema,
+  asr: z18.number().nullable().optional(),
+  score: z18.number().nullable().optional(),
+  security_report: CategoryReportSchema.nullable().optional(),
+  safety_report: CategoryReportSchema.nullable().optional(),
+  brand_report: CategoryReportSchema.nullable().optional(),
+  compliance_report: z18.array(ComplianceReportSchema).nullable().optional(),
+  report_summary: z18.string().nullable().optional(),
+  recommendations: StaticJobRemediationRecommendationSchema.nullable().optional()
+}).passthrough();
+var DynamicJobReportSchema = z18.object({
+  total_goals: z18.number().int().optional(),
+  total_streams: z18.number().int().optional(),
+  total_threats: z18.number().int().optional(),
+  goals_achieved: z18.number().int().optional(),
+  report_summary: z18.string().nullable().optional(),
+  score: z18.number().optional(),
+  asr: z18.number().optional()
+}).passthrough();
+var RemediationDetailSchema = z18.object({
+  remediation: z18.string(),
+  description: z18.string(),
+  resource_links: z18.array(z18.string()).optional(),
+  priority_level: z18.string().optional(),
+  ease_of_implementation_level: z18.string().optional(),
+  effectiveness_level: z18.string().optional()
+}).passthrough();
+var RemediationResponseSchema = z18.object({ remediations: z18.array(RemediationDetailSchema).optional() }).passthrough();
+var RuntimeSecurityProfileResponseSchema = z18.object({
+  runtime_security_profile: z18.array(RuntimeSecurityPolicySchema).nullable().optional()
+}).passthrough();
+var GoalSchema = z18.object({
+  goal: z18.string(),
+  safe_response: z18.string(),
+  jailbroken_response: z18.string(),
+  goal_metadata: z18.record(z18.unknown()).optional(),
+  custom_goal: z18.boolean().optional(),
+  goal_type: z18.string().optional(),
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  goal_to_show: z18.string().nullable().optional(),
+  threat: z18.boolean().optional(),
+  version: z18.number().int().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional()
+}).passthrough();
+var GoalListResponseSchema = z18.object({ pagination: RedTeamPaginationSchema, data: z18.array(GoalSchema) }).passthrough();
+var StreamIterationDataSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  stream_id: z18.string(),
+  goal_id: z18.string(),
+  iteration: z18.number().int(),
+  prompt: z18.string(),
+  techniques: z18.string(),
+  improvement: z18.string(),
+  prompts_objective: z18.string(),
+  summary: z18.string(),
+  output: z18.string().nullable().optional(),
+  score: z18.number().int().nullable().optional(),
+  judge_reasoning: z18.string().nullable().optional(),
+  threat: z18.boolean().optional(),
+  created_at: z18.string().nullable().optional(),
+  updated_at: z18.string().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional(),
+  version: z18.number().int().nullable().optional()
+}).passthrough();
+var StreamDetailResponseSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  goal_id: z18.string(),
+  stream_idx: z18.number().int().optional(),
+  iteration: z18.number().int().optional(),
+  goal: z18.unknown().optional(),
+  marked_safe: z18.boolean().optional(),
+  stream_type: z18.string().nullable().optional(),
+  threat: z18.boolean().optional(),
+  first_threat_iteration: StreamIterationDataSchema.nullable().optional(),
+  created_at: z18.string().nullable().optional(),
+  updated_at: z18.string().nullable().optional(),
+  extra_info: z18.record(z18.unknown()).optional(),
+  version: z18.number().int().nullable().optional(),
+  iterations: z18.array(StreamIterationDataSchema).optional()
+}).passthrough();
+var StreamListResponseSchema = z18.object({ pagination: RedTeamPaginationSchema, data: z18.array(StreamDetailResponseSchema) }).passthrough();
+var CustomAttackOutputSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  custom_attack_id: z18.string(),
+  job_id: z18.string(),
+  target_id: z18.string(),
+  output: z18.string(),
+  threat: z18.boolean().nullable().optional(),
+  marked_safe: z18.boolean().nullable().optional()
+}).passthrough();
+var PropertyAssignmentSchema = z18.object({
+  name: z18.string(),
+  value: z18.string()
+});
+var PropertyValueStatisticSchema = z18.object({
+  value: z18.string(),
+  successful_attack_count: z18.number().int(),
+  total_attack_count: z18.number().int(),
+  success_rate: z18.number()
+});
+var PropertyStatisticSchema = z18.object({
+  property_name: z18.string(),
+  values: z18.array(PropertyValueStatisticSchema)
+});
+var PromptSetSummarySchema = z18.object({
+  prompt_set_id: z18.string(),
+  prompt_set_name: z18.string(),
+  total_prompts: z18.number().int(),
+  total_attacks: z18.number().int(),
+  total_threats: z18.number().int(),
+  failed_attacks: z18.number().int(),
+  threat_rate: z18.number(),
+  property_names: z18.array(z18.string()).optional(),
+  property_statistics: z18.array(PropertyStatisticSchema).optional()
+}).passthrough();
+var CustomAttackReportResponseSchema = z18.object({
+  total_prompts: z18.number().int(),
+  total_attacks: z18.number().int(),
+  total_threats: z18.number().int(),
+  failed_attacks: z18.number().int(),
+  score: z18.number(),
+  asr: z18.number(),
+  custom_attack_reports: z18.array(PromptSetSummarySchema).optional(),
+  property_statistics: z18.array(PropertyStatisticSchema).optional()
+}).passthrough();
+var PromptSetsReportResponseSchema = z18.object({
+  prompt_sets: z18.array(PromptSetSummarySchema),
+  total_prompt_sets: z18.number().int(),
+  applied_filters: z18.record(z18.unknown()).optional()
+}).passthrough();
+var PromptDetailResponseSchema = z18.object({
+  prompt_id: z18.string(),
+  prompt_text: z18.string(),
+  goal: z18.string().nullable().optional(),
+  user_defined_goal: z18.boolean().optional(),
+  properties: z18.array(PropertyAssignmentSchema).optional(),
+  attack_id: z18.string().nullable().optional(),
+  threat: z18.boolean().nullable().optional(),
+  attack_outputs: z18.array(CustomAttackOutputSchema).optional(),
+  asr: z18.number().nullable().optional(),
+  prompt_set_id: z18.string().nullable().optional(),
+  prompt_set_name: z18.string().nullable().optional()
+}).passthrough();
+var CustomAttacksListResponseSchema = z18.object({
+  pagination: RedTeamPaginationSchema,
+  data: z18.array(z18.unknown()),
+  total_attacks: z18.number().int(),
+  total_threats: z18.number().int()
+}).passthrough();
+var RiskLevelSchema = z18.object({
+  risk_rating: z18.string(),
+  total: z18.number().int(),
+  targets_by_type: z18.array(CountByNameSchema).optional()
+}).passthrough();
+var ScanStatisticsResponseSchema = z18.object({
+  total_scans: z18.number().int(),
+  targets_scanned: z18.number().int(),
+  targets_scanned_by_type: z18.array(CountByNameSchema).optional(),
+  scan_status: z18.array(CountByNameSchema).optional(),
+  risk_profile: z18.array(RiskLevelSchema).optional()
+}).passthrough();
+var ScoreTrendSeriesSchema = z18.object({
+  label: z18.string(),
+  data: z18.array(z18.number().nullable())
+});
+var ScoreTrendResponseSchema = z18.object({
+  labels: z18.array(z18.string()),
+  series: z18.array(ScoreTrendSeriesSchema)
+});
+var SentimentRequestSchema = z18.object({
+  job_id: z18.string(),
+  up_vote: z18.boolean().optional(),
+  down_vote: z18.boolean().optional()
+});
+var SentimentResponseSchema = z18.object({
+  job_id: z18.string(),
+  up_vote: z18.boolean().optional(),
+  down_vote: z18.boolean().optional()
+}).passthrough();
+var QuotaDetailsSchema = z18.object({
+  allocated: z18.number().int(),
+  unlimited: z18.boolean(),
+  consumed: z18.number().int()
+});
+var QuotaSummarySchema = z18.object({
+  static: QuotaDetailsSchema,
+  dynamic: QuotaDetailsSchema,
+  custom: QuotaDetailsSchema
+});
+var ErrorLogSchema = z18.object({
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  job_id: z18.string().nullable().optional(),
+  target_id: z18.string().nullable().optional(),
+  target_version: z18.number().int().nullable().optional(),
+  attack_id: z18.string().nullable().optional(),
+  error_type: z18.string().nullable().optional(),
+  error_source: z18.string().nullable().optional(),
+  error_message: z18.string().nullable().optional(),
+  target_object: z18.record(z18.unknown()).nullable().optional(),
+  extra_info: z18.record(z18.unknown()).nullable().optional(),
+  version: z18.number().int().optional()
+}).passthrough();
+var ErrorLogListResponseSchema = z18.object({ pagination: RedTeamPaginationSchema, data: z18.array(ErrorLogSchema) }).passthrough();
+var TargetCreateRequestSchema = z18.object({
+  name: z18.string(),
+  description: z18.unknown().optional(),
+  target_type: z18.unknown().optional(),
+  connection_type: z18.unknown().optional(),
+  api_endpoint_type: z18.unknown().optional(),
+  response_mode: z18.unknown().optional(),
+  connection_params: z18.unknown().optional(),
+  session_supported: z18.boolean().optional(),
+  target_metadata: z18.unknown().optional(),
+  target_background: z18.unknown().optional(),
+  additional_context: z18.unknown().optional(),
+  extra_info: z18.unknown().optional(),
+  network_broker_channel_uuid: z18.unknown().optional()
+}).passthrough();
+var TargetUpdateRequestSchema = z18.object({
+  name: z18.string(),
+  description: z18.unknown().optional(),
+  target_type: z18.unknown().optional(),
+  connection_type: z18.unknown().optional(),
+  api_endpoint_type: z18.unknown().optional(),
+  response_mode: z18.unknown().optional(),
+  connection_params: z18.unknown().optional(),
+  session_supported: z18.boolean().optional(),
+  target_metadata: z18.unknown().optional(),
+  target_background: z18.unknown().optional(),
+  additional_context: z18.unknown().optional(),
+  extra_info: z18.unknown().optional(),
+  network_broker_channel_uuid: z18.unknown().optional()
+}).passthrough();
+var TargetContextUpdateSchema = z18.object({
+  target_background: z18.unknown().optional(),
+  additional_context: z18.unknown().optional()
+}).passthrough();
+var TargetResponseSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  name: z18.string(),
+  status: z18.unknown(),
+  active: z18.boolean(),
+  validated: z18.boolean(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  description: z18.unknown().optional(),
+  target_type: z18.unknown().optional(),
+  connection_type: z18.unknown().optional(),
+  api_endpoint_type: z18.unknown().optional(),
+  response_mode: z18.unknown().optional(),
+  session_supported: z18.boolean().optional(),
+  extra_info: z18.unknown().optional(),
+  version: z18.unknown().optional(),
+  secret_version: z18.unknown().optional(),
+  created_by_user_id: z18.unknown().optional(),
+  updated_by_user_id: z18.unknown().optional(),
+  target_metadata: z18.unknown().optional(),
+  target_background: z18.unknown().optional(),
+  profiling_status: z18.unknown().optional(),
+  additional_context: z18.unknown().optional()
+}).passthrough();
+var TargetListItemSchema = z18.object({
+  uuid: z18.string(),
+  tsg_id: z18.string(),
+  name: z18.string(),
+  status: z18.unknown(),
+  active: z18.boolean(),
+  validated: z18.boolean(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  description: z18.unknown().optional(),
+  target_type: z18.unknown().optional(),
+  connection_type: z18.unknown().optional(),
+  api_endpoint_type: z18.unknown().optional(),
+  response_mode: z18.unknown().optional(),
+  session_supported: z18.boolean().optional(),
+  extra_info: z18.unknown().optional(),
+  version: z18.unknown().optional(),
+  secret_version: z18.unknown().optional(),
+  created_by_user_id: z18.unknown().optional(),
+  updated_by_user_id: z18.unknown().optional()
+}).passthrough();
+var TargetListSchema = z18.object({ pagination: RedTeamPaginationSchema, data: z18.array(TargetListItemSchema).optional() }).passthrough();
+var TargetProbeRequestSchema = z18.object({
+  name: z18.string(),
+  uuid: z18.unknown().optional(),
+  description: z18.unknown().optional(),
+  target_type: z18.unknown().optional(),
+  connection_type: z18.unknown().optional(),
+  api_endpoint_type: z18.unknown().optional(),
+  response_mode: z18.unknown().optional(),
+  connection_params: z18.unknown().optional(),
+  session_supported: z18.boolean().optional(),
+  target_metadata: z18.unknown().optional(),
+  target_background: z18.unknown().optional(),
+  additional_context: z18.unknown().optional(),
+  extra_info: z18.unknown().optional(),
+  network_broker_channel_uuid: z18.unknown().optional(),
+  probe_fields: z18.unknown().optional()
+}).passthrough();
+var TargetProfileResponseSchema = z18.object({
+  target_id: z18.string(),
+  target_version: z18.number().int(),
+  status: z18.string(),
+  profiling_status: z18.unknown().optional(),
+  target_background: z18.unknown().optional(),
+  additional_context: z18.unknown().optional(),
+  ai_generated_fields: z18.unknown().optional(),
+  other_details: z18.unknown().optional()
+}).passthrough();
+var BaseResponseSchema = z18.object({
+  message: z18.string(),
+  status: z18.number().int()
+});
+var PromptSetStatsSchema = z18.object({
+  total_prompts: z18.number().int(),
+  active_prompts: z18.number().int(),
+  inactive_prompts: z18.number().int(),
+  failed_prompts: z18.number().int().optional(),
+  validation_prompts: z18.number().int().optional()
+}).passthrough();
+var CustomPromptSetCreateRequestSchema = z18.object({
+  name: z18.string(),
+  description: z18.unknown().optional(),
+  property_names: z18.array(z18.string()).optional()
+});
+var CustomPromptSetUpdateRequestSchema = z18.object({
+  name: z18.unknown().optional(),
+  description: z18.unknown().optional(),
+  archive: z18.unknown().optional(),
+  property_names: z18.unknown().optional()
+}).passthrough();
+var CustomPromptSetArchiveRequestSchema = z18.object({ archive: z18.boolean() });
+var CustomPromptSetResponseSchema = z18.object({
+  uuid: z18.string(),
+  name: z18.string(),
+  active: z18.boolean(),
+  archive: z18.boolean(),
+  status: z18.string(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  description: z18.unknown().optional(),
+  property_names: z18.array(z18.string()).optional(),
+  properties: z18.array(z18.unknown()).optional(),
+  stats: z18.unknown().optional(),
+  extra_info: z18.unknown().optional(),
+  version: z18.unknown().optional(),
+  created_by_user_id: z18.unknown().optional(),
+  updated_by_user_id: z18.unknown().optional()
+}).passthrough();
+var CustomPromptSetListItemSchema = z18.object({
+  uuid: z18.string(),
+  name: z18.string(),
+  active: z18.boolean(),
+  archive: z18.boolean(),
+  status: z18.string(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  description: z18.unknown().optional(),
+  property_names: z18.array(z18.string()).optional(),
+  stats: z18.unknown().optional(),
+  created_by_user_id: z18.unknown().optional()
+}).passthrough();
+var CustomPromptSetListSchema = z18.object({
+  pagination: RedTeamPaginationSchema,
+  data: z18.array(CustomPromptSetListItemSchema).optional()
+}).passthrough();
+var CustomPromptSetListActiveSchema = z18.object({ data: z18.array(CustomPromptSetListItemSchema).optional() }).passthrough();
+var CustomPromptSetReferenceSchema = z18.object({
+  uuid: z18.string(),
+  name: z18.string(),
+  status: z18.string(),
+  active: z18.boolean(),
+  tsg_id: z18.string(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  version: z18.unknown().optional()
+}).passthrough();
+var CustomPromptSetVersionInfoSchema = z18.object({
+  uuid: z18.string(),
+  status: z18.string(),
+  is_latest: z18.boolean(),
+  version: z18.unknown().optional(),
+  stats: z18.unknown().optional(),
+  snapshot_created_at: z18.unknown().optional()
+}).passthrough();
+var CustomPromptCreateRequestSchema = z18.object({
+  prompt: z18.string(),
+  prompt_set_id: z18.string(),
+  goal: z18.unknown().optional(),
+  properties: z18.unknown().optional()
+});
+var CustomPromptUpdateRequestSchema = z18.object({
+  prompt: z18.unknown().optional(),
+  goal: z18.unknown().optional(),
+  properties: z18.unknown().optional()
+}).passthrough();
+var CustomPromptResponseSchema = z18.object({
+  uuid: z18.string(),
+  prompt: z18.string(),
+  user_defined_goal: z18.boolean(),
+  status: z18.string(),
+  active: z18.boolean(),
+  prompt_set_id: z18.string(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  goal: z18.unknown().optional(),
+  properties: z18.unknown().optional(),
+  property_assignments: z18.array(z18.unknown()).optional(),
+  detector_category: z18.unknown().optional(),
+  severity: z18.unknown().optional(),
+  extra_info: z18.unknown().optional()
+}).passthrough();
+var CustomPromptListItemSchema = z18.object({
+  uuid: z18.string(),
+  prompt: z18.string(),
+  user_defined_goal: z18.boolean(),
+  status: z18.string(),
+  active: z18.boolean(),
+  created_at: z18.string(),
+  updated_at: z18.string(),
+  goal: z18.unknown().optional(),
+  properties: z18.unknown().optional()
+}).passthrough();
+var CustomPromptListSchema = z18.object({
+  pagination: RedTeamPaginationSchema,
+  data: z18.array(CustomPromptListItemSchema).optional()
+}).passthrough();
+var PropertyNameCreateRequestSchema = z18.object({ name: z18.string() });
+var PropertyValueCreateRequestSchema = z18.object({
+  property_name: z18.string(),
+  property_value: z18.string()
+});
+var PropertyDefinitionSchema = z18.object({
+  property_name: z18.string(),
+  created_at: z18.string()
+});
+var PropertyNamesListResponseSchema = z18.object({ data: z18.array(PropertyDefinitionSchema).optional() }).passthrough();
+var PropertyValuesResponseSchema = z18.object({
+  name: z18.string(),
+  values: z18.array(z18.string()).optional()
+}).passthrough();
+var PropertyValuesMultipleResponseSchema = z18.object({ data: z18.record(z18.array(z18.string())).optional() }).passthrough();
+var DashboardOverviewResponseSchema = z18.object({
+  total_targets: z18.number().int(),
+  targets_by_type: z18.array(CountByNameSchema).optional()
+}).passthrough();
+
+// src/models/oauth-token.ts
+import { z as z19 } from "zod";
+var OAuthTokenResponseSchema = z19.object({
+  access_token: z19.string(),
+  token_type: z19.string().optional(),
+  expires_in: z19.number(),
+  scope: z19.string().optional()
 });
 
 // src/management/oauth-client.ts
@@ -816,6 +2324,10 @@ var OAuthClient = class {
     this.tsgId = opts.tsgId;
     this.tokenEndpoint = opts.tokenEndpoint ?? DEFAULT_TOKEN_ENDPOINT;
   }
+  /**
+   * Get a valid access token, refreshing if needed.
+   * @returns Bearer access token string.
+   */
   async getToken() {
     if (this.accessToken && Date.now() < this.expiresAt - TOKEN_BUFFER_MS) {
       return this.accessToken;
@@ -828,6 +2340,7 @@ var OAuthClient = class {
     });
     return this.pendingFetch;
   }
+  /** Clear the cached token, forcing a fresh fetch on next call. */
   clearToken() {
     this.accessToken = null;
     this.expiresAt = 0;
@@ -872,76 +2385,43 @@ var OAuthClient = class {
 };
 
 // src/management/management-http-client.ts
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function extractError(body, status) {
-  try {
-    const parsed = JSON.parse(body);
-    return parsed.error_message ?? parsed.message ?? `API error ${status}: ${body}`;
-  } catch {
-    return body ? `API error ${status}: ${body}` : `API error ${status}`;
-  }
-}
 async function managementHttpRequest(opts) {
   const { method, baseUrl, path, body, params, oauthClient, numRetries } = opts;
   let hadTokenRefresh = false;
-  for (let attempt = 0; attempt <= numRetries; attempt++) {
-    const token = await oauthClient.getToken();
-    const stripped = baseUrl.replace(/\/+$/, "");
-    const url = new URL(`${stripped}${path}`);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        url.searchParams.set(key, value);
+  const response = await executeWithRetry({
+    maxRetries: numRetries,
+    execute: async () => {
+      const token = await oauthClient.getToken();
+      const stripped = baseUrl.replace(/\/+$/, "");
+      const url = new URL(`${stripped}${path}`);
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          url.searchParams.set(key, value);
+        }
       }
-    }
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      "User-Agent": USER_AGENT
-    };
-    let bodyStr;
-    if (body !== void 0) {
-      headers["Content-Type"] = "application/json";
-      bodyStr = JSON.stringify(body);
-    }
-    let response;
-    try {
-      response = await fetch(url.toString(), {
-        method,
-        headers,
-        body: bodyStr
-      });
-    } catch (err) {
-      if (attempt < numRetries) {
-        await sleep2(Math.pow(2, attempt) * 1e3);
-        continue;
+      const headers = {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": USER_AGENT
+      };
+      let bodyStr;
+      if (body !== void 0) {
+        headers["Content-Type"] = "application/json";
+        bodyStr = JSON.stringify(body);
       }
-      throw new AISecSDKException(
-        err.message ?? "Network error",
-        "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */
-      );
-    }
-    if (response.ok) {
-      const text = await response.text();
-      const data = text ? JSON.parse(text) : {};
-      return { status: response.status, data };
-    }
-    if (response.status === 401 && !hadTokenRefresh) {
-      hadTokenRefresh = true;
-      oauthClient.clearToken();
-      attempt--;
-      continue;
-    }
-    if (HTTP_FORCE_RETRY_STATUS_CODES.includes(response.status) && attempt < numRetries) {
-      await sleep2(Math.pow(2, attempt) * 1e3);
-      continue;
+      return fetch(url.toString(), { method, headers, body: bodyStr });
+    },
+    onRetryableFailure: async (response2) => {
+      if (response2.status === 401 && !hadTokenRefresh) {
+        hadTokenRefresh = true;
+        oauthClient.clearToken();
+        return true;
+      }
+      return false;
     }
-    const errorText = await response.text();
-    const errorMessage = extractError(errorText, response.status);
-    const errorType = response.status >= 500 ? "AISEC_SERVER_SIDE_ERROR" /* SERVER_SIDE_ERROR */ : "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */;
-    throw new AISecSDKException(errorMessage, errorType);
-  }
-  throw new AISecSDKException("Max retries exceeded", "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */);
+  });
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : {};
+  return { status: response.status, data };
 }
 
 // src/management/profiles.ts
@@ -956,6 +2436,11 @@ var ProfilesClient = class {
     this.tsgId = opts.tsgId;
     this.numRetries = opts.numRetries;
   }
+  /**
+   * Create a new security profile.
+   * @param request - Profile configuration.
+   * @returns The created security profile.
+   */
   async create(request) {
     const res = await managementHttpRequest({
       method: "POST",
@@ -967,6 +2452,11 @@ var ProfilesClient = class {
     });
     return res.data;
   }
+  /**
+   * List security profiles for the TSG.
+   * @param opts - Pagination options.
+   * @returns Paginated list of security profiles.
+   */
   async list(opts) {
     const params = {
       offset: String(opts?.offset ?? 0),
@@ -982,6 +2472,12 @@ var ProfilesClient = class {
     });
     return res.data;
   }
+  /**
+   * Update an existing security profile.
+   * @param profileId - UUID of the profile to update.
+   * @param request - Updated profile configuration.
+   * @returns The updated security profile.
+   */
   async update(profileId, request) {
     if (!isValidUuid(profileId)) {
       throw new AISecSDKException(
@@ -999,6 +2495,11 @@ var ProfilesClient = class {
     });
     return res.data;
   }
+  /**
+   * Delete a security profile.
+   * @param profileId - UUID of the profile to delete.
+   * @returns Deletion confirmation message.
+   */
   async delete(profileId) {
     if (!isValidUuid(profileId)) {
       throw new AISecSDKException(
@@ -1029,6 +2530,11 @@ var TopicsClient = class {
     this.tsgId = opts.tsgId;
     this.numRetries = opts.numRetries;
   }
+  /**
+   * Create a new custom topic.
+   * @param request - Topic definition with name, description, and examples.
+   * @returns The created custom topic.
+   */
   async create(request) {
     const res = await managementHttpRequest({
       method: "POST",
@@ -1040,6 +2546,11 @@ var TopicsClient = class {
     });
     return res.data;
   }
+  /**
+   * List custom topics for the TSG.
+   * @param opts - Pagination options.
+   * @returns Paginated list of custom topics.
+   */
   async list(opts) {
     const params = {
       offset: String(opts?.offset ?? 0),
@@ -1055,6 +2566,12 @@ var TopicsClient = class {
     });
     return res.data;
   }
+  /**
+   * Update an existing custom topic.
+   * @param topicId - UUID of the topic to update.
+   * @param request - Updated topic definition.
+   * @returns The updated custom topic.
+   */
   async update(topicId, request) {
     if (!isValidUuid(topicId)) {
       throw new AISecSDKException(
@@ -1072,6 +2589,11 @@ var TopicsClient = class {
     });
     return res.data;
   }
+  /**
+   * Delete a custom topic. Fails if topic is referenced by a profile.
+   * @param topicId - UUID of the topic to delete.
+   * @returns Deletion confirmation message.
+   */
   async delete(topicId) {
     if (!isValidUuid(topicId)) {
       throw new AISecSDKException(
@@ -1088,6 +2610,11 @@ var TopicsClient = class {
     });
     return res.data;
   }
+  /**
+   * Force-delete a custom topic, removing it from any referencing profiles.
+   * @param topicId - UUID of the topic to force-delete.
+   * @returns Deletion confirmation message.
+   */
   async forceDelete(topicId) {
     if (!isValidUuid(topicId)) {
       throw new AISecSDKException(
@@ -1158,39 +2685,1823 @@ var ManagementClient = class {
     });
   }
 };
+
+// src/model-security/scans-client.ts
+function buildListParams(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var ModelSecurityScansClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /**
+   * Create a new model security scan.
+   * @param request - Scan creation request body.
+   * @returns The created scan response.
+   */
+  async create(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: MODEL_SEC_SCANS_PATH,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * List model security scans with optional filters.
+   * @param opts - Pagination and filter options.
+   * @returns Paginated list of scans.
+   */
+  async list(opts) {
+    const params = buildListParams(opts);
+    if (opts?.eval_outcome !== void 0) params.eval_outcome = opts.eval_outcome;
+    if (opts?.source_type !== void 0) params.source_type = opts.source_type;
+    if (opts?.scan_origin !== void 0) params.scan_origin = opts.scan_origin;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: MODEL_SEC_SCANS_PATH,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single scan by UUID.
+   * @param uuid - Scan UUID.
+   * @returns The scan response.
+   */
+  async get(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get rule evaluations for a scan.
+   * @param scanUuid - Scan UUID.
+   * @param opts - Pagination options.
+   * @returns Paginated list of rule evaluations.
+   */
+  async getEvaluations(scanUuid, opts) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${scanUuid}/evaluations`,
+      params: buildListParams(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get files for a scan.
+   * @param scanUuid - Scan UUID.
+   * @param opts - Pagination and file filter options.
+   * @returns Paginated list of files.
+   */
+  async getFiles(scanUuid, opts) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const params = buildListParams(opts);
+    if (opts?.type !== void 0) params.type = opts.type;
+    if (opts?.result !== void 0) params.result = opts.result;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${scanUuid}/files`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Add labels to a scan (merge with existing).
+   * @param scanUuid - Scan UUID.
+   * @param request - Labels to add.
+   * @returns Labels response.
+   */
+  async addLabels(scanUuid, request) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${scanUuid}/labels`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Set labels on a scan (replace all existing).
+   * @param scanUuid - Scan UUID.
+   * @param request - Labels to set.
+   * @returns Labels response.
+   */
+  async setLabels(scanUuid, request) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${scanUuid}/labels`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Delete labels from a scan by key.
+   * @param scanUuid - Scan UUID.
+   * @param keys - Label keys to delete.
+   */
+  async deleteLabels(scanUuid, keys) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const url = new URL(`https://placeholder${MODEL_SEC_SCANS_PATH}/${scanUuid}/labels`);
+    for (const key of keys) {
+      url.searchParams.append("keys", key);
+    }
+    const queryString = url.searchParams.toString();
+    const pathWithQuery = `${MODEL_SEC_SCANS_PATH}/${scanUuid}/labels${queryString ? `?${queryString}` : ""}`;
+    await managementHttpRequest({
+      method: "DELETE",
+      baseUrl: this.baseUrl,
+      path: pathWithQuery,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+  }
+  /**
+   * Get rule violations for a scan.
+   * @param scanUuid - Scan UUID.
+   * @param opts - Pagination options.
+   * @returns Paginated list of violations.
+   */
+  async getViolations(scanUuid, opts) {
+    if (!isValidUuid(scanUuid)) {
+      throw new AISecSDKException(
+        `Invalid scan uuid: ${scanUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/${scanUuid}/rule-violations`,
+      params: buildListParams(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get distinct label keys across all scans.
+   * @param opts - Pagination options.
+   * @returns Paginated list of label keys.
+   */
+  async getLabelKeys(opts) {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/label-keys`,
+      params: buildListParams(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get distinct values for a label key.
+   * @param key - Label key to get values for.
+   * @param opts - Pagination options.
+   * @returns Paginated list of label values.
+   */
+  async getLabelValues(key, opts) {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SCANS_PATH}/label-keys/${encodeURIComponent(key)}/values`,
+      params: buildListParams(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single rule evaluation by UUID.
+   * @param uuid - Evaluation UUID.
+   * @returns The rule evaluation response.
+   */
+  async getEvaluation(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid evaluation uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_EVALUATIONS_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single violation by UUID.
+   * @param uuid - Violation UUID.
+   * @returns The violation response.
+   */
+  async getViolation(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid violation uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_VIOLATIONS_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/model-security/security-groups-client.ts
+function buildListParams2(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var ModelSecurityGroupsClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /**
+   * Create a new security group.
+   * @param request - Security group creation request.
+   * @returns The created security group.
+   */
+  async create(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: MODEL_SEC_SECURITY_GROUPS_PATH,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * List security groups with optional filters.
+   * @param opts - Pagination and filter options.
+   * @returns Paginated list of security groups.
+   */
+  async list(opts) {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: MODEL_SEC_SECURITY_GROUPS_PATH,
+      params: buildListParams2(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single security group by UUID.
+   * @param uuid - Security group UUID.
+   * @returns The security group.
+   */
+  async get(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Update an existing security group.
+   * @param uuid - Security group UUID.
+   * @param request - Updated security group fields.
+   * @returns The updated security group.
+   */
+  async update(uuid, request) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${uuid}`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Delete a security group.
+   * @param uuid - Security group UUID.
+   */
+  async delete(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    await managementHttpRequest({
+      method: "DELETE",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+  }
+  /**
+   * List rule instances for a security group.
+   * @param securityGroupUuid - Security group UUID.
+   * @param opts - Pagination options.
+   * @returns Paginated list of rule instances.
+   */
+  async listRuleInstances(securityGroupUuid, opts) {
+    if (!isValidUuid(securityGroupUuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${securityGroupUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${securityGroupUuid}/rule-instances`,
+      params: buildListParams2(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single rule instance within a security group.
+   * @param securityGroupUuid - Security group UUID.
+   * @param ruleInstanceUuid - Rule instance UUID.
+   * @returns The rule instance.
+   */
+  async getRuleInstance(securityGroupUuid, ruleInstanceUuid) {
+    if (!isValidUuid(securityGroupUuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${securityGroupUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (!isValidUuid(ruleInstanceUuid)) {
+      throw new AISecSDKException(
+        `Invalid rule instance uuid: ${ruleInstanceUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${securityGroupUuid}/rule-instances/${ruleInstanceUuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Update a rule instance within a security group.
+   * @param securityGroupUuid - Security group UUID.
+   * @param ruleInstanceUuid - Rule instance UUID.
+   * @param request - Updated rule instance fields.
+   * @returns The updated rule instance.
+   */
+  async updateRuleInstance(securityGroupUuid, ruleInstanceUuid, request) {
+    if (!isValidUuid(securityGroupUuid)) {
+      throw new AISecSDKException(
+        `Invalid security group uuid: ${securityGroupUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (!isValidUuid(ruleInstanceUuid)) {
+      throw new AISecSDKException(
+        `Invalid rule instance uuid: ${ruleInstanceUuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_GROUPS_PATH}/${securityGroupUuid}/rule-instances/${ruleInstanceUuid}`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/model-security/security-rules-client.ts
+function buildListParams3(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var ModelSecurityRulesClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /**
+   * List available security rules.
+   * @param opts - Pagination options.
+   * @returns Paginated list of security rules.
+   */
+  async list(opts) {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: MODEL_SEC_SECURITY_RULES_PATH,
+      params: buildListParams3(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /**
+   * Get a single security rule by UUID.
+   * @param uuid - Security rule UUID.
+   * @returns The security rule.
+   */
+  async get(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid security rule uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${MODEL_SEC_SECURITY_RULES_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/model-security/client.ts
+var ModelSecurityClient = class {
+  /** Data plane scan operations. */
+  scans;
+  /** Management plane security group operations. */
+  securityGroups;
+  /** Management plane security rule operations (read-only). */
+  securityRules;
+  mgmtEndpoint;
+  oauthClient;
+  numRetries;
+  constructor(opts = {}) {
+    const clientId = opts.clientId ?? process.env[MODEL_SEC_CLIENT_ID] ?? process.env[MGMT_CLIENT_ID];
+    const clientSecret = opts.clientSecret ?? process.env[MODEL_SEC_CLIENT_SECRET] ?? process.env[MGMT_CLIENT_SECRET];
+    const tsgId = opts.tsgId ?? process.env[MODEL_SEC_TSG_ID] ?? process.env[MGMT_TSG_ID];
+    const dataEndpoint = opts.dataEndpoint ?? process.env[MODEL_SEC_DATA_ENDPOINT] ?? DEFAULT_MODEL_SEC_DATA_ENDPOINT;
+    const mgmtEndpoint = opts.mgmtEndpoint ?? process.env[MODEL_SEC_MGMT_ENDPOINT] ?? DEFAULT_MODEL_SEC_MGMT_ENDPOINT;
+    const tokenEndpoint = opts.tokenEndpoint ?? process.env[MODEL_SEC_TOKEN_ENDPOINT] ?? process.env[MGMT_TOKEN_ENDPOINT];
+    const numRetries = Math.min(
+      Math.max(opts.numRetries ?? MAX_NUMBER_OF_RETRIES, 0),
+      MAX_NUMBER_OF_RETRIES
+    );
+    if (!clientId) {
+      throw new AISecSDKException(
+        "clientId is required (option or PANW_MODEL_SEC_CLIENT_ID / PANW_MGMT_CLIENT_ID env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    if (!clientSecret) {
+      throw new AISecSDKException(
+        "clientSecret is required (option or PANW_MODEL_SEC_CLIENT_SECRET / PANW_MGMT_CLIENT_SECRET env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    if (!tsgId) {
+      throw new AISecSDKException(
+        "tsgId is required (option or PANW_MODEL_SEC_TSG_ID / PANW_MGMT_TSG_ID env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    this.oauthClient = new OAuthClient({
+      clientId,
+      clientSecret,
+      tsgId,
+      tokenEndpoint
+    });
+    this.mgmtEndpoint = mgmtEndpoint;
+    this.numRetries = numRetries;
+    this.scans = new ModelSecurityScansClient({
+      baseUrl: dataEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.securityGroups = new ModelSecurityGroupsClient({
+      baseUrl: mgmtEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.securityRules = new ModelSecurityRulesClient({
+      baseUrl: mgmtEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+  }
+  /**
+   * Get PyPI authentication credentials for Google Artifact Registry.
+   * @returns PyPI auth response with URL and expiration.
+   */
+  async getPyPIAuth() {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.mgmtEndpoint,
+      path: MODEL_SEC_PYPI_AUTH_PATH,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/scans-client.ts
+function buildListParams4(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var RedTeamScansClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /** Create a new red team scan job. */
+  async create(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: RED_TEAM_SCAN_PATH,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List red team scan jobs with optional filters. */
+  async list(opts) {
+    const params = buildListParams4(opts);
+    if (opts?.status !== void 0) params.status = opts.status;
+    if (opts?.job_type !== void 0) params.job_type = opts.job_type;
+    if (opts?.target_id !== void 0) params.target_id = opts.target_id;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: RED_TEAM_SCAN_PATH,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get a single scan job by ID. */
+  async get(jobId) {
+    if (!isValidUuid(jobId)) {
+      throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_SCAN_PATH}/${jobId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Abort a running scan job. */
+  async abort(jobId) {
+    if (!isValidUuid(jobId)) {
+      throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+    }
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_SCAN_PATH}/${jobId}/abort`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get all categories with subcategories. */
+  async getCategories() {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: RED_TEAM_CATEGORIES_PATH,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/reports-client.ts
+function buildListParams5(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+function validateJobId(jobId) {
+  if (!isValidUuid(jobId)) {
+    throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+  }
+}
+var RedTeamReportsClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  // -----------------------------------------------------------------------
+  // Static (attack library) report endpoints
+  // -----------------------------------------------------------------------
+  /** List attacks for a static scan. */
+  async listAttacks(jobId, opts) {
+    validateJobId(jobId);
+    const params = buildListParams5(opts);
+    if (opts?.status !== void 0) params.status = opts.status;
+    if (opts?.severity !== void 0) params.severity = opts.severity;
+    if (opts?.category !== void 0) params.category = opts.category;
+    if (opts?.sub_category !== void 0) params.sub_category = opts.sub_category;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/list-attacks`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get attack details for a static scan. */
+  async getAttackDetail(jobId, attackId) {
+    validateJobId(jobId);
+    if (!isValidUuid(attackId)) {
+      throw new AISecSDKException(
+        `Invalid attack id: ${attackId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/attack/${attackId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get multi-turn attack details for a static scan. */
+  async getMultiTurnAttackDetail(jobId, attackId) {
+    validateJobId(jobId);
+    if (!isValidUuid(attackId)) {
+      throw new AISecSDKException(
+        `Invalid attack id: ${attackId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/attack-multi-turn/${attackId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get the attack library report for a static scan. */
+  async getStaticReport(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/report`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get remediation recommendations for a static scan. */
+  async getStaticRemediation(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/remediation`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get runtime security profile config for a static scan. */
+  async getStaticRuntimePolicy(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_STATIC_PATH}/${jobId}/runtime-policy-config`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  // -----------------------------------------------------------------------
+  // Dynamic (agent) report endpoints
+  // -----------------------------------------------------------------------
+  /** Get the agent scan report for a dynamic scan. */
+  async getDynamicReport(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/${jobId}/report`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get remediation recommendations for a dynamic scan. */
+  async getDynamicRemediation(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/${jobId}/remediation`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get runtime security profile config for a dynamic scan. */
+  async getDynamicRuntimePolicy(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/${jobId}/runtime-policy-config`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List goals for a dynamic scan. */
+  async listGoals(jobId, opts) {
+    validateJobId(jobId);
+    const params = buildListParams5(opts);
+    if (opts?.goal_type !== void 0) params.goal_type = opts.goal_type;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/${jobId}/list-goals`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List streams for a goal in a dynamic scan. */
+  async listGoalStreams(jobId, goalId, opts) {
+    validateJobId(jobId);
+    if (!isValidUuid(goalId)) {
+      throw new AISecSDKException(
+        `Invalid goal id: ${goalId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/${jobId}/goal/${goalId}/list-streams`,
+      params: buildListParams5(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  // -----------------------------------------------------------------------
+  // Common report endpoints
+  // -----------------------------------------------------------------------
+  /** Get stream details by stream ID. */
+  async getStreamDetail(streamId) {
+    if (!isValidUuid(streamId)) {
+      throw new AISecSDKException(
+        `Invalid stream id: ${streamId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_DYNAMIC_PATH}/stream/${streamId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Download a report in the specified format. */
+  async downloadReport(jobId, format) {
+    validateJobId(jobId);
+    const params = {};
+    if (format !== void 0) params.file_format = format;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_PATH}/${jobId}/download`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Generate a partial report for a running scan. */
+  async generatePartialReport(jobId) {
+    validateJobId(jobId);
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_REPORT_PATH}/${jobId}/generate-partial-report`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/custom-attack-reports-client.ts
+function buildListParams6(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+function validateJobId2(jobId) {
+  if (!isValidUuid(jobId)) {
+    throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+  }
+}
+var RedTeamCustomAttackReportsClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /** Get custom attack report for a scan. */
+  async getReport(jobId) {
+    validateJobId2(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/report/${jobId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get prompt sets for a custom attack scan. */
+  async getPromptSets(jobId) {
+    validateJobId2(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/report/${jobId}/prompt-sets`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get prompts for a specific prompt set in a scan. */
+  async getPromptsBySet(jobId, promptSetId, opts) {
+    validateJobId2(jobId);
+    if (!isValidUuid(promptSetId)) {
+      throw new AISecSDKException(
+        `Invalid prompt set id: ${promptSetId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/report/${jobId}/prompt-set/${promptSetId}/prompts`,
+      params: buildListParams6(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get details for a specific prompt. */
+  async getPromptDetail(jobId, promptId) {
+    validateJobId2(jobId);
+    if (!isValidUuid(promptId)) {
+      throw new AISecSDKException(
+        `Invalid prompt id: ${promptId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/report/${jobId}/prompt/${promptId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List custom attacks for a scan. */
+  async listCustomAttacks(jobId, opts) {
+    validateJobId2(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/job/${jobId}/list-custom-attacks`,
+      params: buildListParams6(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get attack outputs for a custom attack. */
+  async getAttackOutputs(jobId, attackId) {
+    validateJobId2(jobId);
+    if (!isValidUuid(attackId)) {
+      throw new AISecSDKException(
+        `Invalid attack id: ${attackId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/job/${jobId}/attack/${attackId}/list-outputs`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get property statistics for a custom attack scan. */
+  async getPropertyStats(jobId) {
+    validateJobId2(jobId);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH}/job/${jobId}/property-stats`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/targets-client.ts
+function buildListParams7(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var RedTeamTargetsClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  /** Create a new target. */
+  async create(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: RED_TEAM_TARGET_PATH,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List targets with optional filters. */
+  async list(opts) {
+    const params = buildListParams7(opts);
+    if (opts?.target_type !== void 0) params.target_type = opts.target_type;
+    if (opts?.status !== void 0) params.status = opts.status;
+    if (opts?.active !== void 0) params.active = String(opts.active);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: RED_TEAM_TARGET_PATH,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get a target by UUID. */
+  async get(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid target uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Update a target. */
+  async update(uuid, request) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid target uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/${uuid}`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Delete a target. */
+  async delete(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid target uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "DELETE",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Run profiling probes on a target. */
+  async probe(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/probe`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get profiling results for a target. */
+  async getProfile(uuid) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid target uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/${uuid}/profile`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Update a target profile (background + additional context). */
+  async updateProfile(uuid, request) {
+    if (!isValidUuid(uuid)) {
+      throw new AISecSDKException(
+        `Invalid target uuid: ${uuid}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_TARGET_PATH}/${uuid}/profile`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/custom-attacks-client.ts
+function buildListParams8(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+function validateUuid(uuid, label) {
+  if (!isValidUuid(uuid)) {
+    throw new AISecSDKException(`Invalid ${label}: ${uuid}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+  }
+}
+var RedTeamCustomAttacksClient = class {
+  baseUrl;
+  oauthClient;
+  numRetries;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.oauthClient = opts.oauthClient;
+    this.numRetries = opts.numRetries;
+  }
+  // -----------------------------------------------------------------------
+  // Prompt Set operations
+  // -----------------------------------------------------------------------
+  /** Create a new custom prompt set. */
+  async createPromptSet(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List custom prompt sets. */
+  async listPromptSets(opts) {
+    const params = buildListParams8(opts);
+    if (opts?.active !== void 0) params.active = String(opts.active);
+    if (opts?.archive !== void 0) params.archive = String(opts.archive);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/list-custom-prompt-sets`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get a prompt set by UUID. */
+  async getPromptSet(uuid) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Update a prompt set. */
+  async updatePromptSet(uuid, request) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${uuid}`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Archive or unarchive a prompt set. */
+  async archivePromptSet(uuid, request) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${uuid}/archive`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Resolve a prompt set reference for data plane consumption. */
+  async getPromptSetReference(uuid) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${uuid}/reference`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get version information for a prompt set. */
+  async getPromptSetVersionInfo(uuid) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${uuid}/version-info`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List active prompt sets (for data plane). */
+  async listActivePromptSets() {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/active-custom-prompt-sets`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Download CSV template for a prompt set. */
+  async downloadTemplate(uuid) {
+    validateUuid(uuid, "prompt set uuid");
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/download-template/${uuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  // -----------------------------------------------------------------------
+  // Prompt operations
+  // -----------------------------------------------------------------------
+  /** Create a new custom prompt. */
+  async createPrompt(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/custom-prompt`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List prompts in a prompt set. */
+  async listPrompts(promptSetUuid, opts) {
+    validateUuid(promptSetUuid, "prompt set uuid");
+    const params = buildListParams8(opts);
+    if (opts?.active !== void 0) params.active = String(opts.active);
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${promptSetUuid}/list-custom-prompts`,
+      params,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get a prompt by UUID. */
+  async getPrompt(promptSetUuid, promptUuid) {
+    validateUuid(promptSetUuid, "prompt set uuid");
+    validateUuid(promptUuid, "prompt uuid");
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${promptSetUuid}/custom-prompt/${promptUuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Update a prompt. */
+  async updatePrompt(promptSetUuid, promptUuid, request) {
+    validateUuid(promptSetUuid, "prompt set uuid");
+    validateUuid(promptUuid, "prompt uuid");
+    const res = await managementHttpRequest({
+      method: "PUT",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${promptSetUuid}/custom-prompt/${promptUuid}`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Delete a prompt. */
+  async deletePrompt(promptSetUuid, promptUuid) {
+    validateUuid(promptSetUuid, "prompt set uuid");
+    validateUuid(promptUuid, "prompt uuid");
+    const res = await managementHttpRequest({
+      method: "DELETE",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/custom-prompt-set/${promptSetUuid}/custom-prompt/${promptUuid}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  // -----------------------------------------------------------------------
+  // Property operations
+  // -----------------------------------------------------------------------
+  /** Get all property names. */
+  async getPropertyNames() {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/property-names`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Create a new property name. */
+  async createPropertyName(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/property-names`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get values for a property name. */
+  async getPropertyValues(propertyName) {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/property-values/${encodeURIComponent(propertyName)}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get values for multiple property names. */
+  async getPropertyValuesMultiple(propertyNames) {
+    const url = new URL(`https://placeholder${RED_TEAM_CUSTOM_ATTACK_PATH}/property-values`);
+    for (const name of propertyNames) {
+      url.searchParams.append("property_names", name);
+    }
+    const queryString = url.searchParams.toString();
+    const pathWithQuery = `${RED_TEAM_CUSTOM_ATTACK_PATH}/property-values${queryString ? `?${queryString}` : ""}`;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.baseUrl,
+      path: pathWithQuery,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Create a property value. */
+  async createPropertyValue(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.baseUrl,
+      path: `${RED_TEAM_CUSTOM_ATTACK_PATH}/property-values`,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
+
+// src/red-team/client.ts
+function buildListParams9(opts) {
+  const params = {};
+  if (opts?.skip !== void 0) params.skip = String(opts.skip);
+  if (opts?.limit !== void 0) params.limit = String(opts.limit);
+  if (opts?.sort_by !== void 0) params.sort_by = opts.sort_by;
+  if (opts?.sort_direction !== void 0) params.sort_direction = opts.sort_direction;
+  if (opts?.search !== void 0) params.search = opts.search;
+  return params;
+}
+var RedTeamClient = class {
+  /** Data plane scan operations. */
+  scans;
+  /** Data plane report operations. */
+  reports;
+  /** Data plane custom attack report operations. */
+  customAttackReports;
+  /** Management plane target operations. */
+  targets;
+  /** Management plane custom attack/prompt set operations. */
+  customAttacks;
+  dataEndpoint;
+  mgmtEndpoint;
+  oauthClient;
+  numRetries;
+  constructor(opts = {}) {
+    const clientId = opts.clientId ?? process.env[RED_TEAM_CLIENT_ID] ?? process.env[MGMT_CLIENT_ID];
+    const clientSecret = opts.clientSecret ?? process.env[RED_TEAM_CLIENT_SECRET] ?? process.env[MGMT_CLIENT_SECRET];
+    const tsgId = opts.tsgId ?? process.env[RED_TEAM_TSG_ID] ?? process.env[MGMT_TSG_ID];
+    const dataEndpoint = opts.dataEndpoint ?? process.env[RED_TEAM_DATA_ENDPOINT] ?? DEFAULT_RED_TEAM_DATA_ENDPOINT;
+    const mgmtEndpoint = opts.mgmtEndpoint ?? process.env[RED_TEAM_MGMT_ENDPOINT] ?? DEFAULT_RED_TEAM_MGMT_ENDPOINT;
+    const tokenEndpoint = opts.tokenEndpoint ?? process.env[RED_TEAM_TOKEN_ENDPOINT] ?? process.env[MGMT_TOKEN_ENDPOINT];
+    const numRetries = Math.min(
+      Math.max(opts.numRetries ?? MAX_NUMBER_OF_RETRIES, 0),
+      MAX_NUMBER_OF_RETRIES
+    );
+    if (!clientId) {
+      throw new AISecSDKException(
+        "clientId is required (option or PANW_RED_TEAM_CLIENT_ID / PANW_MGMT_CLIENT_ID env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    if (!clientSecret) {
+      throw new AISecSDKException(
+        "clientSecret is required (option or PANW_RED_TEAM_CLIENT_SECRET / PANW_MGMT_CLIENT_SECRET env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    if (!tsgId) {
+      throw new AISecSDKException(
+        "tsgId is required (option or PANW_RED_TEAM_TSG_ID / PANW_MGMT_TSG_ID env var)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    this.oauthClient = new OAuthClient({ clientId, clientSecret, tsgId, tokenEndpoint });
+    this.dataEndpoint = dataEndpoint;
+    this.mgmtEndpoint = mgmtEndpoint;
+    this.numRetries = numRetries;
+    this.scans = new RedTeamScansClient({
+      baseUrl: dataEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.reports = new RedTeamReportsClient({
+      baseUrl: dataEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.customAttackReports = new RedTeamCustomAttackReportsClient({
+      baseUrl: dataEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.targets = new RedTeamTargetsClient({
+      baseUrl: mgmtEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+    this.customAttacks = new RedTeamCustomAttacksClient({
+      baseUrl: mgmtEndpoint,
+      oauthClient: this.oauthClient,
+      numRetries
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Data plane convenience methods
+  // -----------------------------------------------------------------------
+  /** Get scan statistics and risk profile (data plane dashboard). */
+  async getScanStatistics(params) {
+    const p = {};
+    if (params?.date_range !== void 0) p.date_range = params.date_range;
+    if (params?.target_id !== void 0) p.target_id = params.target_id;
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.dataEndpoint,
+      path: `${RED_TEAM_DASHBOARD_PATH}/scan-statistics`,
+      params: p,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get score trend for a target (data plane dashboard). */
+  async getScoreTrend(targetId) {
+    if (!isValidUuid(targetId)) {
+      throw new AISecSDKException(
+        `Invalid target id: ${targetId}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.dataEndpoint,
+      path: `${RED_TEAM_DASHBOARD_PATH}/score-trend`,
+      params: { target_id: targetId },
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get quota summary. */
+  async getQuota() {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.dataEndpoint,
+      path: RED_TEAM_QUOTA_PATH,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** List error logs for a scan job. */
+  async getErrorLogs(jobId, opts) {
+    if (!isValidUuid(jobId)) {
+      throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.dataEndpoint,
+      path: `${RED_TEAM_ERROR_LOG_PATH}/${jobId}`,
+      params: buildListParams9(opts),
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Update sentiment for a scan report. */
+  async updateSentiment(request) {
+    const res = await managementHttpRequest({
+      method: "POST",
+      baseUrl: this.dataEndpoint,
+      path: RED_TEAM_SENTIMENT_PATH,
+      body: request,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  /** Get sentiment for a scan report. */
+  async getSentiment(jobId) {
+    if (!isValidUuid(jobId)) {
+      throw new AISecSDKException(`Invalid job id: ${jobId}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+    }
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.dataEndpoint,
+      path: `${RED_TEAM_SENTIMENT_PATH}/${jobId}`,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+  // -----------------------------------------------------------------------
+  // Management plane convenience methods
+  // -----------------------------------------------------------------------
+  /** Get management dashboard overview. */
+  async getDashboardOverview() {
+    const res = await managementHttpRequest({
+      method: "GET",
+      baseUrl: this.mgmtEndpoint,
+      path: RED_TEAM_MGMT_DASHBOARD_PATH,
+      oauthClient: this.oauthClient,
+      numRetries: this.numRetries
+    });
+    return res.data;
+  }
+};
 export {
   AISecSDKException,
   AI_SEC_API_ENDPOINT,
   AI_SEC_API_KEY,
   AI_SEC_API_TOKEN,
   ASYNC_SCAN_PATH,
+  Action,
   AgentMetaSchema,
   AiProfileSchema,
+  ApiEndpointType,
   AsyncScanObjectSchema,
   AsyncScanResponseSchema,
+  AttackDetailResponseSchema,
+  AttackListItemSchema,
+  AttackListResponseSchema,
+  AttackMultiTurnDetailResponseSchema,
+  AttackMultiTurnOutputSchema,
+  AttackOutputSchema,
+  AttackStatus,
+  AttackType,
+  AuthType,
   BEARER,
+  BaseResponseSchema,
+  BrandSubCategory,
+  Category,
+  CategoryModelSchema,
+  CategoryReportSchema,
+  ComplianceReportSchema,
+  ComplianceSubCategory,
+  ComplianceTechniqueSchema,
   Content,
+  CountByNameSchema,
+  CountedQuotaEnum,
   CreateCustomTopicRequestSchema,
   CreateSecurityProfileRequestSchema,
+  CustomAttackOutputSchema,
+  CustomAttackReportResponseSchema,
+  CustomAttacksListResponseSchema,
+  CustomJobMetadataSchema,
+  CustomPromptCreateRequestSchema,
+  CustomPromptListItemSchema,
+  CustomPromptListSchema,
+  CustomPromptResponseSchema,
+  CustomPromptSetArchiveRequestSchema,
+  CustomPromptSetCreateRequestSchema,
+  CustomPromptSetListActiveSchema,
+  CustomPromptSetListItemSchema,
+  CustomPromptSetListSchema,
+  CustomPromptSetReferenceSchema,
+  CustomPromptSetResponseSchema,
+  CustomPromptSetUpdateRequestSchema,
+  CustomPromptSetVersionInfoSchema,
+  CustomPromptUpdateRequestSchema,
   CustomTopicListResponseSchema,
   CustomTopicSchema,
   DEFAULT_ENDPOINT,
   DEFAULT_MGMT_ENDPOINT,
+  DEFAULT_MODEL_SEC_DATA_ENDPOINT,
+  DEFAULT_MODEL_SEC_MGMT_ENDPOINT,
+  DEFAULT_RED_TEAM_DATA_ENDPOINT,
+  DEFAULT_RED_TEAM_MGMT_ENDPOINT,
   DEFAULT_TOKEN_ENDPOINT,
   DSDetailResultSchema,
   DSResultMetadataSchema,
+  DashboardOverviewResponseSchema,
+  DateRangeFilter,
   DeleteProfileConflictSchema,
   DeleteProfileResponseSchema,
   DeleteTopicConflictSchema,
   DeleteTopicResponseSchema,
   DetectionServiceResultSchema,
   DlpReportSchema,
+  DynamicJobMetadataSchema,
+  DynamicJobReportSchema,
+  DynamicJobReportStatsSchema,
+  ErrorCodes,
+  ErrorLogListResponseSchema,
+  ErrorLogSchema,
   ErrorResponseSchema,
+  ErrorSource,
   ErrorType,
+  EvalOutcome,
+  EvalSummarySchema,
+  FileFormat,
+  FileListSchema,
+  FileResponseSchema,
+  FileScanDataSchema,
+  FileScanResult,
+  FileType,
+  GoalListResponseSchema,
+  GoalSchema,
+  GoalType,
+  GoalTypeQueryParam,
+  GuardrailAction,
   HEADER_API_KEY,
   HEADER_AUTH_TOKEN,
+  HTTPValidationErrorSchema,
   HTTP_FORCE_RETRY_STATUS_CODES,
   IODetectedSchema,
+  JobAbortResponseSchema,
+  JobCreateRequestSchema,
+  JobListResponseSchema,
+  JobResponseSchema,
+  JobStatus,
+  JobStatusFilter,
+  JobTimeRecordSchema,
+  JobType,
+  LabelKeyListSchema,
+  LabelSchema,
+  LabelValueListSchema,
+  LabelsCreateRequestSchema,
+  LabelsResponseSchema,
+  ListModelSecurityGroupsResponseSchema,
+  ListModelSecurityRuleInstancesResponseSchema,
+  ListModelSecurityRulesResponseSchema,
   MAX_AI_PROFILE_NAME_LENGTH,
   MAX_API_KEY_LENGTH,
   MAX_CONNECTION_POOL_SIZE,
@@ -1216,28 +4527,167 @@ export {
   MGMT_TOPIC_FORCE_PATH,
   MGMT_TOPIC_PATH,
   MGMT_TSG_ID,
+  MODEL_SEC_CLIENT_ID,
+  MODEL_SEC_CLIENT_SECRET,
+  MODEL_SEC_DATA_ENDPOINT,
+  MODEL_SEC_EVALUATIONS_PATH,
+  MODEL_SEC_MGMT_ENDPOINT,
+  MODEL_SEC_PYPI_AUTH_PATH,
+  MODEL_SEC_SCANS_PATH,
+  MODEL_SEC_SECURITY_GROUPS_PATH,
+  MODEL_SEC_SECURITY_RULES_PATH,
+  MODEL_SEC_TOKEN_ENDPOINT,
+  MODEL_SEC_TSG_ID,
+  MODEL_SEC_VIOLATIONS_PATH,
   ManagementClient,
   MaskedDataSchema,
   MetadataSchema,
+  ModelScanIssueSchema,
+  ModelScanStatus,
+  ModelSecurityClient,
+  ModelSecurityGroupCreateRequestSchema,
+  ModelSecurityGroupResponseSchema,
+  ModelSecurityGroupState,
+  ModelSecurityGroupUpdateRequestSchema,
+  ModelSecurityGroupsClient,
+  ModelSecurityPaginationSchema,
+  ModelSecurityRuleInstanceResponseSchema,
+  ModelSecurityRuleInstanceUpdateRequestSchema,
+  ModelSecurityRuleResponseSchema,
+  ModelSecurityRulesClient,
+  ModelSecurityScansClient,
   PAYLOAD_HASH,
   PolicySchema,
+  PolicyType,
+  PrerequisiteModelSchema,
   ProfilesClient,
+  ProfilingStatus,
+  PromptDetailResponseSchema,
   PromptDetectedSchema,
   PromptDetectionDetailsSchema,
+  PromptSetStatsSchema,
+  PromptSetSummarySchema,
+  PromptSetsReportResponseSchema,
+  PropertyAssignmentSchema,
+  PropertyDefinitionSchema,
+  PropertyNameCreateRequestSchema,
+  PropertyNamesListResponseSchema,
+  PropertyStatisticSchema,
+  PropertyValueCreateRequestSchema,
+  PropertyValueStatisticSchema,
+  PropertyValuesMultipleResponseSchema,
+  PropertyValuesResponseSchema,
+  PyPIAuthResponseSchema,
+  QuotaDetailsSchema,
+  QuotaSummarySchema,
+  RED_TEAM_CATEGORIES_PATH,
+  RED_TEAM_CLIENT_ID,
+  RED_TEAM_CLIENT_SECRET,
+  RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH,
+  RED_TEAM_CUSTOM_ATTACK_PATH,
+  RED_TEAM_DASHBOARD_PATH,
+  RED_TEAM_DATA_ENDPOINT,
+  RED_TEAM_ERROR_LOG_PATH,
+  RED_TEAM_MGMT_DASHBOARD_PATH,
+  RED_TEAM_MGMT_ENDPOINT,
+  RED_TEAM_QUOTA_PATH,
+  RED_TEAM_REPORT_DYNAMIC_PATH,
+  RED_TEAM_REPORT_PATH,
+  RED_TEAM_REPORT_STATIC_PATH,
+  RED_TEAM_SCAN_PATH,
+  RED_TEAM_SENTIMENT_PATH,
+  RED_TEAM_TARGET_PATH,
+  RED_TEAM_TOKEN_ENDPOINT,
+  RED_TEAM_TSG_ID,
+  RedTeamCategory,
+  RedTeamClient,
+  RedTeamCustomAttackReportsClient,
+  RedTeamCustomAttacksClient,
+  RedTeamErrorType,
+  RedTeamPaginationSchema,
+  RedTeamReportsClient,
+  RedTeamScansClient,
+  RedTeamTargetsClient,
+  RemediationDetailSchema,
+  RemediationResponseSchema,
   ResponseDetectedSchema,
   ResponseDetectionDetailsSchema,
+  ResponseMode,
+  RiskLevelSchema,
+  RiskRating,
+  RuleConfigurationSchema,
+  RuleEditableFieldDropdownSchema,
+  RuleEditableFieldSchema,
+  RuleEditableFieldType,
+  RuleEvaluationListSchema,
+  RuleEvaluationResponseSchema,
+  RuleEvaluationResult,
+  RuleFieldValueKey,
+  RuleRemediationSchema,
+  RuleState,
+  RuleType,
+  RuntimeSecurityPolicySchema,
+  RuntimeSecurityProfileResponseSchema,
   SCAN_REPORTS_PATH,
   SCAN_RESULTS_PATH,
   SDK_VERSION,
   SYNC_SCAN_PATH,
+  SafetySubCategory,
+  ScanBaseResponseSchema,
+  ScanCreateRequestSchema,
+  ScanDetailsSchema,
   ScanIdResultSchema,
+  ScanListSchema,
+  ScanOrigin,
   ScanRequestContentsInnerSchema,
   ScanRequestSchema,
   ScanResponseSchema,
+  ScanStatisticsResponseSchema,
   ScanSummarySchema,
   Scanner,
+  ScoreTrendResponseSchema,
+  ScoreTrendSeriesSchema,
   SecurityProfileListResponseSchema,
   SecurityProfileSchema,
+  SecuritySubCategory,
+  SentimentRequestSchema,
+  SentimentResponseSchema,
+  SeverityFilter,
+  SeverityReportSchema,
+  SeverityStatsSchema,
+  SortByDateField,
+  SortByFileField,
+  SortDirection,
+  SourceType,
+  StaticJobMetadataSchema,
+  StaticJobRemediationRecommendationSchema,
+  StaticJobRemediationSchema,
+  StaticJobReportSchema,
+  StaticJobReportStatsSchema,
+  StatusQueryParam,
+  StreamDetailResponseSchema,
+  StreamIterationDataSchema,
+  StreamListResponseSchema,
+  StreamType,
+  SubCategoryModelSchema,
+  SubCategoryStatsSchema,
+  TargetAdditionalContextSchema,
+  TargetBackgroundSchema,
+  TargetConnectionType,
+  TargetContextUpdateSchema,
+  TargetCreateRequestSchema,
+  TargetJobRequestSchema,
+  TargetListItemSchema,
+  TargetListSchema,
+  TargetMetadataSchema,
+  TargetProbeRequestSchema,
+  TargetProfileResponseSchema,
+  TargetReferenceSchema,
+  TargetResponseSchema,
+  TargetStatus,
+  TargetType,
+  TargetUpdateRequestSchema,
+  ThreatCategory,
   ThreatScanReportSchema,
   ToolDetectedSchema,
   ToolEventMetadataSchema,
@@ -1245,6 +4695,10 @@ export {
   TopicsClient,
   USER_AGENT,
   UrlfEntrySchema,
+  ValidationErrorSchema,
+  Verdict,
+  ViolationListSchema,
+  ViolationResponseSchema,
   globalConfiguration,
   init
 };