@cdot65/prisma-airs-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,724 @@
+// src/constants.ts
+var HEADER_API_KEY = "x-pan-token";
+var HEADER_AUTH_TOKEN = "Authorization";
+var PAYLOAD_HASH = "x-payload-hash";
+var BEARER = "Bearer ";
+var DEFAULT_ENDPOINT = "https://service.api.aisecurity.paloaltonetworks.com";
+var AI_SEC_API_KEY = "PANW_AI_SEC_API_KEY";
+var AI_SEC_API_TOKEN = "PANW_AI_SEC_API_TOKEN";
+var AI_SEC_API_ENDPOINT = "PANW_AI_SEC_API_ENDPOINT";
+var MAX_CONTENT_PROMPT_LENGTH = 2 * 1024 * 1024;
+var MAX_CONTENT_RESPONSE_LENGTH = 2 * 1024 * 1024;
+var MAX_CONTENT_CONTEXT_LENGTH = 100 * 1024 * 1024;
+var MAX_API_KEY_LENGTH = 2048;
+var MAX_TOKEN_LENGTH = 2048;
+var MAX_TRANSACTION_ID_STR_LENGTH = 100;
+var MAX_SESSION_ID_STR_LENGTH = 100;
+var MAX_SCAN_ID_STR_LENGTH = 36;
+var MAX_REPORT_ID_STR_LENGTH = 40;
+var MAX_AI_PROFILE_NAME_LENGTH = 100;
+var MAX_NUMBER_OF_SCAN_IDS = 5;
+var MAX_NUMBER_OF_REPORT_IDS = 5;
+var MAX_NUMBER_OF_BATCH_SCAN_OBJECTS = 5;
+var MAX_CONNECTION_POOL_SIZE = 100;
+var MAX_NUMBER_OF_RETRIES = 5;
+var HTTP_FORCE_RETRY_STATUS_CODES = [500, 502, 503, 504];
+var SDK_VERSION = "0.1.0";
+var USER_AGENT = `PAN-AIRS/${SDK_VERSION}-typescript-sdk`;
+var SYNC_SCAN_PATH = "/v1/scan/sync/request";
+var ASYNC_SCAN_PATH = "/v1/scan/async/request";
+var SCAN_RESULTS_PATH = "/v1/scan/results";
+var SCAN_REPORTS_PATH = "/v1/scan/reports";
+
+// src/errors.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["SERVER_SIDE_ERROR"] = "AISEC_SERVER_SIDE_ERROR";
+  ErrorType2["CLIENT_SIDE_ERROR"] = "AISEC_CLIENT_SIDE_ERROR";
+  ErrorType2["USER_REQUEST_PAYLOAD_ERROR"] = "AISEC_USER_REQUEST_PAYLOAD_ERROR";
+  ErrorType2["MISSING_VARIABLE"] = "AISEC_MISSING_VARIABLE";
+  ErrorType2["AISEC_SDK_ERROR"] = "AISEC_SDK_ERROR";
+  return ErrorType2;
+})(ErrorType || {});
+var AISecSDKException = class _AISecSDKException extends Error {
+  errorType;
+  constructor(message, errorType) {
+    super(errorType ? `${errorType}:${message}` : message);
+    this.name = "AISecSDKException";
+    this.errorType = errorType;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AISecSDKException);
+    }
+  }
+};
+
+// src/configuration.ts
+var Configuration = class {
+  _apiKey;
+  _apiToken;
+  _apiEndpoint = DEFAULT_ENDPOINT;
+  _numRetries = MAX_NUMBER_OF_RETRIES;
+  _initialized = false;
+  get apiKey() {
+    return this._apiKey;
+  }
+  get apiToken() {
+    return this._apiToken;
+  }
+  get apiEndpoint() {
+    return this._apiEndpoint;
+  }
+  get numRetries() {
+    return this._numRetries;
+  }
+  get initialized() {
+    return this._initialized;
+  }
+  init(opts = {}) {
+    const apiKey = (opts.apiKey ?? process.env[AI_SEC_API_KEY] ?? "").trim() || void 0;
+    const apiToken = (opts.apiToken ?? process.env[AI_SEC_API_TOKEN] ?? "").trim() || void 0;
+    if (!apiKey && !apiToken) {
+      throw new AISecSDKException(
+        "Either apiKey or apiToken must be provided (or set via environment variables)",
+        "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+      );
+    }
+    if (apiKey && apiKey.length > MAX_API_KEY_LENGTH) {
+      throw new AISecSDKException(
+        `apiKey exceeds max length of ${MAX_API_KEY_LENGTH}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (apiToken && apiToken.length > MAX_TOKEN_LENGTH) {
+      throw new AISecSDKException(
+        `apiToken exceeds max length of ${MAX_TOKEN_LENGTH}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._apiKey = apiKey;
+    this._apiToken = apiToken;
+    const endpoint = opts.apiEndpoint ?? process.env[AI_SEC_API_ENDPOINT] ?? DEFAULT_ENDPOINT;
+    this._apiEndpoint = endpoint.replace(/\/+$/, "");
+    if (opts.numRetries !== void 0) {
+      if (opts.numRetries < 0 || opts.numRetries > MAX_NUMBER_OF_RETRIES) {
+        throw new AISecSDKException(
+          `numRetries must be between 0 and ${MAX_NUMBER_OF_RETRIES}`,
+          "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+        );
+      }
+      this._numRetries = opts.numRetries;
+    }
+    this._initialized = true;
+  }
+  reset() {
+    this._apiKey = void 0;
+    this._apiToken = void 0;
+    this._apiEndpoint = DEFAULT_ENDPOINT;
+    this._numRetries = MAX_NUMBER_OF_RETRIES;
+    this._initialized = false;
+  }
+};
+var globalConfiguration = new Configuration();
+function init(opts = {}) {
+  globalConfiguration.init(opts);
+}
+
+// src/utils.ts
+import { createHmac } from "crypto";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidUuid(value) {
+  return UUID_RE.test(value);
+}
+function generatePayloadHash(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+
+// src/http-client.ts
+function buildHeaders() {
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": USER_AGENT
+  };
+  const cfg = globalConfiguration;
+  if (cfg.apiToken) {
+    headers[HEADER_AUTH_TOKEN] = `${BEARER}${cfg.apiToken}`;
+  }
+  if (cfg.apiKey) {
+    headers[HEADER_API_KEY] = cfg.apiKey;
+  }
+  return headers;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function httpRequest(opts) {
+  if (!globalConfiguration.initialized) {
+    throw new AISecSDKException(
+      "SDK not initialized. Call init() before making requests.",
+      "AISEC_MISSING_VARIABLE" /* MISSING_VARIABLE */
+    );
+  }
+  const baseUrl = globalConfiguration.apiEndpoint;
+  const url = new URL(opts.path, baseUrl);
+  if (opts.params) {
+    for (const [key, value] of Object.entries(opts.params)) {
+      url.searchParams.set(key, value);
+    }
+  }
+  const headers = buildHeaders();
+  let bodyStr;
+  if (opts.body !== void 0) {
+    bodyStr = JSON.stringify(opts.body);
+    if (globalConfiguration.apiKey) {
+      headers[PAYLOAD_HASH] = generatePayloadHash(bodyStr, globalConfiguration.apiKey);
+    }
+  }
+  const maxRetries = globalConfiguration.numRetries;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url.toString(), {
+        method: opts.method,
+        headers,
+        body: bodyStr
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return { status: response.status, data };
+      }
+      if (HTTP_FORCE_RETRY_STATUS_CODES.includes(response.status) && attempt < maxRetries) {
+        await sleep(Math.pow(2, attempt) * 1e3);
+        continue;
+      }
+      let errorMessage;
+      try {
+        const errorBody = await response.json();
+        errorMessage = errorBody.message ?? errorBody.error?.message ?? `API error ${response.status}`;
+      } catch {
+        errorMessage = `API error ${response.status}`;
+      }
+      const errorType = response.status >= 500 ? "AISEC_SERVER_SIDE_ERROR" /* SERVER_SIDE_ERROR */ : "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */;
+      throw new AISecSDKException(errorMessage, errorType);
+    } catch (err) {
+      if (err instanceof AISecSDKException) {
+        throw err;
+      }
+      lastError = err;
+      if (attempt < maxRetries) {
+        await sleep(Math.pow(2, attempt) * 1e3);
+        continue;
+      }
+    }
+  }
+  throw new AISecSDKException(lastError?.message ?? "Network error", "AISEC_CLIENT_SIDE_ERROR" /* CLIENT_SIDE_ERROR */);
+}
+
+// src/scan/scanner.ts
+var Scanner = class {
+  async syncScan(aiProfile, content, opts = {}) {
+    if (opts.trId && opts.trId.length > MAX_TRANSACTION_ID_STR_LENGTH) {
+      throw new AISecSDKException(
+        `trId exceeds max length of ${MAX_TRANSACTION_ID_STR_LENGTH}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (opts.sessionId && opts.sessionId.length > MAX_SESSION_ID_STR_LENGTH) {
+      throw new AISecSDKException(
+        `sessionId exceeds max length of ${MAX_SESSION_ID_STR_LENGTH}`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const body = {
+      ai_profile: aiProfile,
+      contents: [content.toJSON()]
+    };
+    if (opts.trId) body.tr_id = opts.trId;
+    if (opts.sessionId) body.session_id = opts.sessionId;
+    if (opts.metadata) body.metadata = opts.metadata;
+    const res = await httpRequest({
+      method: "POST",
+      path: SYNC_SCAN_PATH,
+      body
+    });
+    return res.data;
+  }
+  async asyncScan(scanObjects) {
+    if (scanObjects.length < 1) {
+      throw new AISecSDKException(
+        "At least 1 scan object is required",
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (scanObjects.length > MAX_NUMBER_OF_BATCH_SCAN_OBJECTS) {
+      throw new AISecSDKException(
+        `Max of ${MAX_NUMBER_OF_BATCH_SCAN_OBJECTS} scan objects allowed`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await httpRequest({
+      method: "POST",
+      path: ASYNC_SCAN_PATH,
+      body: scanObjects
+    });
+    return res.data;
+  }
+  async queryByScanIds(scanIds) {
+    if (scanIds.length < 1) {
+      throw new AISecSDKException(
+        "At least 1 scan_id is required",
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (scanIds.length > MAX_NUMBER_OF_SCAN_IDS) {
+      throw new AISecSDKException(
+        `Max of ${MAX_NUMBER_OF_SCAN_IDS} scan_ids allowed`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    for (const id of scanIds) {
+      if (!isValidUuid(id)) {
+        throw new AISecSDKException(`Invalid scan_id: ${id}`, "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */);
+      }
+    }
+    const res = await httpRequest({
+      method: "GET",
+      path: SCAN_RESULTS_PATH,
+      params: { scan_ids: scanIds.join(",") }
+    });
+    return res.data;
+  }
+  async queryByReportIds(reportIds) {
+    if (reportIds.length < 1) {
+      throw new AISecSDKException(
+        "At least 1 report_id is required",
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (reportIds.length > MAX_NUMBER_OF_REPORT_IDS) {
+      throw new AISecSDKException(
+        `Max of ${MAX_NUMBER_OF_REPORT_IDS} report_ids allowed`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    const res = await httpRequest({
+      method: "GET",
+      path: SCAN_REPORTS_PATH,
+      params: { report_ids: reportIds.join(",") }
+    });
+    return res.data;
+  }
+};
+
+// src/scan/content.ts
+import { readFileSync } from "fs";
+var Content = class _Content {
+  _prompt;
+  _response;
+  _context;
+  _codePrompt;
+  _codeResponse;
+  _toolEvent;
+  constructor(opts) {
+    if (!opts.prompt && !opts.response && !opts.codePrompt && !opts.codeResponse && !opts.toolEvent) {
+      throw new AISecSDKException(
+        "At least one of prompt, response, codePrompt, codeResponse, or toolEvent must be provided",
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    if (opts.prompt !== void 0) this.prompt = opts.prompt;
+    if (opts.response !== void 0) this.response = opts.response;
+    if (opts.context !== void 0) this.context = opts.context;
+    if (opts.codePrompt !== void 0) this.codePrompt = opts.codePrompt;
+    if (opts.codeResponse !== void 0) this.codeResponse = opts.codeResponse;
+    if (opts.toolEvent !== void 0) this._toolEvent = opts.toolEvent;
+  }
+  get prompt() {
+    return this._prompt;
+  }
+  set prompt(value) {
+    if (value !== void 0 && Buffer.byteLength(value) > MAX_CONTENT_PROMPT_LENGTH) {
+      throw new AISecSDKException(
+        `prompt exceeds max length of ${MAX_CONTENT_PROMPT_LENGTH} bytes`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._prompt = value;
+  }
+  get response() {
+    return this._response;
+  }
+  set response(value) {
+    if (value !== void 0 && Buffer.byteLength(value) > MAX_CONTENT_RESPONSE_LENGTH) {
+      throw new AISecSDKException(
+        `response exceeds max length of ${MAX_CONTENT_RESPONSE_LENGTH} bytes`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._response = value;
+  }
+  get context() {
+    return this._context;
+  }
+  set context(value) {
+    if (value !== void 0 && Buffer.byteLength(value) > MAX_CONTENT_CONTEXT_LENGTH) {
+      throw new AISecSDKException(
+        `context exceeds max length of ${MAX_CONTENT_CONTEXT_LENGTH} bytes`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._context = value;
+  }
+  get codePrompt() {
+    return this._codePrompt;
+  }
+  set codePrompt(value) {
+    if (value !== void 0 && Buffer.byteLength(value) > MAX_CONTENT_PROMPT_LENGTH) {
+      throw new AISecSDKException(
+        `codePrompt exceeds max length of ${MAX_CONTENT_PROMPT_LENGTH} bytes`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._codePrompt = value;
+  }
+  get codeResponse() {
+    return this._codeResponse;
+  }
+  set codeResponse(value) {
+    if (value !== void 0 && Buffer.byteLength(value) > MAX_CONTENT_RESPONSE_LENGTH) {
+      throw new AISecSDKException(
+        `codeResponse exceeds max length of ${MAX_CONTENT_RESPONSE_LENGTH} bytes`,
+        "AISEC_USER_REQUEST_PAYLOAD_ERROR" /* USER_REQUEST_PAYLOAD_ERROR */
+      );
+    }
+    this._codeResponse = value;
+  }
+  get toolEvent() {
+    return this._toolEvent;
+  }
+  set toolEvent(value) {
+    this._toolEvent = value;
+  }
+  get length() {
+    let total = 0;
+    if (this._prompt) total += Buffer.byteLength(this._prompt);
+    if (this._response) total += Buffer.byteLength(this._response);
+    if (this._context) total += Buffer.byteLength(this._context);
+    if (this._codePrompt) total += Buffer.byteLength(this._codePrompt);
+    if (this._codeResponse) total += Buffer.byteLength(this._codeResponse);
+    return total;
+  }
+  toJSON() {
+    const obj = {};
+    if (this._prompt !== void 0) obj.prompt = this._prompt;
+    if (this._response !== void 0) obj.response = this._response;
+    if (this._context !== void 0) obj.context = this._context;
+    if (this._codePrompt !== void 0) obj.code_prompt = this._codePrompt;
+    if (this._codeResponse !== void 0) obj.code_response = this._codeResponse;
+    if (this._toolEvent !== void 0) obj.tool_event = this._toolEvent;
+    return obj;
+  }
+  static fromJSON(json) {
+    return new _Content({
+      prompt: json.prompt,
+      response: json.response,
+      context: json.context,
+      codePrompt: json.code_prompt,
+      codeResponse: json.code_response,
+      toolEvent: json.tool_event
+    });
+  }
+  static fromJSONFile(filePath) {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return _Content.fromJSON(parsed);
+  }
+};
+
+// src/models/ai-profile.ts
+import { z } from "zod";
+var AiProfileSchema = z.object({
+  profile_id: z.string().uuid().optional(),
+  profile_name: z.string().max(MAX_AI_PROFILE_NAME_LENGTH).optional()
+}).refine((d) => d.profile_id || d.profile_name, {
+  message: "Either profile_id or profile_name must be provided"
+});
+
+// src/models/metadata.ts
+import { z as z2 } from "zod";
+var AgentMetaSchema = z2.object({
+  agent_id: z2.string().optional(),
+  agent_version: z2.string().optional(),
+  agent_arn: z2.string().optional()
+});
+var MetadataSchema = z2.object({
+  app_name: z2.string().optional(),
+  app_user: z2.string().optional(),
+  ai_model: z2.string().optional(),
+  user_ip: z2.string().optional(),
+  agent_meta: AgentMetaSchema.optional()
+});
+
+// src/models/tool-event.ts
+import { z as z3 } from "zod";
+var ToolEventMetadataSchema = z3.object({
+  ecosystem: z3.string(),
+  method: z3.string(),
+  server_name: z3.string(),
+  tool_invoked: z3.string().optional()
+});
+var ToolEventSchema = z3.object({
+  metadata: ToolEventMetadataSchema.optional(),
+  input: z3.string().optional(),
+  output: z3.string().optional()
+});
+
+// src/models/scan-request.ts
+import { z as z4 } from "zod";
+var ScanRequestContentsInnerSchema = z4.object({
+  prompt: z4.string().optional(),
+  response: z4.string().optional(),
+  code_prompt: z4.string().optional(),
+  code_response: z4.string().optional(),
+  context: z4.string().optional(),
+  tool_event: ToolEventSchema.optional()
+});
+var ScanRequestSchema = z4.object({
+  tr_id: z4.string().max(MAX_TRANSACTION_ID_STR_LENGTH).optional(),
+  session_id: z4.string().max(MAX_SESSION_ID_STR_LENGTH).optional(),
+  ai_profile: AiProfileSchema,
+  metadata: MetadataSchema.optional(),
+  contents: z4.array(ScanRequestContentsInnerSchema).min(1)
+});
+
+// src/models/scan-response.ts
+import { z as z7 } from "zod";
+
+// src/models/prompt-detected.ts
+import { z as z5 } from "zod";
+var PromptDetectionDetailsSchema = z5.object({
+  topic_guardrails_details: z5.record(z5.unknown()).optional()
+});
+var PromptDetectedSchema = z5.object({
+  url_cats: z5.boolean().optional(),
+  dlp: z5.boolean().optional(),
+  injection: z5.boolean().optional(),
+  toxic_content: z5.boolean().optional(),
+  malicious_code: z5.boolean().optional(),
+  agent: z5.boolean().optional(),
+  topic_violation: z5.boolean().optional()
+});
+
+// src/models/response-detected.ts
+import { z as z6 } from "zod";
+var ResponseDetectionDetailsSchema = z6.object({
+  topic_guardrails_details: z6.record(z6.unknown()).optional()
+});
+var ResponseDetectedSchema = z6.object({
+  url_cats: z6.boolean().optional(),
+  dlp: z6.boolean().optional(),
+  db_security: z6.boolean().optional(),
+  toxic_content: z6.boolean().optional(),
+  malicious_code: z6.boolean().optional(),
+  agent: z6.boolean().optional(),
+  ungrounded: z6.boolean().optional(),
+  topic_violation: z6.boolean().optional()
+});
+
+// src/models/scan-response.ts
+var MaskedDataSchema = z7.object({
+  data: z7.string().optional(),
+  pattern_detections: z7.array(z7.record(z7.unknown())).optional()
+});
+var IODetectedSchema = z7.object({
+  url_cats: z7.boolean().optional(),
+  dlp: z7.boolean().optional(),
+  injection: z7.boolean().optional(),
+  toxic_content: z7.boolean().optional(),
+  malicious_code: z7.boolean().optional()
+}).passthrough();
+var ScanSummarySchema = z7.object({
+  verdict: z7.string().optional(),
+  action: z7.string().optional()
+}).passthrough();
+var ToolDetectedSchema = z7.object({
+  verdict: z7.string().optional(),
+  metadata: ToolEventMetadataSchema.optional(),
+  summary: ScanSummarySchema.optional(),
+  input_detected: IODetectedSchema.optional(),
+  output_detected: IODetectedSchema.optional()
+});
+var ScanResponseSchema = z7.object({
+  source: z7.string().optional(),
+  report_id: z7.string(),
+  scan_id: z7.string(),
+  tr_id: z7.string().optional(),
+  session_id: z7.string().optional(),
+  profile_id: z7.string().optional(),
+  profile_name: z7.string().optional(),
+  category: z7.string(),
+  action: z7.string(),
+  prompt_detected: PromptDetectedSchema.optional(),
+  response_detected: ResponseDetectedSchema.optional(),
+  prompt_masked_data: MaskedDataSchema.optional(),
+  response_masked_data: MaskedDataSchema.optional(),
+  prompt_detection_details: PromptDetectionDetailsSchema.optional(),
+  response_detection_details: ResponseDetectionDetailsSchema.optional(),
+  tool_detected: ToolDetectedSchema.optional(),
+  created_at: z7.string().optional(),
+  completed_at: z7.string().optional()
+});
+
+// src/models/async-scan.ts
+import { z as z8 } from "zod";
+var AsyncScanObjectSchema = z8.object({
+  req_id: z8.number().int(),
+  scan_req: ScanRequestSchema
+});
+var AsyncScanResponseSchema = z8.object({
+  received: z8.string(),
+  scan_id: z8.string(),
+  report_id: z8.string().optional(),
+  source: z8.string().optional()
+});
+
+// src/models/scan-id-result.ts
+import { z as z9 } from "zod";
+var ScanIdResultSchema = z9.object({
+  source: z9.string().optional(),
+  req_id: z9.number().optional(),
+  status: z9.string().optional(),
+  scan_id: z9.string().optional(),
+  result: ScanResponseSchema.optional()
+});
+
+// src/models/threat-report.ts
+import { z as z13 } from "zod";
+
+// src/models/detection.ts
+import { z as z12 } from "zod";
+
+// src/models/dlp-report.ts
+import { z as z10 } from "zod";
+var DlpReportSchema = z10.object({
+  dlp_report_id: z10.string().optional(),
+  dlp_profile_name: z10.string().optional(),
+  dlp_profile_id: z10.string().optional(),
+  dlp_profile_version: z10.number().optional(),
+  data_pattern_rule1_verdict: z10.string().optional(),
+  data_pattern_rule2_verdict: z10.string().optional()
+});
+
+// src/models/urlf-report.ts
+import { z as z11 } from "zod";
+var UrlfEntrySchema = z11.object({
+  url: z11.string().optional(),
+  risk_level: z11.string().optional(),
+  categories: z11.array(z11.string()).optional()
+});
+
+// src/models/detection.ts
+var DSDetailResultSchema = z12.object({
+  urlf_report: z12.array(UrlfEntrySchema).optional(),
+  dlp_report: DlpReportSchema.optional()
+});
+var DSResultMetadataSchema = z12.object({
+  score: z12.number().optional(),
+  confidence: z12.string().optional()
+}).passthrough();
+var DetectionServiceResultSchema = z12.object({
+  data_type: z12.string().optional(),
+  detection_service: z12.string().optional(),
+  verdict: z12.string().optional(),
+  action: z12.string().optional(),
+  metadata: DSResultMetadataSchema.optional(),
+  result_detail: DSDetailResultSchema.optional()
+});
+
+// src/models/threat-report.ts
+var ThreatScanReportSchema = z13.object({
+  source: z13.string().optional(),
+  report_id: z13.string().optional(),
+  scan_id: z13.string().optional(),
+  req_id: z13.number().optional(),
+  transaction_id: z13.string().optional(),
+  session_id: z13.string().optional(),
+  detection_results: z13.array(DetectionServiceResultSchema).optional()
+});
+
+// src/models/error-response.ts
+import { z as z14 } from "zod";
+var ErrorResponseSchema = z14.object({
+  status_code: z14.number().optional(),
+  message: z14.string().optional(),
+  error: z14.object({
+    message: z14.string().optional()
+  }).passthrough().optional(),
+  retry_after: z14.object({
+    interval: z14.number().optional(),
+    unit: z14.string().optional()
+  }).optional()
+});
+export {
+  AISecSDKException,
+  AI_SEC_API_ENDPOINT,
+  AI_SEC_API_KEY,
+  AI_SEC_API_TOKEN,
+  ASYNC_SCAN_PATH,
+  AgentMetaSchema,
+  AiProfileSchema,
+  AsyncScanObjectSchema,
+  AsyncScanResponseSchema,
+  BEARER,
+  Content,
+  DEFAULT_ENDPOINT,
+  DSDetailResultSchema,
+  DSResultMetadataSchema,
+  DetectionServiceResultSchema,
+  DlpReportSchema,
+  ErrorResponseSchema,
+  ErrorType,
+  HEADER_API_KEY,
+  HEADER_AUTH_TOKEN,
+  HTTP_FORCE_RETRY_STATUS_CODES,
+  IODetectedSchema,
+  MAX_AI_PROFILE_NAME_LENGTH,
+  MAX_API_KEY_LENGTH,
+  MAX_CONNECTION_POOL_SIZE,
+  MAX_CONTENT_CONTEXT_LENGTH,
+  MAX_CONTENT_PROMPT_LENGTH,
+  MAX_CONTENT_RESPONSE_LENGTH,
+  MAX_NUMBER_OF_BATCH_SCAN_OBJECTS,
+  MAX_NUMBER_OF_REPORT_IDS,
+  MAX_NUMBER_OF_RETRIES,
+  MAX_NUMBER_OF_SCAN_IDS,
+  MAX_REPORT_ID_STR_LENGTH,
+  MAX_SCAN_ID_STR_LENGTH,
+  MAX_SESSION_ID_STR_LENGTH,
+  MAX_TOKEN_LENGTH,
+  MAX_TRANSACTION_ID_STR_LENGTH,
+  MaskedDataSchema,
+  MetadataSchema,
+  PAYLOAD_HASH,
+  PromptDetectedSchema,
+  PromptDetectionDetailsSchema,
+  ResponseDetectedSchema,
+  ResponseDetectionDetailsSchema,
+  SCAN_REPORTS_PATH,
+  SCAN_RESULTS_PATH,
+  SDK_VERSION,
+  SYNC_SCAN_PATH,
+  ScanIdResultSchema,
+  ScanRequestContentsInnerSchema,
+  ScanRequestSchema,
+  ScanResponseSchema,
+  ScanSummarySchema,
+  Scanner,
+  ThreatScanReportSchema,
+  ToolDetectedSchema,
+  ToolEventMetadataSchema,
+  ToolEventSchema,
+  USER_AGENT,
+  UrlfEntrySchema,
+  globalConfiguration,
+  init
+};
+//# sourceMappingURL=index.js.map