npm - @cdot65/prisma-airs-sdk - Versions diffs - 0.2.1 → 0.5.0 - Mend

@cdot65/prisma-airs-sdk 0.2.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.cjs CHANGED Viewed

@@ -28,32 +28,112 @@ __export(index_exports, {
   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,
@@ -79,28 +159,168 @@ __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,
+  OAuthClient: () => OAuthClient,
   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,
@@ -108,7 +328,10 @@ __export(index_exports, {
   TopicsClient: () => TopicsClient,
   USER_AGENT: () => USER_AGENT,
   UrlfEntrySchema: () => UrlfEntrySchema,
+  ValidationErrorSchema: () => ValidationErrorSchema,
   Verdict: () => Verdict,
+  ViolationListSchema: () => ViolationListSchema,
+  ViolationResponseSchema: () => ViolationResponseSchema,
   globalConfiguration: () => globalConfiguration,
   init: () => init
 });
@@ -139,7 +362,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.2.1";
+var SDK_VERSION = "0.5.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";
@@ -157,6 +380,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) => {
@@ -991,22 +1249,1413 @@ 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
-var TOKEN_BUFFER_MS = 3e4;
+var DEFAULT_TOKEN_BUFFER_MS = 3e4;
 var OAuthClient = class {
   tokenEndpoint;
   clientId;
   clientSecret;
   tsgId;
+  tokenBufferMs;
+  onTokenRefresh;
   accessToken = null;
   expiresAt = 0;
   pendingFetch = null;
@@ -1015,13 +2664,15 @@ var OAuthClient = class {
     this.clientSecret = opts.clientSecret;
     this.tsgId = opts.tsgId;
     this.tokenEndpoint = opts.tokenEndpoint ?? DEFAULT_TOKEN_ENDPOINT;
+    this.tokenBufferMs = opts.tokenBufferMs ?? DEFAULT_TOKEN_BUFFER_MS;
+    this.onTokenRefresh = opts.onTokenRefresh;
   }
   /**
    * 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) {
+    if (this.accessToken && Date.now() < this.expiresAt - this.tokenBufferMs) {
       return this.accessToken;
     }
     if (this.pendingFetch) {
@@ -1037,6 +2688,40 @@ var OAuthClient = class {
     this.accessToken = null;
     this.expiresAt = 0;
   }
+  /** Check if the current token has passed its expiry time. Returns true if no token exists. */
+  isTokenExpired() {
+    if (!this.accessToken) return true;
+    return Date.now() >= this.expiresAt;
+  }
+  /**
+   * Check if the token is within the pre-expiry buffer window.
+   * Returns true if no token exists.
+   * @param bufferMs - Custom buffer in ms. Defaults to the configured `tokenBufferMs`.
+   */
+  isTokenExpiringSoon(bufferMs) {
+    if (!this.accessToken) return true;
+    const buffer = bufferMs ?? this.tokenBufferMs;
+    return Date.now() >= this.expiresAt - buffer;
+  }
+  /**
+   * Get a snapshot of the current token state without exposing the actual token value.
+   * @returns Current {@link TokenInfo}.
+   */
+  getTokenInfo() {
+    const now = Date.now();
+    const hasToken = this.accessToken !== null;
+    const isExpired = !hasToken || now >= this.expiresAt;
+    const isExpiringSoon = !hasToken || now >= this.expiresAt - this.tokenBufferMs;
+    const expiresInMs = hasToken ? Math.max(0, this.expiresAt - now) : 0;
+    return {
+      hasToken,
+      isValid: hasToken && !isExpiringSoon,
+      isExpired,
+      isExpiringSoon,
+      expiresInMs,
+      expiresAt: hasToken ? this.expiresAt : 0
+    };
+  }
   async fetchToken() {
     const credentials = btoa(`${this.clientId}:${this.clientSecret}`);
     const body = new URLSearchParams({
@@ -1072,6 +2757,12 @@ var OAuthClient = class {
     const data = OAuthTokenResponseSchema.parse(await response.json());
     this.accessToken = data.access_token;
     this.expiresAt = Date.now() + data.expires_in * 1e3;
+    if (this.onTokenRefresh) {
+      try {
+        this.onTokenRefresh(this.getTokenInfo());
+      } catch {
+      }
+    }
     return this.accessToken;
   }
 };
@@ -1103,7 +2794,7 @@ async function managementHttpRequest(opts) {
       return fetch(url.toString(), { method, headers, body: bodyStr });
     },
     onRetryableFailure: async (response2) => {
-      if (response2.status === 401 && !hadTokenRefresh) {
+      if ((response2.status === 401 || response2.status === 403) && !hadTokenRefresh) {
         hadTokenRefresh = true;
         oauthClient.clearToken();
         return true;
@@ -1377,6 +3068,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,
@@ -1387,32 +4780,112 @@ var ManagementClient = class {
   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,
@@ -1438,28 +4911,168 @@ 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,
+  OAuthClient,
   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,
@@ -1467,7 +5080,10 @@ var ManagementClient = class {
   TopicsClient,
   USER_AGENT,
   UrlfEntrySchema,
+  ValidationErrorSchema,
   Verdict,
+  ViolationListSchema,
+  ViolationResponseSchema,
   globalConfiguration,
   init
 });