@cdot65/prisma-airs-sdk 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -25,33 +25,115 @@ __export(index_exports, {
   AI_SEC_API_KEY: () => AI_SEC_API_KEY,
   AI_SEC_API_TOKEN: () => AI_SEC_API_TOKEN,
   ASYNC_SCAN_PATH: () => ASYNC_SCAN_PATH,
+  Action: () => Action,
   AgentMetaSchema: () => AgentMetaSchema,
   AiProfileSchema: () => AiProfileSchema,
+  ApiEndpointType: () => ApiEndpointType,
   AsyncScanObjectSchema: () => AsyncScanObjectSchema,
   AsyncScanResponseSchema: () => AsyncScanResponseSchema,
+  AttackDetailResponseSchema: () => AttackDetailResponseSchema,
+  AttackListItemSchema: () => AttackListItemSchema,
+  AttackListResponseSchema: () => AttackListResponseSchema,
+  AttackMultiTurnDetailResponseSchema: () => AttackMultiTurnDetailResponseSchema,
+  AttackMultiTurnOutputSchema: () => AttackMultiTurnOutputSchema,
+  AttackOutputSchema: () => AttackOutputSchema,
+  AttackStatus: () => AttackStatus,
+  AttackType: () => AttackType,
+  AuthType: () => AuthType,
   BEARER: () => BEARER,
+  BaseResponseSchema: () => BaseResponseSchema,
+  BrandSubCategory: () => BrandSubCategory,
+  Category: () => Category,
+  CategoryModelSchema: () => CategoryModelSchema,
+  CategoryReportSchema: () => CategoryReportSchema,
+  ComplianceReportSchema: () => ComplianceReportSchema,
+  ComplianceSubCategory: () => ComplianceSubCategory,
+  ComplianceTechniqueSchema: () => ComplianceTechniqueSchema,
   Content: () => Content,
+  CountByNameSchema: () => CountByNameSchema,
+  CountedQuotaEnum: () => CountedQuotaEnum,
   CreateCustomTopicRequestSchema: () => CreateCustomTopicRequestSchema,
   CreateSecurityProfileRequestSchema: () => CreateSecurityProfileRequestSchema,
+  CustomAttackOutputSchema: () => CustomAttackOutputSchema,
+  CustomAttackReportResponseSchema: () => CustomAttackReportResponseSchema,
+  CustomAttacksListResponseSchema: () => CustomAttacksListResponseSchema,
+  CustomJobMetadataSchema: () => CustomJobMetadataSchema,
+  CustomPromptCreateRequestSchema: () => CustomPromptCreateRequestSchema,
+  CustomPromptListItemSchema: () => CustomPromptListItemSchema,
+  CustomPromptListSchema: () => CustomPromptListSchema,
+  CustomPromptResponseSchema: () => CustomPromptResponseSchema,
+  CustomPromptSetArchiveRequestSchema: () => CustomPromptSetArchiveRequestSchema,
+  CustomPromptSetCreateRequestSchema: () => CustomPromptSetCreateRequestSchema,
+  CustomPromptSetListActiveSchema: () => CustomPromptSetListActiveSchema,
+  CustomPromptSetListItemSchema: () => CustomPromptSetListItemSchema,
+  CustomPromptSetListSchema: () => CustomPromptSetListSchema,
+  CustomPromptSetReferenceSchema: () => CustomPromptSetReferenceSchema,
+  CustomPromptSetResponseSchema: () => CustomPromptSetResponseSchema,
+  CustomPromptSetUpdateRequestSchema: () => CustomPromptSetUpdateRequestSchema,
+  CustomPromptSetVersionInfoSchema: () => CustomPromptSetVersionInfoSchema,
+  CustomPromptUpdateRequestSchema: () => CustomPromptUpdateRequestSchema,
   CustomTopicListResponseSchema: () => CustomTopicListResponseSchema,
   CustomTopicSchema: () => CustomTopicSchema,
   DEFAULT_ENDPOINT: () => DEFAULT_ENDPOINT,
   DEFAULT_MGMT_ENDPOINT: () => DEFAULT_MGMT_ENDPOINT,
+  DEFAULT_MODEL_SEC_DATA_ENDPOINT: () => DEFAULT_MODEL_SEC_DATA_ENDPOINT,
+  DEFAULT_MODEL_SEC_MGMT_ENDPOINT: () => DEFAULT_MODEL_SEC_MGMT_ENDPOINT,
+  DEFAULT_RED_TEAM_DATA_ENDPOINT: () => DEFAULT_RED_TEAM_DATA_ENDPOINT,
+  DEFAULT_RED_TEAM_MGMT_ENDPOINT: () => DEFAULT_RED_TEAM_MGMT_ENDPOINT,
   DEFAULT_TOKEN_ENDPOINT: () => DEFAULT_TOKEN_ENDPOINT,
   DSDetailResultSchema: () => DSDetailResultSchema,
   DSResultMetadataSchema: () => DSResultMetadataSchema,
+  DashboardOverviewResponseSchema: () => DashboardOverviewResponseSchema,
+  DateRangeFilter: () => DateRangeFilter,
   DeleteProfileConflictSchema: () => DeleteProfileConflictSchema,
   DeleteProfileResponseSchema: () => DeleteProfileResponseSchema,
   DeleteTopicConflictSchema: () => DeleteTopicConflictSchema,
   DeleteTopicResponseSchema: () => DeleteTopicResponseSchema,
   DetectionServiceResultSchema: () => DetectionServiceResultSchema,
   DlpReportSchema: () => DlpReportSchema,
+  DynamicJobMetadataSchema: () => DynamicJobMetadataSchema,
+  DynamicJobReportSchema: () => DynamicJobReportSchema,
+  DynamicJobReportStatsSchema: () => DynamicJobReportStatsSchema,
+  ErrorCodes: () => ErrorCodes,
+  ErrorLogListResponseSchema: () => ErrorLogListResponseSchema,
+  ErrorLogSchema: () => ErrorLogSchema,
   ErrorResponseSchema: () => ErrorResponseSchema,
+  ErrorSource: () => ErrorSource,
   ErrorType: () => ErrorType,
+  EvalOutcome: () => EvalOutcome,
+  EvalSummarySchema: () => EvalSummarySchema,
+  FileFormat: () => FileFormat,
+  FileListSchema: () => FileListSchema,
+  FileResponseSchema: () => FileResponseSchema,
+  FileScanDataSchema: () => FileScanDataSchema,
+  FileScanResult: () => FileScanResult,
+  FileType: () => FileType,
+  GoalListResponseSchema: () => GoalListResponseSchema,
+  GoalSchema: () => GoalSchema,
+  GoalType: () => GoalType,
+  GoalTypeQueryParam: () => GoalTypeQueryParam,
+  GuardrailAction: () => GuardrailAction,
   HEADER_API_KEY: () => HEADER_API_KEY,
   HEADER_AUTH_TOKEN: () => HEADER_AUTH_TOKEN,
+  HTTPValidationErrorSchema: () => HTTPValidationErrorSchema,
   HTTP_FORCE_RETRY_STATUS_CODES: () => HTTP_FORCE_RETRY_STATUS_CODES,
   IODetectedSchema: () => IODetectedSchema,
+  JobAbortResponseSchema: () => JobAbortResponseSchema,
+  JobCreateRequestSchema: () => JobCreateRequestSchema,
+  JobListResponseSchema: () => JobListResponseSchema,
+  JobResponseSchema: () => JobResponseSchema,
+  JobStatus: () => JobStatus,
+  JobStatusFilter: () => JobStatusFilter,
+  JobTimeRecordSchema: () => JobTimeRecordSchema,
+  JobType: () => JobType,
+  LabelKeyListSchema: () => LabelKeyListSchema,
+  LabelSchema: () => LabelSchema,
+  LabelValueListSchema: () => LabelValueListSchema,
+  LabelsCreateRequestSchema: () => LabelsCreateRequestSchema,
+  LabelsResponseSchema: () => LabelsResponseSchema,
+  ListModelSecurityGroupsResponseSchema: () => ListModelSecurityGroupsResponseSchema,
+  ListModelSecurityRuleInstancesResponseSchema: () => ListModelSecurityRuleInstancesResponseSchema,
+  ListModelSecurityRulesResponseSchema: () => ListModelSecurityRulesResponseSchema,
   MAX_AI_PROFILE_NAME_LENGTH: () => MAX_AI_PROFILE_NAME_LENGTH,
   MAX_API_KEY_LENGTH: () => MAX_API_KEY_LENGTH,
   MAX_CONNECTION_POOL_SIZE: () => MAX_CONNECTION_POOL_SIZE,
@@ -77,28 +159,167 @@ __export(index_exports, {
   MGMT_TOPIC_FORCE_PATH: () => MGMT_TOPIC_FORCE_PATH,
   MGMT_TOPIC_PATH: () => MGMT_TOPIC_PATH,
   MGMT_TSG_ID: () => MGMT_TSG_ID,
+  MODEL_SEC_CLIENT_ID: () => MODEL_SEC_CLIENT_ID,
+  MODEL_SEC_CLIENT_SECRET: () => MODEL_SEC_CLIENT_SECRET,
+  MODEL_SEC_DATA_ENDPOINT: () => MODEL_SEC_DATA_ENDPOINT,
+  MODEL_SEC_EVALUATIONS_PATH: () => MODEL_SEC_EVALUATIONS_PATH,
+  MODEL_SEC_MGMT_ENDPOINT: () => MODEL_SEC_MGMT_ENDPOINT,
+  MODEL_SEC_PYPI_AUTH_PATH: () => MODEL_SEC_PYPI_AUTH_PATH,
+  MODEL_SEC_SCANS_PATH: () => MODEL_SEC_SCANS_PATH,
+  MODEL_SEC_SECURITY_GROUPS_PATH: () => MODEL_SEC_SECURITY_GROUPS_PATH,
+  MODEL_SEC_SECURITY_RULES_PATH: () => MODEL_SEC_SECURITY_RULES_PATH,
+  MODEL_SEC_TOKEN_ENDPOINT: () => MODEL_SEC_TOKEN_ENDPOINT,
+  MODEL_SEC_TSG_ID: () => MODEL_SEC_TSG_ID,
+  MODEL_SEC_VIOLATIONS_PATH: () => MODEL_SEC_VIOLATIONS_PATH,
   ManagementClient: () => ManagementClient,
   MaskedDataSchema: () => MaskedDataSchema,
   MetadataSchema: () => MetadataSchema,
+  ModelScanIssueSchema: () => ModelScanIssueSchema,
+  ModelScanStatus: () => ModelScanStatus,
+  ModelSecurityClient: () => ModelSecurityClient,
+  ModelSecurityGroupCreateRequestSchema: () => ModelSecurityGroupCreateRequestSchema,
+  ModelSecurityGroupResponseSchema: () => ModelSecurityGroupResponseSchema,
+  ModelSecurityGroupState: () => ModelSecurityGroupState,
+  ModelSecurityGroupUpdateRequestSchema: () => ModelSecurityGroupUpdateRequestSchema,
+  ModelSecurityGroupsClient: () => ModelSecurityGroupsClient,
+  ModelSecurityPaginationSchema: () => ModelSecurityPaginationSchema,
+  ModelSecurityRuleInstanceResponseSchema: () => ModelSecurityRuleInstanceResponseSchema,
+  ModelSecurityRuleInstanceUpdateRequestSchema: () => ModelSecurityRuleInstanceUpdateRequestSchema,
+  ModelSecurityRuleResponseSchema: () => ModelSecurityRuleResponseSchema,
+  ModelSecurityRulesClient: () => ModelSecurityRulesClient,
+  ModelSecurityScansClient: () => ModelSecurityScansClient,
   PAYLOAD_HASH: () => PAYLOAD_HASH,
   PolicySchema: () => PolicySchema,
+  PolicyType: () => PolicyType,
+  PrerequisiteModelSchema: () => PrerequisiteModelSchema,
   ProfilesClient: () => ProfilesClient,
+  ProfilingStatus: () => ProfilingStatus,
+  PromptDetailResponseSchema: () => PromptDetailResponseSchema,
   PromptDetectedSchema: () => PromptDetectedSchema,
   PromptDetectionDetailsSchema: () => PromptDetectionDetailsSchema,
+  PromptSetStatsSchema: () => PromptSetStatsSchema,
+  PromptSetSummarySchema: () => PromptSetSummarySchema,
+  PromptSetsReportResponseSchema: () => PromptSetsReportResponseSchema,
+  PropertyAssignmentSchema: () => PropertyAssignmentSchema,
+  PropertyDefinitionSchema: () => PropertyDefinitionSchema,
+  PropertyNameCreateRequestSchema: () => PropertyNameCreateRequestSchema,
+  PropertyNamesListResponseSchema: () => PropertyNamesListResponseSchema,
+  PropertyStatisticSchema: () => PropertyStatisticSchema,
+  PropertyValueCreateRequestSchema: () => PropertyValueCreateRequestSchema,
+  PropertyValueStatisticSchema: () => PropertyValueStatisticSchema,
+  PropertyValuesMultipleResponseSchema: () => PropertyValuesMultipleResponseSchema,
+  PropertyValuesResponseSchema: () => PropertyValuesResponseSchema,
+  PyPIAuthResponseSchema: () => PyPIAuthResponseSchema,
+  QuotaDetailsSchema: () => QuotaDetailsSchema,
+  QuotaSummarySchema: () => QuotaSummarySchema,
+  RED_TEAM_CATEGORIES_PATH: () => RED_TEAM_CATEGORIES_PATH,
+  RED_TEAM_CLIENT_ID: () => RED_TEAM_CLIENT_ID,
+  RED_TEAM_CLIENT_SECRET: () => RED_TEAM_CLIENT_SECRET,
+  RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH: () => RED_TEAM_CUSTOM_ATTACKS_REPORT_PATH,
+  RED_TEAM_CUSTOM_ATTACK_PATH: () => RED_TEAM_CUSTOM_ATTACK_PATH,
+  RED_TEAM_DASHBOARD_PATH: () => RED_TEAM_DASHBOARD_PATH,
+  RED_TEAM_DATA_ENDPOINT: () => RED_TEAM_DATA_ENDPOINT,
+  RED_TEAM_ERROR_LOG_PATH: () => RED_TEAM_ERROR_LOG_PATH,
+  RED_TEAM_MGMT_DASHBOARD_PATH: () => RED_TEAM_MGMT_DASHBOARD_PATH,
+  RED_TEAM_MGMT_ENDPOINT: () => RED_TEAM_MGMT_ENDPOINT,
+  RED_TEAM_QUOTA_PATH: () => RED_TEAM_QUOTA_PATH,
+  RED_TEAM_REPORT_DYNAMIC_PATH: () => RED_TEAM_REPORT_DYNAMIC_PATH,
+  RED_TEAM_REPORT_PATH: () => RED_TEAM_REPORT_PATH,
+  RED_TEAM_REPORT_STATIC_PATH: () => RED_TEAM_REPORT_STATIC_PATH,
+  RED_TEAM_SCAN_PATH: () => RED_TEAM_SCAN_PATH,
+  RED_TEAM_SENTIMENT_PATH: () => RED_TEAM_SENTIMENT_PATH,
+  RED_TEAM_TARGET_PATH: () => RED_TEAM_TARGET_PATH,
+  RED_TEAM_TOKEN_ENDPOINT: () => RED_TEAM_TOKEN_ENDPOINT,
+  RED_TEAM_TSG_ID: () => RED_TEAM_TSG_ID,
+  RedTeamCategory: () => RedTeamCategory,
+  RedTeamClient: () => RedTeamClient,
+  RedTeamCustomAttackReportsClient: () => RedTeamCustomAttackReportsClient,
+  RedTeamCustomAttacksClient: () => RedTeamCustomAttacksClient,
+  RedTeamErrorType: () => RedTeamErrorType,
+  RedTeamPaginationSchema: () => RedTeamPaginationSchema,
+  RedTeamReportsClient: () => RedTeamReportsClient,
+  RedTeamScansClient: () => RedTeamScansClient,
+  RedTeamTargetsClient: () => RedTeamTargetsClient,
+  RemediationDetailSchema: () => RemediationDetailSchema,
+  RemediationResponseSchema: () => RemediationResponseSchema,
   ResponseDetectedSchema: () => ResponseDetectedSchema,
   ResponseDetectionDetailsSchema: () => ResponseDetectionDetailsSchema,
+  ResponseMode: () => ResponseMode,
+  RiskLevelSchema: () => RiskLevelSchema,
+  RiskRating: () => RiskRating,
+  RuleConfigurationSchema: () => RuleConfigurationSchema,
+  RuleEditableFieldDropdownSchema: () => RuleEditableFieldDropdownSchema,
+  RuleEditableFieldSchema: () => RuleEditableFieldSchema,
+  RuleEditableFieldType: () => RuleEditableFieldType,
+  RuleEvaluationListSchema: () => RuleEvaluationListSchema,
+  RuleEvaluationResponseSchema: () => RuleEvaluationResponseSchema,
+  RuleEvaluationResult: () => RuleEvaluationResult,
+  RuleFieldValueKey: () => RuleFieldValueKey,
+  RuleRemediationSchema: () => RuleRemediationSchema,
+  RuleState: () => RuleState,
+  RuleType: () => RuleType,
+  RuntimeSecurityPolicySchema: () => RuntimeSecurityPolicySchema,
+  RuntimeSecurityProfileResponseSchema: () => RuntimeSecurityProfileResponseSchema,
   SCAN_REPORTS_PATH: () => SCAN_REPORTS_PATH,
   SCAN_RESULTS_PATH: () => SCAN_RESULTS_PATH,
   SDK_VERSION: () => SDK_VERSION,
   SYNC_SCAN_PATH: () => SYNC_SCAN_PATH,
+  SafetySubCategory: () => SafetySubCategory,
+  ScanBaseResponseSchema: () => ScanBaseResponseSchema,
+  ScanCreateRequestSchema: () => ScanCreateRequestSchema,
+  ScanDetailsSchema: () => ScanDetailsSchema,
   ScanIdResultSchema: () => ScanIdResultSchema,
+  ScanListSchema: () => ScanListSchema,
+  ScanOrigin: () => ScanOrigin,
   ScanRequestContentsInnerSchema: () => ScanRequestContentsInnerSchema,
   ScanRequestSchema: () => ScanRequestSchema,
   ScanResponseSchema: () => ScanResponseSchema,
+  ScanStatisticsResponseSchema: () => ScanStatisticsResponseSchema,
   ScanSummarySchema: () => ScanSummarySchema,
   Scanner: () => Scanner,
+  ScoreTrendResponseSchema: () => ScoreTrendResponseSchema,
+  ScoreTrendSeriesSchema: () => ScoreTrendSeriesSchema,
   SecurityProfileListResponseSchema: () => SecurityProfileListResponseSchema,
   SecurityProfileSchema: () => SecurityProfileSchema,
+  SecuritySubCategory: () => SecuritySubCategory,
+  SentimentRequestSchema: () => SentimentRequestSchema,
+  SentimentResponseSchema: () => SentimentResponseSchema,
+  SeverityFilter: () => SeverityFilter,
+  SeverityReportSchema: () => SeverityReportSchema,
+  SeverityStatsSchema: () => SeverityStatsSchema,
+  SortByDateField: () => SortByDateField,
+  SortByFileField: () => SortByFileField,
+  SortDirection: () => SortDirection,
+  SourceType: () => SourceType,
+  StaticJobMetadataSchema: () => StaticJobMetadataSchema,
+  StaticJobRemediationRecommendationSchema: () => StaticJobRemediationRecommendationSchema,
+  StaticJobRemediationSchema: () => StaticJobRemediationSchema,
+  StaticJobReportSchema: () => StaticJobReportSchema,
+  StaticJobReportStatsSchema: () => StaticJobReportStatsSchema,
+  StatusQueryParam: () => StatusQueryParam,
+  StreamDetailResponseSchema: () => StreamDetailResponseSchema,
+  StreamIterationDataSchema: () => StreamIterationDataSchema,
+  StreamListResponseSchema: () => StreamListResponseSchema,
+  StreamType: () => StreamType,
+  SubCategoryModelSchema: () => SubCategoryModelSchema,
+  SubCategoryStatsSchema: () => SubCategoryStatsSchema,
+  TargetAdditionalContextSchema: () => TargetAdditionalContextSchema,
+  TargetBackgroundSchema: () => TargetBackgroundSchema,
+  TargetConnectionType: () => TargetConnectionType,
+  TargetContextUpdateSchema: () => TargetContextUpdateSchema,
+  TargetCreateRequestSchema: () => TargetCreateRequestSchema,
+  TargetJobRequestSchema: () => TargetJobRequestSchema,
+  TargetListItemSchema: () => TargetListItemSchema,
+  TargetListSchema: () => TargetListSchema,
+  TargetMetadataSchema: () => TargetMetadataSchema,
+  TargetProbeRequestSchema: () => TargetProbeRequestSchema,
+  TargetProfileResponseSchema: () => TargetProfileResponseSchema,
+  TargetReferenceSchema: () => TargetReferenceSchema,
+  TargetResponseSchema: () => TargetResponseSchema,
+  TargetStatus: () => TargetStatus,
+  TargetType: () => TargetType,
+  TargetUpdateRequestSchema: () => TargetUpdateRequestSchema,
+  ThreatCategory: () => ThreatCategory,
   ThreatScanReportSchema: () => ThreatScanReportSchema,
   ToolDetectedSchema: () => ToolDetectedSchema,
   ToolEventMetadataSchema: () => ToolEventMetadataSchema,
@@ -106,6 +327,10 @@ __export(index_exports, {
   TopicsClient: () => TopicsClient,
   USER_AGENT: () => USER_AGENT,
   UrlfEntrySchema: () => UrlfEntrySchema,
+  ValidationErrorSchema: () => ValidationErrorSchema,
+  Verdict: () => Verdict,
+  ViolationListSchema: () => ViolationListSchema,
+  ViolationResponseSchema: () => ViolationResponseSchema,
   globalConfiguration: () => globalConfiguration,
   init: () => init
 });
@@ -136,7 +361,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";
@@ -154,6 +379,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) => {
@@ -167,6 +427,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";
@@ -248,6 +512,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
 var import_node_crypto = require("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;
@@ -273,9 +599,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(
@@ -298,48 +621,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(
@@ -367,6 +669,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(
@@ -387,6 +694,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(
@@ -412,6 +724,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(
@@ -523,6 +840,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);
@@ -532,6 +850,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;
@@ -542,6 +861,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,
@@ -552,6 +875,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 = (0, import_node_fs.readFileSync)(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -559,6 +886,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
 var import_zod = require("zod");
 var AiProfileSchema = import_zod.z.object({
@@ -904,13 +1248,1402 @@ var DeleteTopicConflictSchema = import_zod16.z.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
 var import_zod17 = require("zod");
-var OAuthTokenResponseSchema = import_zod17.z.object({
-  access_token: import_zod17.z.string(),
-  token_type: import_zod17.z.string().optional(),
-  expires_in: import_zod17.z.number(),
-  scope: import_zod17.z.string().optional()
+var ModelSecurityPaginationSchema = import_zod17.z.object({
+  total_items: import_zod17.z.number().int().nullable().optional()
+}).passthrough();
+var LabelSchema = import_zod17.z.object({
+  key: import_zod17.z.string(),
+  value: import_zod17.z.string()
+});
+var LabelsCreateRequestSchema = import_zod17.z.object({
+  labels: import_zod17.z.array(LabelSchema)
+});
+var LabelsResponseSchema = import_zod17.z.object({}).passthrough();
+var LabelKeyListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  keys: import_zod17.z.array(import_zod17.z.string())
+}).passthrough();
+var LabelValueListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  values: import_zod17.z.array(import_zod17.z.string())
+}).passthrough();
+var EvalSummarySchema = import_zod17.z.object({
+  rules_failed: import_zod17.z.number().int().optional().default(0),
+  rules_passed: import_zod17.z.number().int().optional().default(0),
+  total_rules: import_zod17.z.number().int().optional().default(0)
+}).passthrough();
+var ModelScanIssueSchema = import_zod17.z.object({
+  description: import_zod17.z.string(),
+  source: import_zod17.z.string(),
+  threat: import_zod17.z.string().nullable().optional(),
+  module: import_zod17.z.string().nullable().optional(),
+  operator: import_zod17.z.string().nullable().optional()
+}).passthrough();
+var FileScanDataSchema = import_zod17.z.object({
+  file_path: import_zod17.z.string(),
+  modelscan_status: import_zod17.z.string(),
+  blob_id: import_zod17.z.string(),
+  error_message: import_zod17.z.string().nullable().optional(),
+  formats: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  issues_detected: import_zod17.z.array(ModelScanIssueSchema).nullable().optional()
+}).passthrough();
+var ScanDetailsSchema = import_zod17.z.object({
+  scanner_version: import_zod17.z.string(),
+  time_started: import_zod17.z.string(),
+  files: import_zod17.z.array(FileScanDataSchema),
+  total_files_scanned: import_zod17.z.number().int(),
+  total_files_skipped: import_zod17.z.number().int(),
+  model_formats: import_zod17.z.array(import_zod17.z.string()),
+  model_size_bytes: import_zod17.z.number().int(),
+  scan_duration_ms: import_zod17.z.number().int(),
+  error_code: import_zod17.z.string().nullable().optional(),
+  error_message: import_zod17.z.string().nullable().optional()
+});
+var ScanCreateRequestSchema = import_zod17.z.object({
+  model_uri: import_zod17.z.string(),
+  security_group_uuid: import_zod17.z.string(),
+  scan_origin: import_zod17.z.string(),
+  allow_patterns: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  ignore_patterns: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  labels: import_zod17.z.array(LabelSchema).nullable().optional(),
+  model_author: import_zod17.z.string().nullable().optional(),
+  model_name: import_zod17.z.string().nullable().optional(),
+  model_version: import_zod17.z.string().nullable().optional(),
+  scan_details: ScanDetailsSchema.nullable().optional()
+});
+var ScanBaseResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  model_uri: import_zod17.z.string(),
+  owner: import_zod17.z.string(),
+  scan_origin: import_zod17.z.string(),
+  security_group_uuid: import_zod17.z.string(),
+  security_group_name: import_zod17.z.string(),
+  model_version_uuid: import_zod17.z.string(),
+  eval_outcome: import_zod17.z.string(),
+  source_type: import_zod17.z.string(),
+  created_by: import_zod17.z.string().nullable().optional(),
+  enabled_rule_count_snapshot: import_zod17.z.number().int().nullable().optional(),
+  error_code: import_zod17.z.string().nullable().optional(),
+  error_message: import_zod17.z.string().nullable().optional(),
+  eval_summary: EvalSummarySchema.nullable().optional(),
+  labels: import_zod17.z.array(LabelSchema).optional(),
+  model_formats: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  scanner_version: import_zod17.z.string().nullable().optional(),
+  time_started: import_zod17.z.string().nullable().optional(),
+  total_files_scanned: import_zod17.z.number().int().nullable().optional(),
+  total_files_skipped: import_zod17.z.number().int().nullable().optional()
+}).passthrough();
+var ScanListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  scans: import_zod17.z.array(ScanBaseResponseSchema)
+}).passthrough();
+var FileResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  path: import_zod17.z.string(),
+  parent_path: import_zod17.z.string(),
+  type: import_zod17.z.string(),
+  result: import_zod17.z.string(),
+  model_version_uuid: import_zod17.z.string(),
+  blob_id: import_zod17.z.string().nullable().optional(),
+  formats: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  scan_uuid: import_zod17.z.string().nullable().optional()
+}).passthrough();
+var FileListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  files: import_zod17.z.array(FileResponseSchema)
+}).passthrough();
+var RuleEvaluationResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  result: import_zod17.z.string(),
+  violation_count: import_zod17.z.number().int(),
+  rule_instance_uuid: import_zod17.z.string(),
+  scan_uuid: import_zod17.z.string(),
+  rule_name: import_zod17.z.string(),
+  rule_description: import_zod17.z.string(),
+  rule_instance_state: import_zod17.z.string()
+}).passthrough();
+var RuleEvaluationListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  evaluations: import_zod17.z.array(RuleEvaluationResponseSchema)
+}).passthrough();
+var ViolationResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  description: import_zod17.z.string(),
+  rule_instance_uuid: import_zod17.z.string(),
+  rule_name: import_zod17.z.string(),
+  rule_description: import_zod17.z.string(),
+  rule_instance_state: import_zod17.z.string(),
+  file: import_zod17.z.string().nullable().optional(),
+  hash: import_zod17.z.string().nullable().optional(),
+  module: import_zod17.z.string().nullable().optional(),
+  operator: import_zod17.z.string().nullable().optional(),
+  threat: import_zod17.z.string().nullable().optional(),
+  threat_description: import_zod17.z.string().nullable().optional()
+}).passthrough();
+var ViolationListSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  violations: import_zod17.z.array(ViolationResponseSchema)
+}).passthrough();
+var RuleEditableFieldDropdownSchema = import_zod17.z.object({
+  value: import_zod17.z.string(),
+  label: import_zod17.z.string()
+}).passthrough();
+var RuleEditableFieldSchema = import_zod17.z.object({
+  attribute_name: import_zod17.z.string(),
+  type: import_zod17.z.string(),
+  display_name: import_zod17.z.string(),
+  display_type: import_zod17.z.string(),
+  description: import_zod17.z.string().nullable().optional(),
+  dropdown_values: import_zod17.z.array(RuleEditableFieldDropdownSchema).nullable().optional()
+}).passthrough();
+var RuleRemediationSchema = import_zod17.z.object({
+  description: import_zod17.z.string(),
+  steps: import_zod17.z.array(import_zod17.z.string()),
+  url: import_zod17.z.string()
+}).passthrough();
+var RuleConfigurationSchema = import_zod17.z.object({
+  field_values: import_zod17.z.record(import_zod17.z.unknown()).optional(),
+  state: import_zod17.z.string().nullable().optional()
+}).passthrough();
+var ModelSecurityRuleResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  description: import_zod17.z.string(),
+  rule_type: import_zod17.z.string(),
+  compatible_sources: import_zod17.z.array(import_zod17.z.string()),
+  default_state: import_zod17.z.string(),
+  remediation: RuleRemediationSchema,
+  editable_fields: import_zod17.z.array(RuleEditableFieldSchema),
+  constant_values: import_zod17.z.record(import_zod17.z.unknown()),
+  default_values: import_zod17.z.record(import_zod17.z.unknown())
+}).passthrough();
+var ListModelSecurityRulesResponseSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  rules: import_zod17.z.array(ModelSecurityRuleResponseSchema)
+}).passthrough();
+var ModelSecurityRuleInstanceResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  security_group_uuid: import_zod17.z.string(),
+  security_rule_uuid: import_zod17.z.string(),
+  state: import_zod17.z.string(),
+  rule: ModelSecurityRuleResponseSchema,
+  field_values: import_zod17.z.record(import_zod17.z.unknown()).optional()
+}).passthrough();
+var ModelSecurityRuleInstanceUpdateRequestSchema = import_zod17.z.object({
+  security_group_uuid: import_zod17.z.string(),
+  state: import_zod17.z.string().nullable().optional(),
+  field_values: import_zod17.z.record(import_zod17.z.unknown()).nullable().optional()
+});
+var ListModelSecurityRuleInstancesResponseSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  rule_instances: import_zod17.z.array(ModelSecurityRuleInstanceResponseSchema)
+}).passthrough();
+var ModelSecurityGroupCreateRequestSchema = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  source_type: import_zod17.z.string(),
+  description: import_zod17.z.string().optional().default(""),
+  rule_configurations: import_zod17.z.record(RuleConfigurationSchema).optional()
+});
+var ModelSecurityGroupResponseSchema = import_zod17.z.object({
+  uuid: import_zod17.z.string(),
+  tsg_id: import_zod17.z.string(),
+  created_at: import_zod17.z.string(),
+  updated_at: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  description: import_zod17.z.string(),
+  source_type: import_zod17.z.string(),
+  state: import_zod17.z.string(),
+  is_tombstone: import_zod17.z.boolean()
+}).passthrough();
+var ModelSecurityGroupUpdateRequestSchema = import_zod17.z.object({
+  name: import_zod17.z.string().nullable().optional(),
+  description: import_zod17.z.string().nullable().optional()
+});
+var ListModelSecurityGroupsResponseSchema = import_zod17.z.object({
+  pagination: ModelSecurityPaginationSchema,
+  security_groups: import_zod17.z.array(ModelSecurityGroupResponseSchema)
+}).passthrough();
+var PyPIAuthResponseSchema = import_zod17.z.object({
+  url: import_zod17.z.string(),
+  expires_at: import_zod17.z.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
+var import_zod18 = require("zod");
+var RedTeamPaginationSchema = import_zod18.z.object({ total_items: import_zod18.z.number().int().nullable().optional() }).passthrough();
+var CountByNameSchema = import_zod18.z.object({ name: import_zod18.z.string(), count: import_zod18.z.number().int() });
+var ValidationErrorSchema = import_zod18.z.object({
+  loc: import_zod18.z.array(import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()])),
+  msg: import_zod18.z.string(),
+  type: import_zod18.z.string()
+});
+var HTTPValidationErrorSchema = import_zod18.z.object({ detail: import_zod18.z.array(ValidationErrorSchema).optional() }).passthrough();
+var TargetBackgroundSchema = import_zod18.z.object({
+  industry: import_zod18.z.unknown().optional(),
+  use_case: import_zod18.z.unknown().optional(),
+  competitors: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetAdditionalContextSchema = import_zod18.z.object({
+  base_model: import_zod18.z.unknown().optional(),
+  core_architecture: import_zod18.z.unknown().optional(),
+  system_prompt: import_zod18.z.unknown().optional(),
+  languages_supported: import_zod18.z.unknown().optional(),
+  banned_keywords: import_zod18.z.unknown().optional(),
+  tools_accessible: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetMetadataSchema = import_zod18.z.object({
+  multi_turn: import_zod18.z.boolean().optional(),
+  multi_turn_error_message: import_zod18.z.unknown().optional(),
+  rate_limit: import_zod18.z.unknown().optional(),
+  rate_limit_enabled: import_zod18.z.boolean().optional(),
+  rate_limit_error_code: import_zod18.z.unknown().optional(),
+  rate_limit_error_json: import_zod18.z.unknown().optional(),
+  rate_limit_error_message: import_zod18.z.unknown().optional(),
+  content_filter_enabled: import_zod18.z.boolean().optional(),
+  content_filter_error_code: import_zod18.z.unknown().optional(),
+  content_filter_error_json: import_zod18.z.unknown().optional(),
+  content_filter_error_message: import_zod18.z.unknown().optional(),
+  probe_message: import_zod18.z.string().optional(),
+  request_timeout: import_zod18.z.number().optional()
+}).passthrough();
+var TargetJobRequestSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  version: import_zod18.z.number().int().nullable().optional()
+});
+var JobTimeRecordSchema = import_zod18.z.object({
+  queued_at: import_zod18.z.string().nullable().optional(),
+  started_at: import_zod18.z.string().nullable().optional(),
+  completed_at: import_zod18.z.string().nullable().optional(),
+  time_taken: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var StaticJobMetadataSchema = import_zod18.z.object({
+  categories: import_zod18.z.record(import_zod18.z.unknown()),
+  rate_limit_enabled: import_zod18.z.boolean().optional(),
+  rate_limit: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_code: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_message: import_zod18.z.string().nullable().optional(),
+  rate_limit_error_json: import_zod18.z.unknown().optional(),
+  content_filter_enabled: import_zod18.z.boolean().optional(),
+  content_filter_error_code: import_zod18.z.number().int().nullable().optional(),
+  content_filter_error_message: import_zod18.z.string().nullable().optional(),
+  content_filter_error_json: import_zod18.z.unknown().optional()
+}).passthrough();
+var DynamicJobMetadataSchema = import_zod18.z.object({
+  rate_limit_enabled: import_zod18.z.boolean().optional(),
+  rate_limit: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_code: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_message: import_zod18.z.string().nullable().optional(),
+  rate_limit_error_json: import_zod18.z.unknown().optional(),
+  content_filter_enabled: import_zod18.z.boolean().optional(),
+  content_filter_error_code: import_zod18.z.number().int().nullable().optional(),
+  content_filter_error_message: import_zod18.z.string().nullable().optional(),
+  content_filter_error_json: import_zod18.z.unknown().optional(),
+  stream_breadth: import_zod18.z.number().int().optional(),
+  stream_depth: import_zod18.z.number().int().optional(),
+  max_tokens: import_zod18.z.number().int().optional(),
+  context_size: import_zod18.z.number().int().optional(),
+  attack_goals: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+  base_model: import_zod18.z.string().nullable().optional(),
+  use_case: import_zod18.z.string().nullable().optional(),
+  system_prompt: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var CustomJobMetadataSchema = import_zod18.z.object({
+  custom_prompt_sets: import_zod18.z.array(import_zod18.z.unknown()),
+  rate_limit_enabled: import_zod18.z.boolean().optional(),
+  rate_limit: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_code: import_zod18.z.number().int().nullable().optional(),
+  rate_limit_error_message: import_zod18.z.string().nullable().optional(),
+  rate_limit_error_json: import_zod18.z.unknown().optional(),
+  content_filter_enabled: import_zod18.z.boolean().optional(),
+  content_filter_error_code: import_zod18.z.number().int().nullable().optional(),
+  content_filter_error_message: import_zod18.z.string().nullable().optional(),
+  content_filter_error_json: import_zod18.z.unknown().optional()
+}).passthrough();
+var JobCreateRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  target: TargetJobRequestSchema,
+  job_type: import_zod18.z.string(),
+  job_metadata: import_zod18.z.union([
+    StaticJobMetadataSchema,
+    DynamicJobMetadataSchema,
+    CustomJobMetadataSchema
+  ]),
+  version: import_zod18.z.number().int().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional()
+});
+var StaticJobReportStatsSchema = import_zod18.z.object({
+  output_completion_percentage: import_zod18.z.number(),
+  partial_report_unlocked: import_zod18.z.boolean().optional(),
+  partial_report_unlocked_at: import_zod18.z.string().nullable().optional(),
+  report_summary: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var DynamicJobReportStatsSchema = import_zod18.z.object({
+  total_goals: import_zod18.z.number().int().optional(),
+  total_streams: import_zod18.z.number().int().optional(),
+  total_threats: import_zod18.z.number().int().optional(),
+  goals_achieved: import_zod18.z.number().int().optional(),
+  report_summary: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var TargetReferenceSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  description: import_zod18.z.string().nullable().optional(),
+  target_type: import_zod18.z.string().nullable().optional(),
+  connection_type: import_zod18.z.string().nullable().optional(),
+  api_endpoint_type: import_zod18.z.string().nullable().optional(),
+  response_mode: import_zod18.z.string().nullable().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional(),
+  status: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  validated: import_zod18.z.boolean(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  secret_version: import_zod18.z.string().nullable().optional(),
+  created_by_user_id: import_zod18.z.string().nullable().optional(),
+  updated_by_user_id: import_zod18.z.string().nullable().optional(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  target_metadata: TargetMetadataSchema.optional(),
+  target_background: TargetBackgroundSchema.nullable().optional(),
+  profiling_status: import_zod18.z.string().nullable().optional(),
+  additional_context: TargetAdditionalContextSchema.nullable().optional()
+}).passthrough();
+var JobResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  target: TargetReferenceSchema,
+  job_type: import_zod18.z.string(),
+  job_metadata: import_zod18.z.unknown(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional(),
+  target_id: import_zod18.z.string(),
+  target_type: import_zod18.z.string(),
+  total: import_zod18.z.number().int().nullable().optional(),
+  completed: import_zod18.z.number().int().nullable().optional(),
+  status: import_zod18.z.string().optional(),
+  score: import_zod18.z.number().nullable().optional(),
+  asr: import_zod18.z.number().nullable().optional(),
+  time_record: JobTimeRecordSchema.nullable().optional(),
+  created_at: import_zod18.z.string().nullable().optional(),
+  updated_at: import_zod18.z.string().nullable().optional(),
+  created_by_user_id: import_zod18.z.string().nullable().optional(),
+  report_stats: import_zod18.z.unknown().optional(),
+  metering_quota_uuid: import_zod18.z.string().nullable().optional(),
+  counted_towards_quota: import_zod18.z.string().optional(),
+  invocation_id: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var JobListResponseSchema = import_zod18.z.object({
+  pagination: RedTeamPaginationSchema,
+  data: import_zod18.z.array(JobResponseSchema)
+}).passthrough();
+var JobAbortResponseSchema = import_zod18.z.object({
+  job_id: import_zod18.z.string(),
+  message: import_zod18.z.string()
+});
+var PrerequisiteModelSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string()
+});
+var SubCategoryModelSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  preselect: import_zod18.z.boolean().optional(),
+  prerequisites: import_zod18.z.array(PrerequisiteModelSchema).nullable().optional(),
+  active: import_zod18.z.boolean().optional()
+}).passthrough();
+var CategoryModelSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  preselect: import_zod18.z.boolean().optional(),
+  sub_categories: import_zod18.z.array(SubCategoryModelSchema)
+}).passthrough();
+var AttackOutputSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  attack_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  output: import_zod18.z.string(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional()
+}).passthrough();
+var AttackMultiTurnOutputSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  attack_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  output: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  turn: import_zod18.z.number().int(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional(),
+  generation: import_zod18.z.number().int().optional(),
+  multi_turn: import_zod18.z.boolean().optional()
+}).passthrough();
+var AttackListItemSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  prompt_mapping_id: import_zod18.z.string(),
+  prompt_id: import_zod18.z.string(),
+  category: import_zod18.z.string(),
+  sub_category: import_zod18.z.string(),
+  category_display_name: import_zod18.z.string(),
+  sub_category_display_name: import_zod18.z.string(),
+  status: import_zod18.z.string().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).optional(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  attack_type: import_zod18.z.string().optional(),
+  multi_turn: import_zod18.z.boolean().optional(),
+  asr: import_zod18.z.number().nullable().optional(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  severity: import_zod18.z.string().optional()
+}).passthrough();
+var AttackListResponseSchema = import_zod18.z.object({
+  pagination: RedTeamPaginationSchema,
+  data: import_zod18.z.array(AttackListItemSchema)
+}).passthrough();
+var AttackDetailResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  prompt_mapping_id: import_zod18.z.string(),
+  prompt_id: import_zod18.z.string(),
+  category: import_zod18.z.string(),
+  sub_category: import_zod18.z.string(),
+  category_display_name: import_zod18.z.string(),
+  sub_category_display_name: import_zod18.z.string(),
+  compliance_frameworks: import_zod18.z.array(import_zod18.z.unknown()),
+  goal: import_zod18.z.string().nullable(),
+  status: import_zod18.z.string().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).optional(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  attack_type: import_zod18.z.string().optional(),
+  multi_turn: import_zod18.z.boolean().optional(),
+  asr: import_zod18.z.number().nullable().optional(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  severity: import_zod18.z.string().optional(),
+  outputs: import_zod18.z.array(AttackOutputSchema).optional()
+}).passthrough();
+var AttackMultiTurnDetailResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  prompt_mapping_id: import_zod18.z.string(),
+  prompt_id: import_zod18.z.string(),
+  category: import_zod18.z.string(),
+  sub_category: import_zod18.z.string(),
+  category_display_name: import_zod18.z.string(),
+  sub_category_display_name: import_zod18.z.string(),
+  compliance_frameworks: import_zod18.z.array(import_zod18.z.unknown()),
+  goal: import_zod18.z.string().nullable(),
+  status: import_zod18.z.string().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).optional(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  attack_type: import_zod18.z.string().optional(),
+  multi_turn: import_zod18.z.boolean().optional(),
+  asr: import_zod18.z.number().nullable().optional(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  severity: import_zod18.z.string().optional(),
+  outputs: import_zod18.z.array(AttackMultiTurnOutputSchema).optional()
+}).passthrough();
+var SubCategoryStatsSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  preselect: import_zod18.z.boolean().optional(),
+  prerequisites: import_zod18.z.array(PrerequisiteModelSchema).nullable().optional(),
+  active: import_zod18.z.boolean().optional(),
+  successful: import_zod18.z.number().int(),
+  failed: import_zod18.z.number().int(),
+  total: import_zod18.z.number().int().optional()
+}).passthrough();
+var CategoryReportSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  preselect: import_zod18.z.boolean().optional(),
+  sub_categories: import_zod18.z.array(SubCategoryStatsSchema),
+  asr: import_zod18.z.number(),
+  total_prompts: import_zod18.z.number().int(),
+  total_attacks: import_zod18.z.number().int(),
+  successful: import_zod18.z.number().int(),
+  failed: import_zod18.z.number().int()
+}).passthrough();
+var SeverityStatsSchema = import_zod18.z.object({
+  severity: import_zod18.z.string(),
+  successful: import_zod18.z.number().int().optional(),
+  failed: import_zod18.z.number().int().optional()
+}).passthrough();
+var SeverityReportSchema = import_zod18.z.object({
+  stats: import_zod18.z.array(SeverityStatsSchema),
+  successful: import_zod18.z.number().int().optional(),
+  failed: import_zod18.z.number().int().optional(),
+  total_attacks: import_zod18.z.number().int().optional()
+}).passthrough();
+var ComplianceTechniqueSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  compliance_id: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  link: import_zod18.z.string(),
+  version: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  successful: import_zod18.z.number().int().optional(),
+  failed: import_zod18.z.number().int().optional(),
+  total: import_zod18.z.number().int().optional()
+}).passthrough();
+var ComplianceReportSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  version: import_zod18.z.string(),
+  link: import_zod18.z.string(),
+  techniques: import_zod18.z.array(ComplianceTechniqueSchema),
+  score: import_zod18.z.number().int().optional()
+}).passthrough();
+var RuntimeSecurityPolicySchema = import_zod18.z.object({
+  policy_id: import_zod18.z.string(),
+  display_name: import_zod18.z.string(),
+  config: import_zod18.z.record(import_zod18.z.unknown())
+}).passthrough();
+var StaticJobRemediationSchema = import_zod18.z.object({
+  remediation: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  mapping_remediation_id: import_zod18.z.string().nullable().optional(),
+  subcategories: import_zod18.z.array(import_zod18.z.string()).nullable().optional(),
+  effectiveness: import_zod18.z.number().int().optional(),
+  ease_of_implementation: import_zod18.z.number().int().optional(),
+  priority: import_zod18.z.number().int().optional(),
+  resource_links: import_zod18.z.array(import_zod18.z.string()).optional(),
+  categories: import_zod18.z.array(import_zod18.z.string()).nullable().optional()
+}).passthrough();
+var StaticJobRemediationRecommendationSchema = import_zod18.z.object({
+  runtime_security_policy_configuration: import_zod18.z.array(RuntimeSecurityPolicySchema).nullable().optional(),
+  other_measures: import_zod18.z.array(StaticJobRemediationSchema).optional()
+}).passthrough();
+var StaticJobReportSchema = import_zod18.z.object({
+  severity_report: SeverityReportSchema,
+  asr: import_zod18.z.number().nullable().optional(),
+  score: import_zod18.z.number().nullable().optional(),
+  security_report: CategoryReportSchema.nullable().optional(),
+  safety_report: CategoryReportSchema.nullable().optional(),
+  brand_report: CategoryReportSchema.nullable().optional(),
+  compliance_report: import_zod18.z.array(ComplianceReportSchema).nullable().optional(),
+  report_summary: import_zod18.z.string().nullable().optional(),
+  recommendations: StaticJobRemediationRecommendationSchema.nullable().optional()
+}).passthrough();
+var DynamicJobReportSchema = import_zod18.z.object({
+  total_goals: import_zod18.z.number().int().optional(),
+  total_streams: import_zod18.z.number().int().optional(),
+  total_threats: import_zod18.z.number().int().optional(),
+  goals_achieved: import_zod18.z.number().int().optional(),
+  report_summary: import_zod18.z.string().nullable().optional(),
+  score: import_zod18.z.number().optional(),
+  asr: import_zod18.z.number().optional()
+}).passthrough();
+var RemediationDetailSchema = import_zod18.z.object({
+  remediation: import_zod18.z.string(),
+  description: import_zod18.z.string(),
+  resource_links: import_zod18.z.array(import_zod18.z.string()).optional(),
+  priority_level: import_zod18.z.string().optional(),
+  ease_of_implementation_level: import_zod18.z.string().optional(),
+  effectiveness_level: import_zod18.z.string().optional()
+}).passthrough();
+var RemediationResponseSchema = import_zod18.z.object({ remediations: import_zod18.z.array(RemediationDetailSchema).optional() }).passthrough();
+var RuntimeSecurityProfileResponseSchema = import_zod18.z.object({
+  runtime_security_profile: import_zod18.z.array(RuntimeSecurityPolicySchema).nullable().optional()
+}).passthrough();
+var GoalSchema = import_zod18.z.object({
+  goal: import_zod18.z.string(),
+  safe_response: import_zod18.z.string(),
+  jailbroken_response: import_zod18.z.string(),
+  goal_metadata: import_zod18.z.record(import_zod18.z.unknown()).optional(),
+  custom_goal: import_zod18.z.boolean().optional(),
+  goal_type: import_zod18.z.string().optional(),
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  goal_to_show: import_zod18.z.string().nullable().optional(),
+  threat: import_zod18.z.boolean().optional(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional()
+}).passthrough();
+var GoalListResponseSchema = import_zod18.z.object({ pagination: RedTeamPaginationSchema, data: import_zod18.z.array(GoalSchema) }).passthrough();
+var StreamIterationDataSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  stream_id: import_zod18.z.string(),
+  goal_id: import_zod18.z.string(),
+  iteration: import_zod18.z.number().int(),
+  prompt: import_zod18.z.string(),
+  techniques: import_zod18.z.string(),
+  improvement: import_zod18.z.string(),
+  prompts_objective: import_zod18.z.string(),
+  summary: import_zod18.z.string(),
+  output: import_zod18.z.string().nullable().optional(),
+  score: import_zod18.z.number().int().nullable().optional(),
+  judge_reasoning: import_zod18.z.string().nullable().optional(),
+  threat: import_zod18.z.boolean().optional(),
+  created_at: import_zod18.z.string().nullable().optional(),
+  updated_at: import_zod18.z.string().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional(),
+  version: import_zod18.z.number().int().nullable().optional()
+}).passthrough();
+var StreamDetailResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  goal_id: import_zod18.z.string(),
+  stream_idx: import_zod18.z.number().int().optional(),
+  iteration: import_zod18.z.number().int().optional(),
+  goal: import_zod18.z.unknown().optional(),
+  marked_safe: import_zod18.z.boolean().optional(),
+  stream_type: import_zod18.z.string().nullable().optional(),
+  threat: import_zod18.z.boolean().optional(),
+  first_threat_iteration: StreamIterationDataSchema.nullable().optional(),
+  created_at: import_zod18.z.string().nullable().optional(),
+  updated_at: import_zod18.z.string().nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).optional(),
+  version: import_zod18.z.number().int().nullable().optional(),
+  iterations: import_zod18.z.array(StreamIterationDataSchema).optional()
+}).passthrough();
+var StreamListResponseSchema = import_zod18.z.object({ pagination: RedTeamPaginationSchema, data: import_zod18.z.array(StreamDetailResponseSchema) }).passthrough();
+var CustomAttackOutputSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  custom_attack_id: import_zod18.z.string(),
+  job_id: import_zod18.z.string(),
+  target_id: import_zod18.z.string(),
+  output: import_zod18.z.string(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  marked_safe: import_zod18.z.boolean().nullable().optional()
+}).passthrough();
+var PropertyAssignmentSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  value: import_zod18.z.string()
+});
+var PropertyValueStatisticSchema = import_zod18.z.object({
+  value: import_zod18.z.string(),
+  successful_attack_count: import_zod18.z.number().int(),
+  total_attack_count: import_zod18.z.number().int(),
+  success_rate: import_zod18.z.number()
+});
+var PropertyStatisticSchema = import_zod18.z.object({
+  property_name: import_zod18.z.string(),
+  values: import_zod18.z.array(PropertyValueStatisticSchema)
+});
+var PromptSetSummarySchema = import_zod18.z.object({
+  prompt_set_id: import_zod18.z.string(),
+  prompt_set_name: import_zod18.z.string(),
+  total_prompts: import_zod18.z.number().int(),
+  total_attacks: import_zod18.z.number().int(),
+  total_threats: import_zod18.z.number().int(),
+  failed_attacks: import_zod18.z.number().int(),
+  threat_rate: import_zod18.z.number(),
+  property_names: import_zod18.z.array(import_zod18.z.string()).optional(),
+  property_statistics: import_zod18.z.array(PropertyStatisticSchema).optional()
+}).passthrough();
+var CustomAttackReportResponseSchema = import_zod18.z.object({
+  total_prompts: import_zod18.z.number().int(),
+  total_attacks: import_zod18.z.number().int(),
+  total_threats: import_zod18.z.number().int(),
+  failed_attacks: import_zod18.z.number().int(),
+  score: import_zod18.z.number(),
+  asr: import_zod18.z.number(),
+  custom_attack_reports: import_zod18.z.array(PromptSetSummarySchema).optional(),
+  property_statistics: import_zod18.z.array(PropertyStatisticSchema).optional()
+}).passthrough();
+var PromptSetsReportResponseSchema = import_zod18.z.object({
+  prompt_sets: import_zod18.z.array(PromptSetSummarySchema),
+  total_prompt_sets: import_zod18.z.number().int(),
+  applied_filters: import_zod18.z.record(import_zod18.z.unknown()).optional()
+}).passthrough();
+var PromptDetailResponseSchema = import_zod18.z.object({
+  prompt_id: import_zod18.z.string(),
+  prompt_text: import_zod18.z.string(),
+  goal: import_zod18.z.string().nullable().optional(),
+  user_defined_goal: import_zod18.z.boolean().optional(),
+  properties: import_zod18.z.array(PropertyAssignmentSchema).optional(),
+  attack_id: import_zod18.z.string().nullable().optional(),
+  threat: import_zod18.z.boolean().nullable().optional(),
+  attack_outputs: import_zod18.z.array(CustomAttackOutputSchema).optional(),
+  asr: import_zod18.z.number().nullable().optional(),
+  prompt_set_id: import_zod18.z.string().nullable().optional(),
+  prompt_set_name: import_zod18.z.string().nullable().optional()
+}).passthrough();
+var CustomAttacksListResponseSchema = import_zod18.z.object({
+  pagination: RedTeamPaginationSchema,
+  data: import_zod18.z.array(import_zod18.z.unknown()),
+  total_attacks: import_zod18.z.number().int(),
+  total_threats: import_zod18.z.number().int()
+}).passthrough();
+var RiskLevelSchema = import_zod18.z.object({
+  risk_rating: import_zod18.z.string(),
+  total: import_zod18.z.number().int(),
+  targets_by_type: import_zod18.z.array(CountByNameSchema).optional()
+}).passthrough();
+var ScanStatisticsResponseSchema = import_zod18.z.object({
+  total_scans: import_zod18.z.number().int(),
+  targets_scanned: import_zod18.z.number().int(),
+  targets_scanned_by_type: import_zod18.z.array(CountByNameSchema).optional(),
+  scan_status: import_zod18.z.array(CountByNameSchema).optional(),
+  risk_profile: import_zod18.z.array(RiskLevelSchema).optional()
+}).passthrough();
+var ScoreTrendSeriesSchema = import_zod18.z.object({
+  label: import_zod18.z.string(),
+  data: import_zod18.z.array(import_zod18.z.number().nullable())
+});
+var ScoreTrendResponseSchema = import_zod18.z.object({
+  labels: import_zod18.z.array(import_zod18.z.string()),
+  series: import_zod18.z.array(ScoreTrendSeriesSchema)
+});
+var SentimentRequestSchema = import_zod18.z.object({
+  job_id: import_zod18.z.string(),
+  up_vote: import_zod18.z.boolean().optional(),
+  down_vote: import_zod18.z.boolean().optional()
+});
+var SentimentResponseSchema = import_zod18.z.object({
+  job_id: import_zod18.z.string(),
+  up_vote: import_zod18.z.boolean().optional(),
+  down_vote: import_zod18.z.boolean().optional()
+}).passthrough();
+var QuotaDetailsSchema = import_zod18.z.object({
+  allocated: import_zod18.z.number().int(),
+  unlimited: import_zod18.z.boolean(),
+  consumed: import_zod18.z.number().int()
+});
+var QuotaSummarySchema = import_zod18.z.object({
+  static: QuotaDetailsSchema,
+  dynamic: QuotaDetailsSchema,
+  custom: QuotaDetailsSchema
+});
+var ErrorLogSchema = import_zod18.z.object({
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  job_id: import_zod18.z.string().nullable().optional(),
+  target_id: import_zod18.z.string().nullable().optional(),
+  target_version: import_zod18.z.number().int().nullable().optional(),
+  attack_id: import_zod18.z.string().nullable().optional(),
+  error_type: import_zod18.z.string().nullable().optional(),
+  error_source: import_zod18.z.string().nullable().optional(),
+  error_message: import_zod18.z.string().nullable().optional(),
+  target_object: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional(),
+  extra_info: import_zod18.z.record(import_zod18.z.unknown()).nullable().optional(),
+  version: import_zod18.z.number().int().optional()
+}).passthrough();
+var ErrorLogListResponseSchema = import_zod18.z.object({ pagination: RedTeamPaginationSchema, data: import_zod18.z.array(ErrorLogSchema) }).passthrough();
+var TargetCreateRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  target_type: import_zod18.z.unknown().optional(),
+  connection_type: import_zod18.z.unknown().optional(),
+  api_endpoint_type: import_zod18.z.unknown().optional(),
+  response_mode: import_zod18.z.unknown().optional(),
+  connection_params: import_zod18.z.unknown().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  target_metadata: import_zod18.z.unknown().optional(),
+  target_background: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  network_broker_channel_uuid: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetUpdateRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  target_type: import_zod18.z.unknown().optional(),
+  connection_type: import_zod18.z.unknown().optional(),
+  api_endpoint_type: import_zod18.z.unknown().optional(),
+  response_mode: import_zod18.z.unknown().optional(),
+  connection_params: import_zod18.z.unknown().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  target_metadata: import_zod18.z.unknown().optional(),
+  target_background: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  network_broker_channel_uuid: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetContextUpdateSchema = import_zod18.z.object({
+  target_background: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  status: import_zod18.z.unknown(),
+  active: import_zod18.z.boolean(),
+  validated: import_zod18.z.boolean(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  target_type: import_zod18.z.unknown().optional(),
+  connection_type: import_zod18.z.unknown().optional(),
+  api_endpoint_type: import_zod18.z.unknown().optional(),
+  response_mode: import_zod18.z.unknown().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  version: import_zod18.z.unknown().optional(),
+  secret_version: import_zod18.z.unknown().optional(),
+  created_by_user_id: import_zod18.z.unknown().optional(),
+  updated_by_user_id: import_zod18.z.unknown().optional(),
+  target_metadata: import_zod18.z.unknown().optional(),
+  target_background: import_zod18.z.unknown().optional(),
+  profiling_status: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetListItemSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  tsg_id: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  status: import_zod18.z.unknown(),
+  active: import_zod18.z.boolean(),
+  validated: import_zod18.z.boolean(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  target_type: import_zod18.z.unknown().optional(),
+  connection_type: import_zod18.z.unknown().optional(),
+  api_endpoint_type: import_zod18.z.unknown().optional(),
+  response_mode: import_zod18.z.unknown().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  version: import_zod18.z.unknown().optional(),
+  secret_version: import_zod18.z.unknown().optional(),
+  created_by_user_id: import_zod18.z.unknown().optional(),
+  updated_by_user_id: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetListSchema = import_zod18.z.object({ pagination: RedTeamPaginationSchema, data: import_zod18.z.array(TargetListItemSchema).optional() }).passthrough();
+var TargetProbeRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  uuid: import_zod18.z.unknown().optional(),
+  description: import_zod18.z.unknown().optional(),
+  target_type: import_zod18.z.unknown().optional(),
+  connection_type: import_zod18.z.unknown().optional(),
+  api_endpoint_type: import_zod18.z.unknown().optional(),
+  response_mode: import_zod18.z.unknown().optional(),
+  connection_params: import_zod18.z.unknown().optional(),
+  session_supported: import_zod18.z.boolean().optional(),
+  target_metadata: import_zod18.z.unknown().optional(),
+  target_background: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  network_broker_channel_uuid: import_zod18.z.unknown().optional(),
+  probe_fields: import_zod18.z.unknown().optional()
+}).passthrough();
+var TargetProfileResponseSchema = import_zod18.z.object({
+  target_id: import_zod18.z.string(),
+  target_version: import_zod18.z.number().int(),
+  status: import_zod18.z.string(),
+  profiling_status: import_zod18.z.unknown().optional(),
+  target_background: import_zod18.z.unknown().optional(),
+  additional_context: import_zod18.z.unknown().optional(),
+  ai_generated_fields: import_zod18.z.unknown().optional(),
+  other_details: import_zod18.z.unknown().optional()
+}).passthrough();
+var BaseResponseSchema = import_zod18.z.object({
+  message: import_zod18.z.string(),
+  status: import_zod18.z.number().int()
+});
+var PromptSetStatsSchema = import_zod18.z.object({
+  total_prompts: import_zod18.z.number().int(),
+  active_prompts: import_zod18.z.number().int(),
+  inactive_prompts: import_zod18.z.number().int(),
+  failed_prompts: import_zod18.z.number().int().optional(),
+  validation_prompts: import_zod18.z.number().int().optional()
+}).passthrough();
+var CustomPromptSetCreateRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  property_names: import_zod18.z.array(import_zod18.z.string()).optional()
+});
+var CustomPromptSetUpdateRequestSchema = import_zod18.z.object({
+  name: import_zod18.z.unknown().optional(),
+  description: import_zod18.z.unknown().optional(),
+  archive: import_zod18.z.unknown().optional(),
+  property_names: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptSetArchiveRequestSchema = import_zod18.z.object({ archive: import_zod18.z.boolean() });
+var CustomPromptSetResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  archive: import_zod18.z.boolean(),
+  status: import_zod18.z.string(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  property_names: import_zod18.z.array(import_zod18.z.string()).optional(),
+  properties: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+  stats: import_zod18.z.unknown().optional(),
+  extra_info: import_zod18.z.unknown().optional(),
+  version: import_zod18.z.unknown().optional(),
+  created_by_user_id: import_zod18.z.unknown().optional(),
+  updated_by_user_id: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptSetListItemSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  archive: import_zod18.z.boolean(),
+  status: import_zod18.z.string(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  description: import_zod18.z.unknown().optional(),
+  property_names: import_zod18.z.array(import_zod18.z.string()).optional(),
+  stats: import_zod18.z.unknown().optional(),
+  created_by_user_id: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptSetListSchema = import_zod18.z.object({
+  pagination: RedTeamPaginationSchema,
+  data: import_zod18.z.array(CustomPromptSetListItemSchema).optional()
+}).passthrough();
+var CustomPromptSetListActiveSchema = import_zod18.z.object({ data: import_zod18.z.array(CustomPromptSetListItemSchema).optional() }).passthrough();
+var CustomPromptSetReferenceSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  status: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  tsg_id: import_zod18.z.string(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  version: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptSetVersionInfoSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  status: import_zod18.z.string(),
+  is_latest: import_zod18.z.boolean(),
+  version: import_zod18.z.unknown().optional(),
+  stats: import_zod18.z.unknown().optional(),
+  snapshot_created_at: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptCreateRequestSchema = import_zod18.z.object({
+  prompt: import_zod18.z.string(),
+  prompt_set_id: import_zod18.z.string(),
+  goal: import_zod18.z.unknown().optional(),
+  properties: import_zod18.z.unknown().optional()
+});
+var CustomPromptUpdateRequestSchema = import_zod18.z.object({
+  prompt: import_zod18.z.unknown().optional(),
+  goal: import_zod18.z.unknown().optional(),
+  properties: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptResponseSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  user_defined_goal: import_zod18.z.boolean(),
+  status: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  prompt_set_id: import_zod18.z.string(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  goal: import_zod18.z.unknown().optional(),
+  properties: import_zod18.z.unknown().optional(),
+  property_assignments: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+  detector_category: import_zod18.z.unknown().optional(),
+  severity: import_zod18.z.unknown().optional(),
+  extra_info: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptListItemSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  prompt: import_zod18.z.string(),
+  user_defined_goal: import_zod18.z.boolean(),
+  status: import_zod18.z.string(),
+  active: import_zod18.z.boolean(),
+  created_at: import_zod18.z.string(),
+  updated_at: import_zod18.z.string(),
+  goal: import_zod18.z.unknown().optional(),
+  properties: import_zod18.z.unknown().optional()
+}).passthrough();
+var CustomPromptListSchema = import_zod18.z.object({
+  pagination: RedTeamPaginationSchema,
+  data: import_zod18.z.array(CustomPromptListItemSchema).optional()
+}).passthrough();
+var PropertyNameCreateRequestSchema = import_zod18.z.object({ name: import_zod18.z.string() });
+var PropertyValueCreateRequestSchema = import_zod18.z.object({
+  property_name: import_zod18.z.string(),
+  property_value: import_zod18.z.string()
+});
+var PropertyDefinitionSchema = import_zod18.z.object({
+  property_name: import_zod18.z.string(),
+  created_at: import_zod18.z.string()
+});
+var PropertyNamesListResponseSchema = import_zod18.z.object({ data: import_zod18.z.array(PropertyDefinitionSchema).optional() }).passthrough();
+var PropertyValuesResponseSchema = import_zod18.z.object({
+  name: import_zod18.z.string(),
+  values: import_zod18.z.array(import_zod18.z.string()).optional()
+}).passthrough();
+var PropertyValuesMultipleResponseSchema = import_zod18.z.object({ data: import_zod18.z.record(import_zod18.z.array(import_zod18.z.string())).optional() }).passthrough();
+var DashboardOverviewResponseSchema = import_zod18.z.object({
+  total_targets: import_zod18.z.number().int(),
+  targets_by_type: import_zod18.z.array(CountByNameSchema).optional()
+}).passthrough();
+
+// src/models/oauth-token.ts
+var import_zod19 = require("zod");
+var OAuthTokenResponseSchema = import_zod19.z.object({
+  access_token: import_zod19.z.string(),
+  token_type: import_zod19.z.string().optional(),
+  expires_in: import_zod19.z.number(),
+  scope: import_zod19.z.string().optional()
 });
 
 // src/management/oauth-client.ts
@@ -929,6 +2662,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;
@@ -941,6 +2678,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;
@@ -985,76 +2723,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
@@ -1069,6 +2774,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",
@@ -1080,6 +2790,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),
@@ -1095,6 +2810,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(
@@ -1112,6 +2833,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(
@@ -1142,6 +2868,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",
@@ -1153,6 +2884,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),
@@ -1168,6 +2904,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(
@@ -1185,6 +2927,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(
@@ -1201,6 +2948,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(
@@ -1271,6 +3023,1708 @@ 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;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AISecSDKException,
@@ -1278,33 +4732,115 @@ var ManagementClient = class {
   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,
@@ -1330,28 +4866,167 @@ var ManagementClient = class {
   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,
@@ -1359,6 +5034,10 @@ var ManagementClient = class {
   TopicsClient,
   USER_AGENT,
   UrlfEntrySchema,
+  ValidationErrorSchema,
+  Verdict,
+  ViolationListSchema,
+  ViolationResponseSchema,
   globalConfiguration,
   init
 });