@cdot65/prisma-airs-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,812 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AISecSDKException: () => AISecSDKException,
+  AI_SEC_API_ENDPOINT: () => AI_SEC_API_ENDPOINT,
+  AI_SEC_API_KEY: () => AI_SEC_API_KEY,
+  AI_SEC_API_TOKEN: () => AI_SEC_API_TOKEN,
+  ASYNC_SCAN_PATH: () => ASYNC_SCAN_PATH,
+  AgentMetaSchema: () => AgentMetaSchema,
+  AiProfileSchema: () => AiProfileSchema,
+  AsyncScanObjectSchema: () => AsyncScanObjectSchema,
+  AsyncScanResponseSchema: () => AsyncScanResponseSchema,
+  BEARER: () => BEARER,
+  Content: () => Content,
+  DEFAULT_ENDPOINT: () => DEFAULT_ENDPOINT,
+  DSDetailResultSchema: () => DSDetailResultSchema,
+  DSResultMetadataSchema: () => DSResultMetadataSchema,
+  DetectionServiceResultSchema: () => DetectionServiceResultSchema,
+  DlpReportSchema: () => DlpReportSchema,
+  ErrorResponseSchema: () => ErrorResponseSchema,
+  ErrorType: () => ErrorType,
+  HEADER_API_KEY: () => HEADER_API_KEY,
+  HEADER_AUTH_TOKEN: () => HEADER_AUTH_TOKEN,
+  HTTP_FORCE_RETRY_STATUS_CODES: () => HTTP_FORCE_RETRY_STATUS_CODES,
+  IODetectedSchema: () => IODetectedSchema,
+  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,
+  MAX_CONTENT_CONTEXT_LENGTH: () => MAX_CONTENT_CONTEXT_LENGTH,
+  MAX_CONTENT_PROMPT_LENGTH: () => MAX_CONTENT_PROMPT_LENGTH,
+  MAX_CONTENT_RESPONSE_LENGTH: () => MAX_CONTENT_RESPONSE_LENGTH,
+  MAX_NUMBER_OF_BATCH_SCAN_OBJECTS: () => MAX_NUMBER_OF_BATCH_SCAN_OBJECTS,
+  MAX_NUMBER_OF_REPORT_IDS: () => MAX_NUMBER_OF_REPORT_IDS,
+  MAX_NUMBER_OF_RETRIES: () => MAX_NUMBER_OF_RETRIES,
+  MAX_NUMBER_OF_SCAN_IDS: () => MAX_NUMBER_OF_SCAN_IDS,
+  MAX_REPORT_ID_STR_LENGTH: () => MAX_REPORT_ID_STR_LENGTH,
+  MAX_SCAN_ID_STR_LENGTH: () => MAX_SCAN_ID_STR_LENGTH,
+  MAX_SESSION_ID_STR_LENGTH: () => MAX_SESSION_ID_STR_LENGTH,
+  MAX_TOKEN_LENGTH: () => MAX_TOKEN_LENGTH,
+  MAX_TRANSACTION_ID_STR_LENGTH: () => MAX_TRANSACTION_ID_STR_LENGTH,
+  MaskedDataSchema: () => MaskedDataSchema,
+  MetadataSchema: () => MetadataSchema,
+  PAYLOAD_HASH: () => PAYLOAD_HASH,
+  PromptDetectedSchema: () => PromptDetectedSchema,
+  PromptDetectionDetailsSchema: () => PromptDetectionDetailsSchema,
+  ResponseDetectedSchema: () => ResponseDetectedSchema,
+  ResponseDetectionDetailsSchema: () => ResponseDetectionDetailsSchema,
+  SCAN_REPORTS_PATH: () => SCAN_REPORTS_PATH,
+  SCAN_RESULTS_PATH: () => SCAN_RESULTS_PATH,
+  SDK_VERSION: () => SDK_VERSION,
+  SYNC_SCAN_PATH: () => SYNC_SCAN_PATH,
+  ScanIdResultSchema: () => ScanIdResultSchema,
+  ScanRequestContentsInnerSchema: () => ScanRequestContentsInnerSchema,
+  ScanRequestSchema: () => ScanRequestSchema,
+  ScanResponseSchema: () => ScanResponseSchema,
+  ScanSummarySchema: () => ScanSummarySchema,
+  Scanner: () => Scanner,
+  ThreatScanReportSchema: () => ThreatScanReportSchema,
+  ToolDetectedSchema: () => ToolDetectedSchema,
+  ToolEventMetadataSchema: () => ToolEventMetadataSchema,
+  ToolEventSchema: () => ToolEventSchema,
+  USER_AGENT: () => USER_AGENT,
+  UrlfEntrySchema: () => UrlfEntrySchema,
+  globalConfiguration: () => globalConfiguration,
+  init: () => init
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_node_crypto = require("crypto");
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidUuid(value) {
+  return UUID_RE.test(value);
+}
+function generatePayloadHash(payload, secret) {
+  return (0, import_node_crypto.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
+var import_node_fs = require("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 = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return _Content.fromJSON(parsed);
+  }
+};
+
+// src/models/ai-profile.ts
+var import_zod = require("zod");
+var AiProfileSchema = import_zod.z.object({
+  profile_id: import_zod.z.string().uuid().optional(),
+  profile_name: import_zod.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
+var import_zod2 = require("zod");
+var AgentMetaSchema = import_zod2.z.object({
+  agent_id: import_zod2.z.string().optional(),
+  agent_version: import_zod2.z.string().optional(),
+  agent_arn: import_zod2.z.string().optional()
+});
+var MetadataSchema = import_zod2.z.object({
+  app_name: import_zod2.z.string().optional(),
+  app_user: import_zod2.z.string().optional(),
+  ai_model: import_zod2.z.string().optional(),
+  user_ip: import_zod2.z.string().optional(),
+  agent_meta: AgentMetaSchema.optional()
+});
+
+// src/models/tool-event.ts
+var import_zod3 = require("zod");
+var ToolEventMetadataSchema = import_zod3.z.object({
+  ecosystem: import_zod3.z.string(),
+  method: import_zod3.z.string(),
+  server_name: import_zod3.z.string(),
+  tool_invoked: import_zod3.z.string().optional()
+});
+var ToolEventSchema = import_zod3.z.object({
+  metadata: ToolEventMetadataSchema.optional(),
+  input: import_zod3.z.string().optional(),
+  output: import_zod3.z.string().optional()
+});
+
+// src/models/scan-request.ts
+var import_zod4 = require("zod");
+var ScanRequestContentsInnerSchema = import_zod4.z.object({
+  prompt: import_zod4.z.string().optional(),
+  response: import_zod4.z.string().optional(),
+  code_prompt: import_zod4.z.string().optional(),
+  code_response: import_zod4.z.string().optional(),
+  context: import_zod4.z.string().optional(),
+  tool_event: ToolEventSchema.optional()
+});
+var ScanRequestSchema = import_zod4.z.object({
+  tr_id: import_zod4.z.string().max(MAX_TRANSACTION_ID_STR_LENGTH).optional(),
+  session_id: import_zod4.z.string().max(MAX_SESSION_ID_STR_LENGTH).optional(),
+  ai_profile: AiProfileSchema,
+  metadata: MetadataSchema.optional(),
+  contents: import_zod4.z.array(ScanRequestContentsInnerSchema).min(1)
+});
+
+// src/models/scan-response.ts
+var import_zod7 = require("zod");
+
+// src/models/prompt-detected.ts
+var import_zod5 = require("zod");
+var PromptDetectionDetailsSchema = import_zod5.z.object({
+  topic_guardrails_details: import_zod5.z.record(import_zod5.z.unknown()).optional()
+});
+var PromptDetectedSchema = import_zod5.z.object({
+  url_cats: import_zod5.z.boolean().optional(),
+  dlp: import_zod5.z.boolean().optional(),
+  injection: import_zod5.z.boolean().optional(),
+  toxic_content: import_zod5.z.boolean().optional(),
+  malicious_code: import_zod5.z.boolean().optional(),
+  agent: import_zod5.z.boolean().optional(),
+  topic_violation: import_zod5.z.boolean().optional()
+});
+
+// src/models/response-detected.ts
+var import_zod6 = require("zod");
+var ResponseDetectionDetailsSchema = import_zod6.z.object({
+  topic_guardrails_details: import_zod6.z.record(import_zod6.z.unknown()).optional()
+});
+var ResponseDetectedSchema = import_zod6.z.object({
+  url_cats: import_zod6.z.boolean().optional(),
+  dlp: import_zod6.z.boolean().optional(),
+  db_security: import_zod6.z.boolean().optional(),
+  toxic_content: import_zod6.z.boolean().optional(),
+  malicious_code: import_zod6.z.boolean().optional(),
+  agent: import_zod6.z.boolean().optional(),
+  ungrounded: import_zod6.z.boolean().optional(),
+  topic_violation: import_zod6.z.boolean().optional()
+});
+
+// src/models/scan-response.ts
+var MaskedDataSchema = import_zod7.z.object({
+  data: import_zod7.z.string().optional(),
+  pattern_detections: import_zod7.z.array(import_zod7.z.record(import_zod7.z.unknown())).optional()
+});
+var IODetectedSchema = import_zod7.z.object({
+  url_cats: import_zod7.z.boolean().optional(),
+  dlp: import_zod7.z.boolean().optional(),
+  injection: import_zod7.z.boolean().optional(),
+  toxic_content: import_zod7.z.boolean().optional(),
+  malicious_code: import_zod7.z.boolean().optional()
+}).passthrough();
+var ScanSummarySchema = import_zod7.z.object({
+  verdict: import_zod7.z.string().optional(),
+  action: import_zod7.z.string().optional()
+}).passthrough();
+var ToolDetectedSchema = import_zod7.z.object({
+  verdict: import_zod7.z.string().optional(),
+  metadata: ToolEventMetadataSchema.optional(),
+  summary: ScanSummarySchema.optional(),
+  input_detected: IODetectedSchema.optional(),
+  output_detected: IODetectedSchema.optional()
+});
+var ScanResponseSchema = import_zod7.z.object({
+  source: import_zod7.z.string().optional(),
+  report_id: import_zod7.z.string(),
+  scan_id: import_zod7.z.string(),
+  tr_id: import_zod7.z.string().optional(),
+  session_id: import_zod7.z.string().optional(),
+  profile_id: import_zod7.z.string().optional(),
+  profile_name: import_zod7.z.string().optional(),
+  category: import_zod7.z.string(),
+  action: import_zod7.z.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: import_zod7.z.string().optional(),
+  completed_at: import_zod7.z.string().optional()
+});
+
+// src/models/async-scan.ts
+var import_zod8 = require("zod");
+var AsyncScanObjectSchema = import_zod8.z.object({
+  req_id: import_zod8.z.number().int(),
+  scan_req: ScanRequestSchema
+});
+var AsyncScanResponseSchema = import_zod8.z.object({
+  received: import_zod8.z.string(),
+  scan_id: import_zod8.z.string(),
+  report_id: import_zod8.z.string().optional(),
+  source: import_zod8.z.string().optional()
+});
+
+// src/models/scan-id-result.ts
+var import_zod9 = require("zod");
+var ScanIdResultSchema = import_zod9.z.object({
+  source: import_zod9.z.string().optional(),
+  req_id: import_zod9.z.number().optional(),
+  status: import_zod9.z.string().optional(),
+  scan_id: import_zod9.z.string().optional(),
+  result: ScanResponseSchema.optional()
+});
+
+// src/models/threat-report.ts
+var import_zod13 = require("zod");
+
+// src/models/detection.ts
+var import_zod12 = require("zod");
+
+// src/models/dlp-report.ts
+var import_zod10 = require("zod");
+var DlpReportSchema = import_zod10.z.object({
+  dlp_report_id: import_zod10.z.string().optional(),
+  dlp_profile_name: import_zod10.z.string().optional(),
+  dlp_profile_id: import_zod10.z.string().optional(),
+  dlp_profile_version: import_zod10.z.number().optional(),
+  data_pattern_rule1_verdict: import_zod10.z.string().optional(),
+  data_pattern_rule2_verdict: import_zod10.z.string().optional()
+});
+
+// src/models/urlf-report.ts
+var import_zod11 = require("zod");
+var UrlfEntrySchema = import_zod11.z.object({
+  url: import_zod11.z.string().optional(),
+  risk_level: import_zod11.z.string().optional(),
+  categories: import_zod11.z.array(import_zod11.z.string()).optional()
+});
+
+// src/models/detection.ts
+var DSDetailResultSchema = import_zod12.z.object({
+  urlf_report: import_zod12.z.array(UrlfEntrySchema).optional(),
+  dlp_report: DlpReportSchema.optional()
+});
+var DSResultMetadataSchema = import_zod12.z.object({
+  score: import_zod12.z.number().optional(),
+  confidence: import_zod12.z.string().optional()
+}).passthrough();
+var DetectionServiceResultSchema = import_zod12.z.object({
+  data_type: import_zod12.z.string().optional(),
+  detection_service: import_zod12.z.string().optional(),
+  verdict: import_zod12.z.string().optional(),
+  action: import_zod12.z.string().optional(),
+  metadata: DSResultMetadataSchema.optional(),
+  result_detail: DSDetailResultSchema.optional()
+});
+
+// src/models/threat-report.ts
+var ThreatScanReportSchema = import_zod13.z.object({
+  source: import_zod13.z.string().optional(),
+  report_id: import_zod13.z.string().optional(),
+  scan_id: import_zod13.z.string().optional(),
+  req_id: import_zod13.z.number().optional(),
+  transaction_id: import_zod13.z.string().optional(),
+  session_id: import_zod13.z.string().optional(),
+  detection_results: import_zod13.z.array(DetectionServiceResultSchema).optional()
+});
+
+// src/models/error-response.ts
+var import_zod14 = require("zod");
+var ErrorResponseSchema = import_zod14.z.object({
+  status_code: import_zod14.z.number().optional(),
+  message: import_zod14.z.string().optional(),
+  error: import_zod14.z.object({
+    message: import_zod14.z.string().optional()
+  }).passthrough().optional(),
+  retry_after: import_zod14.z.object({
+    interval: import_zod14.z.number().optional(),
+    unit: import_zod14.z.string().optional()
+  }).optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs.map