@castleio/sdk 2.3.3 → 3.0.0

package/dist/index.mjs

@@ -0,0 +1,1499 @@
+// src/core/services/core-generate-default-headers.service.ts
+var CoreGenerateDefaultHeadersService = {
+  call: (configuration) => {
+    return {
+      Authorization: `Basic ${Buffer.from(
+        `:${configuration.apiSecret}`
+      ).toString("base64")}`,
+      "Content-Type": "application/json"
+    };
+  }
+};
+
+// src/core/services/core-generate-request-body.service.ts
+var CoreGenerateRequestBody = {
+  call: (payload) => {
+    return JSON.stringify({
+      sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...payload
+    });
+  }
+};
+
+// src/errors.ts
+var ConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var APIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "APIError";
+  }
+};
+var BadRequestError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+var UserUnauthorizedError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "UserUnauthorizedError";
+  }
+};
+var InvalidParametersError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidParametersError";
+  }
+};
+var InvalidRequestTokenError = class extends InvalidParametersError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidRequestTokenError";
+  }
+};
+var RateLimitError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "RateLimitError";
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(message) {
+    super(message);
+    this.name = "InternalServerError";
+  }
+};
+var WebhookVerificationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+
+// src/logger/services/logger-error-formatter.service.ts
+var LoggerErrorFormatterService = {
+  call: (err) => err ? `
+Error name: ${err.name}
+Error message: ${err.message}
+`.trim() : ""
+};
+
+// src/logger/services/logger-request-formatter.service.ts
+var LoggerRequestFormatterService = {
+  call: ({
+    requestUrl,
+    requestOptions,
+    response,
+    err,
+    body
+  }) => `
+-- Castle request
+URL: ${requestUrl}
+Request: ${JSON.stringify(requestOptions)}
+-- Castle response
+${response ? LoggerResponseFormatterService.call(response, body) : LoggerErrorFormatterService.call(err)}
+`
+};
+
+// src/logger/services/logger-response-formatter.service.ts
+var LoggerResponseFormatterService = {
+  call: (response, body) => `
+Response status: ${response.status}
+Response body: ${JSON.stringify(body)}
+`.trim()
+};
+
+// src/logger/services/logger.service.ts
+var LoggerService = {
+  call: async ({ requestUrl, requestOptions, response, body, err }, logger) => {
+    return logger.info(
+      LoggerRequestFormatterService.call({
+        requestUrl,
+        requestOptions,
+        response,
+        err,
+        body
+      })
+    );
+  }
+};
+
+// src/core/services/core-process-response.service.ts
+var RESPONSE_ERRORS = {
+  "400": BadRequestError,
+  "401": UnauthorizedError,
+  "403": ForbiddenError,
+  "404": NotFoundError,
+  "419": UserUnauthorizedError,
+  "422": InvalidParametersError,
+  "429": RateLimitError
+};
+var RESPONSE_SUB_ERRORS = {
+  invalid_request_token: InvalidRequestTokenError
+};
+var getBody = async (response) => {
+  if (response.cachedBody) {
+    return response.cachedBody;
+  }
+  try {
+    const preparsedResponse = await response.text();
+    if (preparsedResponse) {
+      response.cachedBody = await JSON.parse(preparsedResponse);
+    } else {
+      response.cachedBody = {};
+    }
+  } catch (e) {
+    throw new APIError("Castle: Malformed JSON response");
+  }
+  return response.cachedBody;
+};
+var CoreProcessResponseService = {
+  call: async (requestUrl, requestOptions, response, logger) => {
+    const body = await getBody(response);
+    LoggerService.call({ requestUrl, requestOptions, response, body }, logger);
+    if (response.status >= 200 && response.status <= 299) {
+      return body;
+    }
+    if (response.status >= 500 && response.status <= 599) {
+      throw new InternalServerError(
+        `Castle: Responded with ${response.status} code`
+      );
+    }
+    const err = RESPONSE_SUB_ERRORS[body.type] || RESPONSE_ERRORS[response.status.toString()] || APIError;
+    throw new err(`Castle: Responded with ${response.status} code`);
+  }
+};
+
+// src/api/services/api.service.ts
+var APIService = {
+  call: async (controller, { requestUrl, requestOptions }, configuration) => {
+    const fetcher = configuration.overrideFetch || fetch;
+    let response;
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, configuration.timeout);
+    try {
+      response = await fetcher(requestUrl, requestOptions);
+    } catch (err) {
+      LoggerService.call(
+        { requestUrl, requestOptions, err },
+        configuration.logger
+      );
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+    const processedResponse = await CoreProcessResponseService.call(
+      requestUrl,
+      requestOptions,
+      response,
+      configuration.logger
+    );
+    return processedResponse;
+  }
+};
+
+// src/command/services/command-generate.service.ts
+var combineURLs = (baseURL, relativeURL) => {
+  return baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "");
+};
+var CommandGenerateService = {
+  call: (controller, path, options, method, configuration) => {
+    return {
+      requestUrl: new URL(combineURLs(configuration.baseUrl.toString(), path)),
+      requestOptions: {
+        signal: controller.signal,
+        method,
+        headers: CoreGenerateDefaultHeadersService.call(configuration),
+        ...method !== "GET" && {
+          body: CoreGenerateRequestBody.call(options)
+        }
+      }
+    };
+  }
+};
+
+// src/utils/object.ts
+var isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+var deepMerge = (target, ...sources) => {
+  for (const source of sources) {
+    if (source === null || source === void 0) {
+      continue;
+    }
+    for (const key of Object.keys(source)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue === void 0) {
+        continue;
+      }
+      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        deepMerge(targetValue, sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+        deepMerge(targetValue, sourceValue);
+      } else if (isPlainObject(sourceValue)) {
+        target[key] = deepMerge({}, sourceValue);
+      } else if (Array.isArray(sourceValue)) {
+        target[key] = deepMerge([], sourceValue);
+      } else {
+        target[key] = sourceValue;
+      }
+    }
+  }
+  return target;
+};
+var isEmpty = (value) => {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (Array.isArray(value) || typeof value === "string") {
+    return value.length === 0;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return true;
+};
+var pickByTruthy = (object) => Object.entries(object).reduce((accumulator, [key, value]) => {
+  if (value) {
+    accumulator[key] = value;
+  }
+  return accumulator;
+}, {});
+
+// src/headers/services/headers-extract.service.ts
+var ALWAYS_ALLOWLISTED = ["user-agent"];
+var ALWAYS_DENYLISTED = ["cookie", "authorization"];
+var HeadersExtractService = {
+  call: (headers, configuration) => {
+    return Object.entries(headers).reduce(
+      (accumulator, [key, value]) => {
+        if (ALWAYS_DENYLISTED.includes(key.toLowerCase())) {
+          return {
+            ...accumulator,
+            [key]: true
+          };
+        }
+        if (ALWAYS_ALLOWLISTED.includes(key.toLowerCase())) {
+          return {
+            ...accumulator,
+            [key]: value
+          };
+        }
+        if (configuration.denylisted.includes(key.toLowerCase())) {
+          return {
+            ...accumulator,
+            [key]: true
+          };
+        }
+        if (configuration.allowlisted.length === 0 || configuration.allowlisted.includes(key.toLowerCase())) {
+          return {
+            ...accumulator,
+            [key]: value
+          };
+        }
+        return {
+          ...accumulator,
+          [key]: true
+        };
+      },
+      {}
+    );
+  }
+};
+
+// src/headers/services/headers-get-cookie.service.ts
+var HeadersGetCookieService = {
+  call: (cookies, name) => {
+    if (!cookies) {
+      return;
+    }
+    const pattern = new RegExp(`(?:^|\\s+)\\s?${name}=(.*?)(?:;|$)`);
+    const results = cookies.toString().match(pattern);
+    if (results && results.length === 2) {
+      return results[1];
+    }
+    return;
+  }
+};
+
+// src/client-id/services/client-id-extract.service.ts
+var ClientIdExtractService = {
+  call: (headers = {}, cookies) => {
+    return headers["x-castle-client-id"] || HeadersGetCookieService.call(cookies, "__cid") || "";
+  }
+};
+
+// src/constants.ts
+var DEFAULT_API_URL = "https://api.castle.io/v1";
+var DEFAULT_TIMEOUT = 1500;
+var DEFAULT_ALLOWLIST = [
+  "accept",
+  "accept-charset",
+  "accept-datetime",
+  "accept-encoding",
+  "accept-language",
+  "cache-control",
+  "connection",
+  "content-length",
+  "content-type",
+  "dnt",
+  "host",
+  "origin",
+  "pragma",
+  "referer",
+  "sec-fetch-dest",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-user",
+  "te",
+  "upgrade-insecure-requests",
+  "user-agent",
+  "x-requested-with"
+];
+var TRUSTED_PROXIES = [
+  new RegExp(
+    [
+      /^127\.0\.0\.1$|/,
+      /^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|/,
+      /^::1\Z|\Afd[0-9a-f]{2}:.+|/,
+      /^localhost$|/,
+      /^unix$|/,
+      /^unix:/
+    ].map((r) => r.source).join("")
+  )
+];
+
+// src/ips/services/ips-extract.service.ts
+var DEFAULT = ["x-forwarded-for", "remote-addr"];
+var DEPTH_RELATED = ["x-forwarded-for"];
+var checkInternal = (ipAddress, proxies) => {
+  return proxies.some((proxyRegexp) => proxyRegexp.test(ipAddress));
+};
+var limitProxyDepth = (ips, ipHeader, trustedProxyDepth) => {
+  if (DEPTH_RELATED.includes(ipHeader)) {
+    ips.splice(ips.length - 1, trustedProxyDepth);
+  }
+  return ips;
+};
+var IPsFrom = (ipHeader, headers, trustedProxyDepth) => {
+  if (!headers) {
+    return [];
+  }
+  const headerValue = headers[ipHeader];
+  if (!headerValue) {
+    return [];
+  }
+  const ips = headerValue.trim().split(/[,\s]+/);
+  return limitProxyDepth(ips, ipHeader, trustedProxyDepth);
+};
+var removeProxies = (ips, trustProxyChain, proxiesList) => {
+  if (trustProxyChain) {
+    return ips[0];
+  }
+  const filteredIps = ips.filter((ip) => !checkInternal(ip, proxiesList));
+  return filteredIps[filteredIps.length - 1];
+};
+var IPsExtractService = {
+  call: (headers, {
+    ipHeaders = [],
+    trustedProxies = [],
+    trustProxyChain = false,
+    trustedProxyDepth = 0
+  }) => {
+    const ipHeadersList = ipHeaders.length ? ipHeaders : DEFAULT;
+    const proxiesList = trustedProxies.concat(TRUSTED_PROXIES);
+    let allIPs = [];
+    for (const ipHeader of ipHeadersList) {
+      const IPs = IPsFrom(ipHeader, headers, trustedProxyDepth);
+      const IPValue = removeProxies(IPs, trustProxyChain, proxiesList);
+      if (IPValue) {
+        return IPValue;
+      }
+      allIPs = [...allIPs, ...IPs];
+    }
+    return allIPs[0];
+  }
+};
+
+// package.json
+var version = "3.0.0";
+
+// src/context/services/context-get-default.service.ts
+var requestContextData = (request, cookies, configuration) => {
+  if (isEmpty(request)) {
+    return {};
+  }
+  const cookiesForClientId = cookies || request.headers?.cookies;
+  return {
+    client_id: ClientIdExtractService.call(request.headers, cookiesForClientId) || false,
+    active: true,
+    headers: HeadersExtractService.call(request.headers, configuration),
+    ip: IPsExtractService.call(request.headers, configuration)
+  };
+};
+var ContextGetDefaultService = {
+  call: (request, cookies, configuration) => {
+    return {
+      ...pickByTruthy(requestContextData(request, cookies, configuration)),
+      library: {
+        name: "castle-node",
+        version
+      }
+    };
+  }
+};
+
+// src/context/services/context-prepare.service.ts
+var ContextPrepareService = {
+  call: (request, options, configuration) => {
+    const defaultContext = ContextGetDefaultService.call(
+      request,
+      options?.cookies,
+      configuration
+    );
+    return deepMerge(defaultContext, options?.context);
+  }
+};
+
+// src/context/services/context-sanitize.service.ts
+var ContextSanitizeService = {
+  call: (context) => {
+    if (!context) {
+      return {};
+    }
+    if (!("active" in context)) {
+      return context;
+    }
+    if (typeof context.active === "boolean") {
+      return context;
+    }
+    delete context.active;
+    return context;
+  }
+};
+
+// src/command/services/command-filter.service.ts
+var CommandFilterService = {
+  call: (controller, options, configuration) => {
+    const context = ContextSanitizeService.call(options.context);
+    return CommandGenerateService.call(
+      controller,
+      "filter",
+      { ...options, ...{ context } },
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-log.service.ts
+var CommandLogService = {
+  call: (controller, options, configuration) => {
+    const context = ContextSanitizeService.call(options.context);
+    return CommandGenerateService.call(
+      controller,
+      "log",
+      { ...options, ...{ context } },
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-risk.service.ts
+var CommandRiskService = {
+  call: (controller, options, configuration) => {
+    const context = ContextSanitizeService.call(options.context);
+    return CommandGenerateService.call(
+      controller,
+      "risk",
+      { ...options, ...{ context } },
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/validator/services/validator-present.service.ts
+var ValidatorPresentService = {
+  call: (options, keys) => {
+    for (const key of keys) {
+      if (options[key]) {
+        continue;
+      }
+      throw new InvalidParametersError(`Castle: ${key} is missing or empty`);
+    }
+  }
+};
+
+// src/command/services/command-create-list-item.service.ts
+var CommandCreateListItemService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-search-list-items.service.ts
+var CommandSearchListItemsService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/query`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-update-list-item.service.ts
+var CommandUpdateListItemService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id", "list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/${options.id}`,
+      options,
+      "PUT",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-archive-list-item.service.ts
+var CommandArchiveListItemService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id", "list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/${options.id}/archive`,
+      {},
+      "DELETE",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-unarchive-list-item.service.ts
+var CommandUnarchiveListItemService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id", "list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/${options.id}/unarchive`,
+      {},
+      "PUT",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-fetch-list-item.service.ts
+var CommandFetchListItemService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id", "list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/${options.id}`,
+      {},
+      "GET",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-fetch-list.service.ts
+var CommandFetchListService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.id}`,
+      {},
+      "GET",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-delete-list.service.ts
+var CommandDeleteListService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.id}`,
+      {},
+      "DELETE",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-fetch-all-lists.service.ts
+var CommandFetchAllListsService = {
+  call: (controller, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      `lists`,
+      {},
+      "GET",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-search-lists.service.ts
+var CommandSearchListsService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      `lists/query`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-update-list.service.ts
+var CommandUpdateListService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.id}`,
+      options,
+      "PUT",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-create-list.service.ts
+var CommandCreateListService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      `lists`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-get-events-schema.service.ts
+var CommandGetEventsSchemaService = {
+  call: (controller, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      "events/schema",
+      {},
+      "GET",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-group-events.service.ts
+var CommandGroupEventsService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      "events/group",
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-search-events.service.ts
+var CommandSearchEventsService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      "events/query",
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-count-list-items.service.ts
+var CommandCountListItemsService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/count`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-batch-upsert-list-items.service.ts
+var CommandBatchUpsertListItemsService = {
+  call: (controller, options, configuration) => {
+    ValidatorPresentService.call(options, ["list_id"]);
+    return CommandGenerateService.call(
+      controller,
+      `lists/${options.list_id}/items/batch`,
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-request-user-data.service.ts
+var CommandRequestUserDataService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      "privacy/users",
+      options,
+      "POST",
+      configuration
+    );
+  }
+};
+
+// src/command/services/command-delete-user-data.service.ts
+var CommandDeleteUserDataService = {
+  call: (controller, options, configuration) => {
+    return CommandGenerateService.call(
+      controller,
+      "privacy/users",
+      options,
+      "DELETE",
+      configuration
+    );
+  }
+};
+
+// src/failover/models/failover-strategy.ts
+var FailoverStrategy = /* @__PURE__ */ ((FailoverStrategy2) => {
+  FailoverStrategy2["allow"] = "allow";
+  FailoverStrategy2["deny"] = "deny";
+  FailoverStrategy2["challenge"] = "challenge";
+  FailoverStrategy2["throw"] = "throw";
+  return FailoverStrategy2;
+})(FailoverStrategy || {});
+
+// src/api/services/api-risk.service.ts
+var handleFailover = (reason, configuration, err) => {
+  if (configuration.failoverStrategy === "throw" /* throw */) {
+    throw err;
+  }
+  return {
+    policy: {
+      action: configuration.failoverStrategy
+    },
+    action: configuration.failoverStrategy,
+    failover: true,
+    failover_reason: reason
+  };
+};
+var isTimeoutError = (e) => e.name === "AbortError";
+var APIRiskService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandRiskService.call(controller, options, configuration);
+    let processedResponse;
+    try {
+      processedResponse = await APIService.call(
+        controller,
+        command,
+        configuration
+      );
+    } catch (e) {
+      if (isTimeoutError(e)) {
+        return handleFailover("timeout", configuration, e);
+      } else if (e instanceof InternalServerError) {
+        return handleFailover("server error", configuration);
+      } else {
+        throw e;
+      }
+    }
+    return processedResponse;
+  }
+};
+
+// src/api/services/api-log.service.ts
+var APILogService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandLogService.call(controller, options, configuration);
+    APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-filter.service.ts
+var handleFailover2 = (reason, configuration, err) => {
+  if (configuration.failoverStrategy === "throw" /* throw */) {
+    throw err;
+  }
+  return {
+    policy: {
+      action: configuration.failoverStrategy
+    },
+    action: configuration.failoverStrategy,
+    failover: true,
+    failover_reason: reason
+  };
+};
+var isTimeoutError2 = (e) => e.name === "AbortError";
+var APIFilterService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandFilterService.call(
+      controller,
+      options,
+      configuration
+    );
+    let processedResponse;
+    try {
+      processedResponse = await APIService.call(
+        controller,
+        command,
+        configuration
+      );
+    } catch (e) {
+      if (isTimeoutError2(e)) {
+        return handleFailover2("timeout", configuration, e);
+      } else if (e instanceof InternalServerError) {
+        return handleFailover2("server error", configuration, e);
+      } else {
+        throw e;
+      }
+    }
+    return processedResponse;
+  }
+};
+
+// src/api/services/api-create-list-item.service.ts
+var APICreateListItemService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandCreateListItemService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-create-list.service.ts
+var APICreateListService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandCreateListService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-archive-list-item.service.ts
+var APIArchiveListItemService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandArchiveListItemService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-delete-list.service.ts
+var APIDeleteListService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandDeleteListService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-unarchive-list-item.service.ts
+var APIUnarchiveListItemService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandUnarchiveListItemService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-fetch-list-item.service.ts
+var APIFetchListItemService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandFetchListItemService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-fetch-list.service.ts
+var APIFetchListService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandFetchListService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-search-list-items.service.ts
+var APISearchListItemsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandSearchListItemsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-search-lists.service.ts
+var APISearchListsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandSearchListsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-update-list-item.service.ts
+var APIUpdateListItemService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandUpdateListItemService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-update-list.service.ts
+var APIUpdateListService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandUpdateListService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-fetch-all-lists.service.ts
+var APIFetchAllListsService = {
+  call: async (configuration) => {
+    const controller = new AbortController();
+    const command = CommandFetchAllListsService.call(controller, configuration);
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-get-events-schema.service.ts
+var APIGetEventsSchemaService = {
+  call: async (configuration) => {
+    const controller = new AbortController();
+    const command = CommandGetEventsSchemaService.call(
+      controller,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-group-events.service.ts
+var APIGroupEventsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandGroupEventsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-search-events.service.ts
+var APISearchEventsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandSearchEventsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-count-list-items.service.ts
+var APICountListItemsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandCountListItemsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-batch-upsert-list-items.service.ts
+var APIBatchUpsertListItemsService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandBatchUpsertListItemsService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-request-user-data.service.ts
+var APIRequestUserDataService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandRequestUserDataService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/api/services/api-delete-user-data.service.ts
+var APIDeleteUserDataService = {
+  call: async (options, configuration) => {
+    const controller = new AbortController();
+    const command = CommandDeleteUserDataService.call(
+      controller,
+      options,
+      configuration
+    );
+    return APIService.call(controller, command, configuration);
+  }
+};
+
+// src/webhook/services/webhook-verify.service.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var secureCompare = (a, b) => {
+  const bufferA = Buffer.from(a);
+  const bufferB = Buffer.from(b);
+  if (bufferA.length !== bufferB.length) {
+    return false;
+  }
+  return timingSafeEqual(bufferA, bufferB);
+};
+var WebhookVerifyService = {
+  // Verifies the `X-Castle-Signature` of an incoming webhook against the raw
+  // request body. Throws `WebhookVerificationError` when it does not match.
+  call: (payload, signature, configuration) => {
+    if (!payload || payload.length === 0) {
+      throw new WebhookVerificationError("Invalid webhook from Castle API");
+    }
+    const expectedSignature = createHmac("sha256", configuration.apiSecret).update(payload).digest("base64");
+    if (!signature || !secureCompare(signature, expectedSignature)) {
+      throw new WebhookVerificationError(
+        "Signature not matching the expected signature"
+      );
+    }
+  }
+};
+
+// src/secure-mode/services/secure-mode.service.ts
+import { createHmac as createHmac2 } from "crypto";
+var SecureModeService = {
+  // Computes the secure-mode signature for a user id: a hex HMAC-SHA256 of the
+  // user id keyed with the API secret. Use it to authenticate the user id sent
+  // to Castle from the browser.
+  call: (userId, configuration) => createHmac2("sha256", configuration.apiSecret).update(userId).digest("hex")
+};
+
+// src/configuration.ts
+import pino from "pino";
+import pretty from "pino-pretty";
+var Configuration = class {
+  apiSecret;
+  baseUrl;
+  timeout;
+  allowlisted;
+  denylisted;
+  overrideFetch;
+  failoverStrategy;
+  doNotTrack;
+  ipHeaders;
+  trustedProxies;
+  trustProxyChain;
+  trustedProxyDepth;
+  logger;
+  constructor({
+    apiSecret,
+    baseUrl = DEFAULT_API_URL,
+    timeout = DEFAULT_TIMEOUT,
+    allowlisted = [],
+    denylisted = [],
+    overrideFetch = fetch,
+    failoverStrategy = "allow" /* allow */,
+    doNotTrack = false,
+    ipHeaders = [],
+    trustedProxies = [],
+    trustProxyChain = false,
+    trustedProxyDepth = 0,
+    logger = pino(pretty({ levelFirst: true }))
+  }) {
+    if (!apiSecret) {
+      throw new ConfigurationError(
+        "Castle: Unable to instantiate Castle client, API secret is missing."
+      );
+    }
+    this.apiSecret = apiSecret;
+    this.baseUrl = new URL(baseUrl);
+    this.timeout = timeout;
+    this.allowlisted = allowlisted.map((x) => x.toLowerCase());
+    this.denylisted = denylisted.map((x) => x.toLowerCase());
+    this.overrideFetch = overrideFetch;
+    this.failoverStrategy = failoverStrategy;
+    this.doNotTrack = doNotTrack;
+    this.ipHeaders = ipHeaders;
+    this.trustedProxies = trustedProxies.map((proxy) => new RegExp(proxy));
+    this.trustProxyChain = trustProxyChain;
+    this.trustedProxyDepth = trustedProxyDepth;
+    this.logger = logger;
+  }
+};
+
+// src/Castle.ts
+var Castle = class {
+  configuration;
+  constructor(configAttributes) {
+    this.configuration = new Configuration(configAttributes);
+  }
+  async risk(params) {
+    if (this.configuration.doNotTrack) {
+      return this.generateDoNotTrackResponse(params.user?.id);
+    }
+    return APIRiskService.call(params, this.configuration);
+  }
+  async filter(params) {
+    if (this.configuration.doNotTrack) {
+      return this.generateDoNotTrackResponse(params.matching_user_id);
+    }
+    return APIFilterService.call(params, this.configuration);
+  }
+  async log(params) {
+    if (this.configuration.doNotTrack) {
+      return;
+    }
+    APILogService.call(params, this.configuration);
+  }
+  async createListItem(params) {
+    return APICreateListItemService.call(params, this.configuration);
+  }
+  async createList(params) {
+    return APICreateListService.call(params, this.configuration);
+  }
+  async updateListItem(params) {
+    return APIUpdateListItemService.call(params, this.configuration);
+  }
+  async updateList(params) {
+    return APIUpdateListService.call(params, this.configuration);
+  }
+  async archiveListItem(params) {
+    return APIArchiveListItemService.call(params, this.configuration);
+  }
+  async unarchiveListItem(params) {
+    return APIUnarchiveListItemService.call(params, this.configuration);
+  }
+  async deleteList(params) {
+    return APIDeleteListService.call(params, this.configuration);
+  }
+  async fetchListItem(params) {
+    return APIFetchListItemService.call(params, this.configuration);
+  }
+  async fetchList(params) {
+    return APIFetchListService.call(params, this.configuration);
+  }
+  async fetchAllLists() {
+    return APIFetchAllListsService.call(this.configuration);
+  }
+  async searchListItems(params) {
+    return APISearchListItemsService.call(params, this.configuration);
+  }
+  async searchLists(params) {
+    return APISearchListsService.call(params, this.configuration);
+  }
+  async batchUpdateListItems(params) {
+    return APIBatchUpsertListItemsService.call(params, this.configuration);
+  }
+  async countListItems(params) {
+    return APICountListItemsService.call(params, this.configuration);
+  }
+  async queryEvents(params) {
+    return APISearchEventsService.call(params, this.configuration);
+  }
+  async eventsSchema() {
+    return APIGetEventsSchemaService.call(this.configuration);
+  }
+  async groupEvents(params) {
+    return APIGroupEventsService.call(params, this.configuration);
+  }
+  /** Alias of {@link Castle.queryEvents}. */
+  async searchEvents(params) {
+    return this.queryEvents(params);
+  }
+  /** Alias of {@link Castle.eventsSchema}. */
+  async getEventsSchema() {
+    return this.eventsSchema();
+  }
+  async requestUserData(params) {
+    return APIRequestUserDataService.call(params, this.configuration);
+  }
+  async deleteUserData(params) {
+    return APIDeleteUserDataService.call(params, this.configuration);
+  }
+  verifyWebhookSignature(payload, signature) {
+    WebhookVerifyService.call(payload, signature, this.configuration);
+  }
+  secureModeSignature(userId) {
+    return SecureModeService.call(userId, this.configuration);
+  }
+  generateDoNotTrackResponse(userId) {
+    return {
+      policy: {
+        action: "allow" /* allow */
+      },
+      action: "allow" /* allow */,
+      user_id: userId,
+      failover: true,
+      failover_reason: "do not track"
+    };
+  }
+};
+
+// src/models/events.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["CHALLENGE"] = "$challenge";
+  EventType2["CUSTOM"] = "$custom";
+  EventType2["LOGIN"] = "$login";
+  EventType2["LOGOUT"] = "$logout";
+  EventType2["PASSWORD_RESET_REQUEST"] = "$password_reset_request";
+  EventType2["PROFILE_RESET"] = "$profile_reset";
+  EventType2["PROFILE_UPDATE"] = "$profile_update";
+  EventType2["REGISTRATION"] = "$registration";
+  EventType2["TRANSACTION"] = "$transaction";
+  return EventType2;
+})(EventType || {});
+var EventStatus = /* @__PURE__ */ ((EventStatus2) => {
+  EventStatus2["ATTEMPTED"] = "$attempted";
+  EventStatus2["FAILED"] = "$failed";
+  EventStatus2["REQUESTED"] = "$requested";
+  EventStatus2["SUCCEEDED"] = "$succeeded";
+  return EventStatus2;
+})(EventStatus || {});
+
+// src/models/action.ts
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2["allow"] = "allow";
+  Action2["deny"] = "deny";
+  Action2["challenge"] = "challenge";
+  return Action2;
+})(Action || {});
+
+// src/payload/models/event_payload.ts
+var SearchEventsQueryType = /* @__PURE__ */ ((SearchEventsQueryType2) => {
+  SearchEventsQueryType2["COUNT"] = "$count";
+  SearchEventsQueryType2["RECORDS"] = "$records";
+  SearchEventsQueryType2["RECORDS_WITH_COUNT"] = "$records_with_count";
+  return SearchEventsQueryType2;
+})(SearchEventsQueryType || {});
+var SearchEventsQueryFilterOperator = /* @__PURE__ */ ((SearchEventsQueryFilterOperator2) => {
+  SearchEventsQueryFilterOperator2["IN"] = "$in";
+  SearchEventsQueryFilterOperator2["NIN"] = "$nin";
+  SearchEventsQueryFilterOperator2["EQ"] = "$eq";
+  SearchEventsQueryFilterOperator2["NEQ"] = "$neq";
+  SearchEventsQueryFilterOperator2["LIKE"] = "$like";
+  SearchEventsQueryFilterOperator2["NLIKE"] = "$nlike";
+  SearchEventsQueryFilterOperator2["CONTAINS"] = "$contains";
+  SearchEventsQueryFilterOperator2["NCONTAINS"] = "$ncontains";
+  SearchEventsQueryFilterOperator2["STARTS_WITH"] = "$starts_with";
+  SearchEventsQueryFilterOperator2["NSTARTS_WITH"] = "$nstarts_with";
+  SearchEventsQueryFilterOperator2["ENDS_WITH"] = "$ends_with";
+  SearchEventsQueryFilterOperator2["NENDS_WITH"] = "$nends_with";
+  SearchEventsQueryFilterOperator2["MATCHES"] = "$matches";
+  SearchEventsQueryFilterOperator2["NMATCHES"] = "$nmatches";
+  SearchEventsQueryFilterOperator2["IP_RANGE"] = "$ip_range";
+  SearchEventsQueryFilterOperator2["NIP_RANGE"] = "$nip_range";
+  return SearchEventsQueryFilterOperator2;
+})(SearchEventsQueryFilterOperator || {});
+
+// src/payload/models/event_response.ts
+var EventSignal = /* @__PURE__ */ ((EventSignal2) => {
+  EventSignal2["ABUSE_IP"] = "abuse_ip";
+  EventSignal2["BOT_BEHAVIOR"] = "bot_behavior";
+  EventSignal2["CREDENTIAL_STUFFING"] = "credential_stuffing";
+  EventSignal2["DISPOSABLE_EMAIL_DOMAIN"] = "disposable_email_domain";
+  EventSignal2["GENERATED_EMAIL"] = "generated_email";
+  EventSignal2["HEADLESS_BROWSER"] = "headless_browser";
+  EventSignal2["HTTP_CLIENT_LIBRARY"] = "http_client_library";
+  EventSignal2["IMPOSSIBLE_TRAVEL"] = "impossible_travel";
+  EventSignal2["INVALID_EMAIL"] = "invalid_email";
+  EventSignal2["INVALID_DEVICE_DATA"] = "invalid_device_data";
+  EventSignal2["MISSING_DEVICE_DATA"] = "missing_device_data";
+  EventSignal2["MISSING_HEADERS"] = "missing_headers";
+  EventSignal2["MULTIPLE_ACCOUNTS_PER_DEVICE"] = "multiple_accounts_per_device";
+  EventSignal2["MULTIPLE_ALIASES_PER_EMAIL"] = "multiple_aliases_per_email";
+  EventSignal2["NEW_COUNTRY"] = "new_country";
+  EventSignal2["NEW_DEVICE"] = "new_device";
+  EventSignal2["NEW_DEVICE_TYPE"] = "new_device_type";
+  EventSignal2["NEW_ISP"] = "new_isp";
+  EventSignal2["NEW_LANGUAGE"] = "new_language";
+  EventSignal2["NEW_OS"] = "new_os";
+  EventSignal2["HIGH_ACTIVITY_DEVICE"] = "high_activity_device";
+  EventSignal2["HIGH_ACTIVITY_IP"] = "high_activity_ip";
+  EventSignal2["HIGH_ACTIVITY_ACCOUNT"] = "high_activity_account";
+  EventSignal2["SPOOFED_DEVICE"] = "spoofed_device";
+  EventSignal2["WEB_CRAWLER"] = "web_crawler";
+  return EventSignal2;
+})(EventSignal || {});
+var EventAuthenticationMethod = /* @__PURE__ */ ((EventAuthenticationMethod2) => {
+  EventAuthenticationMethod2["AUTHENTICATOR"] = "$authenticator";
+  EventAuthenticationMethod2["BIOMETRICS"] = "$biometrics";
+  EventAuthenticationMethod2["EMAIL"] = "$email";
+  EventAuthenticationMethod2["PASSWORD"] = "$password";
+  EventAuthenticationMethod2["PHONE"] = "$phone";
+  EventAuthenticationMethod2["PUSH"] = "$push";
+  EventAuthenticationMethod2["SECURITY_KEY"] = "$security_key";
+  EventAuthenticationMethod2["SOCIAL"] = "$social";
+  EventAuthenticationMethod2["SSO"] = "$sso";
+  EventAuthenticationMethod2["KBA"] = "$kba";
+  EventAuthenticationMethod2["ELECTRONIC_ID"] = "$electronic_id";
+  EventAuthenticationMethod2["PHYSICAL_ID"] = "$physical_id";
+  EventAuthenticationMethod2["DOCUMENT"] = "$document";
+  EventAuthenticationMethod2["VIDEO"] = "$video";
+  EventAuthenticationMethod2["PASSKEY"] = "$passkey";
+  EventAuthenticationMethod2["OTHER"] = "$other";
+  return EventAuthenticationMethod2;
+})(EventAuthenticationMethod || {});
+
+// src/payload/services/payload-prepare-service.ts
+var PayloadPrepareService = {
+  call: (payloadParams, request, configuration, options = {}) => {
+    const context = ContextPrepareService.call(
+      request,
+      deepMerge(payloadParams, options),
+      configuration
+    );
+    return deepMerge(payloadParams, { context });
+  }
+};
+export {
+  APIError,
+  Action,
+  BadRequestError,
+  Castle,
+  ConfigurationError,
+  ContextPrepareService,
+  DEFAULT_ALLOWLIST,
+  DEFAULT_API_URL,
+  DEFAULT_TIMEOUT,
+  EventAuthenticationMethod,
+  EventSignal,
+  EventStatus,
+  EventType,
+  FailoverStrategy,
+  ForbiddenError,
+  InternalServerError,
+  InvalidParametersError,
+  InvalidRequestTokenError,
+  NotFoundError,
+  PayloadPrepareService,
+  RateLimitError,
+  SearchEventsQueryFilterOperator,
+  SearchEventsQueryType,
+  SecureModeService,
+  TRUSTED_PROXIES,
+  UnauthorizedError,
+  UserUnauthorizedError,
+  WebhookVerificationError,
+  WebhookVerifyService
+};
+//# sourceMappingURL=index.mjs.map