@arkyn/server 3.0.1-beta.8 → 3.0.1-beta.80

package/dist/bundle.js

@@ -0,0 +1,1507 @@
+var v = Object.defineProperty;
+var w = (e, t, s) => t in e ? v(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var o = (e, t, s) => w(e, typeof t != "symbol" ? t + "" : t, s);
+import "zod";
+import { removeNonNumeric as N } from "@arkyn/shared";
+import "node:dns";
+import { countries as U } from "@arkyn/templates";
+function g(e) {
+  var s;
+  if (process.env.NODE_ENV === "development" || ((s = process.env) == null ? void 0 : s.SHOW_ERRORS_IN_CONSOLE) === "true") {
+    const a = `${{
+      yellow: "\x1B[33m",
+      cyan: "\x1B[36m",
+      red: "\x1B[31m",
+      green: "\x1B[32m"
+    }[e.scheme]}[${e.name}]\x1B[0m`;
+    let c = `
+`;
+    e.debugs.forEach((h) => {
+      c += `${a} ${h.trim()}
+`;
+    }), console.log(c);
+  }
+}
+const A = {};
+class I {
+  /**
+   * Sets the file name to be ignored during stack trace analysis.
+   *
+   * This method configures the debug service to skip specific files when
+   * determining the actual caller of a function. This is useful when you have
+   * adapter or wrapper functions that you want to be transparent in the debug output.
+   *
+   * @param file - The name of the file to ignore in stack traces (e.g., "httpAdapter.ts")
+   *
+   * @example
+   * ```typescript
+   * // Ignore the HTTP adapter file so debug shows the actual business logic caller
+   * DebugService.setIgnoreFile("httpAdapter.ts");
+   * ```
+   */
+  static setIgnoreFile(t) {
+    this.ignoreFiles.push(t);
+  }
+  /**
+   * Clears all configured ignore files.
+   *
+   * This method resets the ignore file configuration, allowing all files to be
+   * considered in stack trace analysis again.
+   *
+   * @example
+   * ```typescript
+   * // Clear all ignore file configurations
+   * DebugService.clearIgnoreFiles();
+   * ```
+   */
+  static clearIgnoreFiles() {
+    this.ignoreFiles = [];
+  }
+}
+/**
+ * The name of the file to ignore when analyzing the stack trace.
+ * When set, the `getCaller` function will skip stack frames containing this file name.
+ */
+o(I, "ignoreFiles", []);
+function E() {
+  const e = process.cwd(), n = (new Error().stack || "").split(`
+`).map((u) => u.trim()), r = I.ignoreFiles;
+  let a = 2;
+  for (; a < n.length && (n[a].includes("node:internal") || n[a].includes("/node_modules/")); )
+    a++;
+  if (r.length > 0)
+    for (; a < n.length && r.some(
+      (u) => n[a].includes(u)
+    ); )
+      a++;
+  const c = n[a] || "";
+  let h = "Unknown function", i = "Unknown caller";
+  const l = c.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
+  if (l)
+    h = l[1], i = l[2];
+  else {
+    const u = c.match(/at\s+(.+)/);
+    if (u) {
+      i = u[1];
+      const d = i.match(/at\s+([^(\s]+)\s+/);
+      d && d[1] !== "new" && (h = d[1]);
+    }
+  }
+  i.includes("(") && (i = i.substring(
+    i.indexOf("(") + 1,
+    i.lastIndexOf(")")
+  )), i = i.split(":").slice(0, -2).join(":");
+  try {
+    i = A.relative(e, i);
+  } catch {
+  }
+  return { functionName: h, callerInfo: i };
+}
+class p {
+  onDebug(t) {
+    const { name: s, body: n, cause: r, message: a } = t, c = [], { callerInfo: h, functionName: i } = E();
+    c.push(`${s} initialized`), c.push(`Caller Function: ${i}`), c.push(`Caller Location: ${h}`), a && c.push(`Message: ${a}`), n && c.push(`Body: ${JSON.stringify(n, null, 2)}`), r && c.push(`Cause: ${JSON.stringify(r, null, 2)}`), g({ scheme: "red", name: "ARKYN-BAD-RESPONSE-DEBUG", debugs: c });
+  }
+}
+class L extends p {
+  /**
+   * Creates an instance of the `BadGateway` class.
+   *
+   * @param message - A descriptive message explaining the cause of the error.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 502);
+    o(this, "statusText");
+    this.body = { name: "BadGateway", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "BadGateway",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `BadGateway` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `BadGateway` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class T extends p {
+  /**
+   * Creates an instance of the `BadRequest` class.
+   *
+   * @param message - A descriptive message explaining the cause of the error.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 400);
+    o(this, "statusText");
+    this.body = { name: "BadRequest", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "BadRequest",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `BadRequest` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `BadRequest` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class B extends p {
+  /**
+   * Creates an instance of the `Conflict` class.
+   *
+   * @param message - A descriptive message explaining the cause of the conflict.
+   * @param cause - Optional additional information about the cause of the conflict.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 409);
+    o(this, "statusText");
+    this.body = { name: "Conflict", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "Conflict",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `Conflict` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Conflict` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class k extends p {
+  /**
+   * Creates an instance of the `Forbidden` class.
+   *
+   * @param message - A descriptive message explaining why access is forbidden.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 403);
+    o(this, "statusText");
+    this.body = { name: "Forbidden", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "Forbidden",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `Forbidden` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Forbidden` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class H extends p {
+  /**
+   * Creates an instance of the `NotFound` class.
+   *
+   * @param message - A descriptive message explaining the reason the resource was not found.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 404);
+    o(this, "statusText");
+    this.body = { name: "NotFound", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "NotFound",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `NotFound` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `NotFound` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class q extends p {
+  /**
+   * Creates an instance of the `NotImplemented` class.
+   *
+   * @param message - A descriptive message explaining why the functionality is not implemented.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 501);
+    o(this, "statusText");
+    this.body = { name: "NotImplemented", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "NotImplemented",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `NotImplemented` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `NotImplemented` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class x extends p {
+  /**
+   * Creates an instance of the `ServerError` class.
+   *
+   * @param message - A descriptive message explaining the cause of the server error.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 500);
+    o(this, "statusText");
+    this.body = { name: "ServerError", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "ServerError",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `ServerError` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `ServerError` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class F extends p {
+  /**
+   * Creates an instance of the `Unauthorized` class.
+   *
+   * @param message - A descriptive message explaining why the request is unauthorized.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "cause");
+    o(this, "status", 401);
+    o(this, "statusText");
+    this.body = { name: "Unauthorized", message: s }, this.statusText = s, this.cause = n ? JSON.stringify(n) : void 0, this.onDebug({
+      name: "Unauthorized",
+      body: this.body,
+      cause: this.cause,
+      message: this.statusText
+    });
+  }
+  /**
+   * Converts the `Unauthorized` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Unauthorized` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class R extends p {
+  /**
+   * Creates an instance of the `UnprocessableEntity` class.
+   *
+   * @param props - An object containing details about the error, such as:
+   *   - `data`: Additional data related to the error.
+   *   - `fieldErrors`: A record of field-specific error messages.
+   *   - `fields`: A record of field values that caused the error.
+   *   - `message`: A descriptive message explaining the error.
+   * @param enableDebug - A boolean indicating whether to enable debug logging for this error.
+   */
+  constructor(s) {
+    super();
+    o(this, "body");
+    o(this, "status", 422);
+    o(this, "statusText");
+    this.statusText = s.message || "Unprocessable Entity", this.body = {
+      name: "UnprocessableEntity",
+      message: s.message || null,
+      data: s.data,
+      fieldErrors: s.fieldErrors,
+      fields: s.fields
+    }, this.onDebug({
+      name: "UnprocessableEntity",
+      cause: s.fieldErrors,
+      message: s.message
+    });
+  }
+  /**
+   * Converts the `UnprocessableEntity` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `UnprocessableEntity` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class m {
+  /**
+   * Logs debug information for success responses including caller context and response details.
+   *
+   * @param name - The name/type of the success response being logged
+   * @param body - The response body or success data to be logged
+   * @param cause - Optional additional cause information for the error
+   *
+   * @example
+   * ```typescript
+   * const SuccessResponse = new SuccessResponse();
+   * SuccessResponse.onDebug("ValidationError", { field: "email", message: "Invalid format" });
+   * ```
+   */
+  onDebug(t, s, n) {
+    const r = [], { callerInfo: a, functionName: c } = E();
+    r.push(`${t} initialized
+`), r.push(`Caller Function: ${c}
+`), r.push(`Caller Location: ${a}
+`), r.push(`Body: ${JSON.stringify(s, null, 2)}
+`), n && r.push(`Cause: ${JSON.stringify(n, null, 2)}
+`), g({
+      scheme: "green",
+      name: "ARKYN-SUCCESS-RESPONSE-DEBUG",
+      debugs: r
+    });
+  }
+}
+class P extends m {
+  /**
+   * Creates an instance of the `Created` class.
+   *
+   * @param body - The response body to be included in the HTTP response.
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "headers");
+    o(this, "status");
+    o(this, "statusText");
+    this.body = s, this.headers = (n == null ? void 0 : n.headers) || {}, this.status = (n == null ? void 0 : n.status) || 201, this.statusText = (n == null ? void 0 : n.statusText) || "Resource created successfully", this.onDebug("Created", s);
+  }
+  /**
+   * Converts the `Created` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Created` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class Y extends m {
+  /**
+   * Creates an instance of the `Found` class.
+   *
+   * @param body - The body of the response.
+   * @param init - Optional initialization object to set headers, status, and statusText.
+   *   - `headers`: Additional headers to include in the response.
+   *   - `status`: HTTP status code (default is 302).
+   *   - `statusText`: HTTP status text (default is "Found").
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "headers");
+    o(this, "status");
+    o(this, "statusText");
+    this.body = s, this.headers = (n == null ? void 0 : n.headers) || {}, this.status = (n == null ? void 0 : n.status) || 302, this.statusText = (n == null ? void 0 : n.statusText) || "Found", this.onDebug("Found", s);
+  }
+  /**
+   * Converts the `Found` instance into a `Response` object.
+   * This method serializes the response body as JSON and includes the appropriate headers.
+   *
+   * @returns A `Response` object with the serialized JSON body and the specified headers, status, and statusText.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Found` instance into a JSON response using `Response.json`.
+   * This method is an alternative to `toResponse` for creating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and the specified headers, status, and statusText.
+   */
+  toJson() {
+    const s = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class z extends m {
+  /**
+   * Creates an instance of the `NoContent` class.
+   *
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+  constructor(s) {
+    super();
+    o(this, "headers");
+    o(this, "status");
+    o(this, "statusText");
+    this.headers = (s == null ? void 0 : s.headers) || {}, this.status = (s == null ? void 0 : s.status) || 204, this.statusText = (s == null ? void 0 : s.statusText) ?? "No content", this.onDebug("No content", null);
+  }
+  /**
+   * Converts the `NoContent` instance into a `Response` object.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with no body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(null, s);
+  }
+}
+class M extends m {
+  /**
+   * Creates an instance of the `Success` class.
+   *
+   * @param body - The response body to be included in the HTTP response.
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "headers");
+    o(this, "status");
+    o(this, "statusText");
+    this.body = s, this.headers = (n == null ? void 0 : n.headers) || {}, this.status = (n == null ? void 0 : n.status) || 200, this.statusText = (n == null ? void 0 : n.statusText) ?? "OK", this.onDebug("Success", s);
+  }
+  /**
+   * Converts the `Success` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Success` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class _ extends m {
+  /**
+   * Creates an instance of the `Updated` class.
+   *
+   * @param body - The response body to be included in the HTTP response.
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+  constructor(s, n) {
+    super();
+    o(this, "body");
+    o(this, "headers");
+    o(this, "status");
+    o(this, "statusText");
+    this.body = s, this.headers = (n == null ? void 0 : n.headers) || {}, this.status = (n == null ? void 0 : n.status) || 200, this.statusText = (n == null ? void 0 : n.statusText) || "Resource updated successfully", this.onDebug("Updated", s);
+  }
+  /**
+   * Converts the `Updated` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /**
+   * Converts the `Updated` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+  toJson() {
+    const s = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class V {
+  static mapHeaders(t) {
+    return t instanceof Headers ? Object.fromEntries(t.entries()) : typeof t == "object" ? Object.entries(t).reduce((s, [n, r]) => (typeof r == "string" ? s[n] = r : Array.isArray(r) ? s[n] = r.join(", ") : s[n] = JSON.stringify(r), s), {}) : {};
+  }
+  static mapQueryParams(t) {
+    const s = {};
+    return t.forEach((n, r) => {
+      s[r] = n;
+    }), s;
+  }
+  static handle(t) {
+    return {
+      rawUrl: t.url,
+      status: t.status,
+      method: t.method,
+      token: null,
+      elapsedTime: t.elapsedTime,
+      requestHeaders: this.mapHeaders(t.requestHeaders),
+      requestBody: t.requestBody || null,
+      queryParams: this.mapQueryParams(t.queryParams),
+      responseHeaders: this.mapHeaders(t.responseHeaders),
+      responseBody: t.responseBody || null
+    };
+  }
+}
+class C {
+  /**
+   * Sets the configuration for the arkyn. This method initializes the arkyn configuration
+   * with the provided `arkynConfig` values. If the configuration has already been set,
+   * the method will return early without making any changes.
+   *
+   * @param arkynConfig - An object containing the arkyn configuration properties.
+   * @param arkynConfig.arkynTrafficSourceId - The key used to identify the arkyn.
+   * @param arkynConfig.arkynUserToken - The user token for authenticating with the arkyn.
+   * @param arkynConfig.arkynLogBaseApiUrl - (Optional) The API URL for the arkyn. If not provided,
+   * a default URL will be used.
+   */
+  static setArkynConfig(t) {
+    if (this.arkynConfig) return;
+    const { trafficSourceId: s, userToken: n, logBaseApiUrl: r } = t;
+    this.arkynConfig = {
+      trafficSourceId: s,
+      userToken: n,
+      apiUrl: r || "http://95.216.190.158:8081/ingest-log"
+    };
+  }
+  /**
+   * Retrieves the current arkyn configuration for the ArkynLogService.
+   *
+   * @returns {ArkynConfigProps | undefined} The current arkyn configuration if set,
+   * or `undefined` if no configuration has been initialized.
+   */
+  static getArkynConfig() {
+    return this.arkynConfig;
+  }
+  /**
+   * Resets the arkyn configuration to `undefined`.
+   * This method can be used to clear the current configuration.
+   */
+  static resetArkynConfig() {
+    this.arkynConfig = void 0;
+  }
+}
+o(C, "arkynConfig");
+async function G(e) {
+  const t = C.getArkynConfig();
+  if (!t) return;
+  const { userToken: s, apiUrl: n, trafficSourceId: r } = t, {
+    elapsedTime: a,
+    method: c,
+    queryParams: h,
+    requestBody: i,
+    requestHeaders: l,
+    responseBody: u,
+    responseHeaders: d,
+    status: S,
+    token: f,
+    rawUrl: j
+  } = e;
+  if (process.env.NODE_ENV !== "development")
+    try {
+      const y = new URL(j);
+      let D = "HTTPS";
+      y.protocol === "http:" && (D = "HTTP");
+      const J = JSON.stringify({
+        domainUrl: y.protocol + "//" + y.host,
+        pathnameUrl: y.pathname,
+        trafficSourceId: r,
+        status: S,
+        protocol: D,
+        method: c,
+        trafficUserId: null,
+        elapsedTime: a,
+        requestHeaders: l,
+        requestBody: i,
+        queryParams: h,
+        responseHeaders: d,
+        responseBody: u
+      });
+      await fetch(n, {
+        method: "POST",
+        body: J,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${s}`
+        }
+      });
+    } catch (y) {
+      g({
+        debugs: [`Error sending request: ${y}`],
+        name: "ARKYN_LOG_ERROR",
+        scheme: "red"
+      });
+    }
+}
+async function b(e, t, s = {}, n) {
+  const r = {
+    POST: "Resource created successfully",
+    PUT: "Resource updated successfully",
+    DELETE: "Resource deleted successfully",
+    PATCH: "Resource patched successfully",
+    GET: "Request successful"
+  };
+  try {
+    const a = performance.now(), c = { ...s, "Content-Type": "application/json" }, h = await fetch(t, {
+      method: e,
+      headers: c,
+      body: n ? JSON.stringify(n) : void 0
+    }), i = performance.now() - a, l = h.status;
+    let u = null;
+    try {
+      u = await h.json();
+    } catch {
+      u = null;
+    }
+    const d = V.handle({
+      elapsedTime: i,
+      method: e,
+      queryParams: new URL(t).searchParams,
+      requestHeaders: c,
+      requestBody: n,
+      responseBody: u,
+      responseHeaders: h.headers,
+      status: l,
+      url: t
+    });
+    return G(d), h.ok ? {
+      success: !0,
+      status: l,
+      message: (u == null ? void 0 : u.message) || r[e],
+      response: u,
+      cause: null
+    } : {
+      success: !1,
+      status: l,
+      message: (u == null ? void 0 : u.message) || h.statusText || "Request failed",
+      response: u,
+      cause: null
+    };
+  } catch (a) {
+    return g({
+      debugs: [`Network error or request failed: ${a}`],
+      name: "ARKYN_MAKE_REQUEST_ERROR",
+      scheme: "red"
+    }), {
+      success: !1,
+      status: 0,
+      message: "Network error or request failed",
+      response: null,
+      cause: a instanceof Error ? a.message : String(a)
+    };
+  }
+}
+async function Z(e, t = {}, s) {
+  return b("DELETE", e, t, s);
+}
+async function W(e, t = {}) {
+  return b("GET", e, t);
+}
+async function K(e, t = {}, s) {
+  return b("PATCH", e, t, s);
+}
+async function Q(e, t = {}, s) {
+  return b("POST", e, t, s);
+}
+async function X(e, t = {}, s) {
+  return b("PUT", e, t, s);
+}
+class xs {
+  /**
+   * Creates an instance of ApiService.
+   * @param props - The configuration properties for the API instance.
+   * @param props.baseUrl - The base URL for the API.
+   * @param props.baseHeaders - Optional base headers to include in all requests.
+   * @param props.baseToken - Optional base token for authorization.
+   * @param props.enableDebug - Optional flag to enable debug logging for requests.
+   */
+  constructor(t) {
+    o(this, "baseUrl");
+    o(this, "baseHeaders");
+    o(this, "baseToken");
+    o(this, "enableDebug");
+    this.baseUrl = t.baseUrl, this.baseHeaders = t.baseHeaders || void 0, this.baseToken = t.baseToken || void 0, this.enableDebug = t.enableDebug || !1;
+  }
+  /**
+   * Generates the full URL by appending the route to the base URL.
+   * @param route - The route to append to the base URL.
+   * @returns The full URL as a string.
+   */
+  onDebug(t, s, n) {
+    if (this.enableDebug) {
+      const r = [];
+      r.push(`Base URL: ${this.baseUrl}`), r.push(`Endpoint: ${t}`), r.push(`Method: ${s}`), n[0] && r.push(`Headers: ${JSON.stringify(n[0])}`), n[1] && r.push(`Body: ${JSON.stringify(n[1])}`), g({ debugs: r, name: "ARKYN-API-DEBUG", scheme: "yellow" });
+    }
+  }
+  generateURL(t) {
+    return this.baseUrl + t;
+  }
+  /**
+   * Generates the headers for a request by merging base headers, provided headers, and tokens.
+   * @param initHeaders - Initial headers to include in the request.
+   * @param token - Optional token to override the base token.
+   * @returns The merged headers as a HeadersInit object.
+   */
+  generateHeaders(t, s) {
+    let n = {};
+    return this.baseToken && (n = { Authorization: `Bearer ${this.baseToken}` }), this.baseHeaders && (n = { ...n, ...this.baseHeaders }), t && (n = { ...n, ...t }), s && (n = { ...n, Authorization: `Bearer ${s}` }), n;
+  }
+  /**
+   * Sends a get request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the get request to.
+   * @param data - The request data, including optional headers and token.
+   * @returns The API response data.
+   */
+  async get(t, s) {
+    const n = this.generateURL(t), r = this.generateHeaders((s == null ? void 0 : s.headers) || {}, s == null ? void 0 : s.token);
+    return this.onDebug(t, "get", [r]), await W(n, r);
+  }
+  /**
+   * Sends a post request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the post request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async post(t, s) {
+    const n = this.generateURL(t), r = this.generateHeaders((s == null ? void 0 : s.headers) || {}, s == null ? void 0 : s.token), a = s == null ? void 0 : s.body;
+    return this.onDebug(t, "post", [r, a]), await Q(n, r, a);
+  }
+  /**
+   * Sends a put request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the put request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async put(t, s) {
+    const n = this.generateURL(t), r = this.generateHeaders((s == null ? void 0 : s.headers) || {}, s == null ? void 0 : s.token), a = s == null ? void 0 : s.body;
+    return this.onDebug(t, "put", [r, a]), await X(n, r, a);
+  }
+  /**
+   * Sends a patch request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the patch request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async patch(t, s) {
+    const n = this.generateURL(t), r = this.generateHeaders((s == null ? void 0 : s.headers) || {}, s == null ? void 0 : s.token), a = s == null ? void 0 : s.body;
+    return this.onDebug(t, "patch", [r, a]), await K(n, r, a);
+  }
+  /**
+   * Sends a delete request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the delete request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async delete(t, s) {
+    const n = this.generateURL(t), r = this.generateHeaders((s == null ? void 0 : s.headers) || {}, s == null ? void 0 : s.token), a = s == null ? void 0 : s.body;
+    return this.onDebug(t, "delete", [r, a]), await Z(n, r, a);
+  }
+}
+function Rs(e, t) {
+  var s, n, r;
+  return e != null && e.message && typeof (e == null ? void 0 : e.message) == "string" ? e == null ? void 0 : e.message : e != null && e.error && typeof (e == null ? void 0 : e.error) == "string" ? e == null ? void 0 : e.error : (s = e == null ? void 0 : e.error) != null && s.message && typeof ((n = e == null ? void 0 : e.error) == null ? void 0 : n.message) == "string" ? (r = e == null ? void 0 : e.error) == null ? void 0 : r.message : t != null && t.statusText && typeof (t == null ? void 0 : t.statusText) == "string" ? t == null ? void 0 : t.statusText : "Missing error message";
+}
+const Ns = async (e) => {
+  let t;
+  const s = await e.arrayBuffer(), n = new TextDecoder().decode(s);
+  try {
+    t = JSON.parse(n);
+  } catch {
+    try {
+      if (n.includes("=")) {
+        const a = new URLSearchParams(n);
+        t = Object.fromEntries(a.entries());
+      } else
+        throw new T("Invalid URLSearchParams format");
+    } catch {
+      throw new T("Failed to extract data from request");
+    }
+  }
+  return t;
+};
+function Es(e) {
+  switch (!0) {
+    case e instanceof Response:
+      return e;
+    case e instanceof Y:
+      return e.toResponse();
+    case e instanceof P:
+      return e.toResponse();
+    case e instanceof _:
+      return e.toResponse();
+    case e instanceof M:
+      return e.toResponse();
+    case e instanceof z:
+      return e.toResponse();
+  }
+  switch (!0) {
+    case e instanceof L:
+      return e.toResponse();
+    case e instanceof T:
+      return e.toResponse();
+    case e instanceof B:
+      return e.toResponse();
+    case e instanceof k:
+      return e.toResponse();
+    case e instanceof H:
+      return e.toResponse();
+    case e instanceof q:
+      return e.toResponse();
+    case e instanceof x:
+      return e.toResponse();
+    case e instanceof F:
+      return e.toResponse();
+    case e instanceof R:
+      return e.toResponse();
+  }
+  return new x("Server error", e).toResponse();
+}
+async function ss([
+  e,
+  t
+]) {
+  const s = await t.safeParseAsync(e);
+  if (s.success === !1) {
+    const n = Object.fromEntries(
+      s.error.issues.map((r) => [r.path.join("."), r.message])
+    );
+    return {
+      success: s.success,
+      fieldErrors: n,
+      fields: e
+    };
+  } else
+    return {
+      success: s.success,
+      data: s.data
+    };
+}
+function es([
+  e,
+  t
+]) {
+  const s = t.safeParse(e);
+  if (s.success === !1) {
+    const n = Object.fromEntries(
+      s.error.issues.map((r) => [r.path.join("."), r.message])
+    );
+    return {
+      success: s.success,
+      fieldErrors: n,
+      fields: e
+    };
+  } else
+    return {
+      success: s.success,
+      data: s.data
+    };
+}
+const Ss = (e, t = "") => {
+  const s = new URL(e.url);
+  if (t === "") return s.searchParams;
+  const n = Array.from(
+    s.searchParams.entries()
+  ).filter(([r]) => r.startsWith(`${t}:`)).map(([r, a]) => [r.replace(`${t}:`, ""), a]);
+  return new URLSearchParams(n);
+};
+function ts(e) {
+  const t = "Error validating:", s = e.issues.map(
+    ({ path: n, message: r }) => `-> ${n.join(".")}: ${r}`
+  );
+  return [t, ...s].join(`
+`);
+}
+class Ds {
+  /**
+   * Creates a new SchemaValidator instance.
+   *
+   * @param {T} schema - The Zod schema to use for validation.
+   */
+  constructor(t) {
+    o(this, "functionName");
+    o(this, "callerInfo");
+    this.schema = t;
+    const { callerInfo: s, functionName: n } = E();
+    this.callerInfo = s, this.functionName = n;
+  }
+  /**
+   * Checks if the provided data is valid according to the schema without throwing errors.
+   *
+   * @param {any} data - The data to validate.
+   *
+   * @returns {boolean} True if the data is valid, false otherwise.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(userSchema);
+   * const isValid = validator.isValid({ name: "John", email: "invalid-email" });
+   * console.log(isValid); // false
+   * ```
+   */
+  isValid(t) {
+    return this.schema.safeParse(t).success;
+  }
+  /**
+   * Safely validates data and returns the complete parse result without throwing errors.
+   *
+   * @param {any} data - The data to validate.
+   *
+   * @returns {z.ZodSafeParseResult<z.infer<T>>} The Zod safe parse result containing success status and data or error.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(userSchema);
+   * const result = validator.safeValidate({ name: "", email: "john@example.com" });
+   *
+   * if (result.success) {
+   *   console.log(result.data); // Validated data
+   * } else {
+   *   console.log(result.error.issues); // Validation errors
+   * }
+   * ```
+   */
+  safeValidate(t) {
+    return this.schema.safeParse(t);
+  }
+  /**
+   * Validates data and returns the parsed result, throwing a ServerError on validation failure.
+   *
+   * @param {any} data - The data to validate.
+   *
+   * @returns {z.infer<T>} The validated and parsed data.
+   *
+   * @throws {ServerError} When validation fails, with a formatted error message.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(userSchema);
+   *
+   * try {
+   *   const validUser = validator.validate({ name: "John", email: "john@example.com", age: 25 });
+   *   console.log(validUser); // { name: "John", email: "john@example.com", age: 25 }
+   * } catch (error) {
+   *   console.error(error.message); // "Error validating:\n-> name: String must contain at least 1 character(s)"
+   * }
+   * ```
+   */
+  validate(t) {
+    try {
+      return this.schema.parse(t);
+    } catch (s) {
+      throw new x(ts(s));
+    }
+  }
+  /**
+   * Validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
+   * This method is specifically designed for form validation in web applications.
+   *
+   * @param {any} data - The form data to validate.
+   * @param {string} [message] - Optional custom error message.
+   *
+   * @returns {z.infer<T>} The validated and parsed form data.
+   *
+   * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(userSchema);
+   *
+   * try {
+   *   const validFormData = validator.formValidate(requestBody, "User data is invalid");
+   *   console.log(validFormData);
+   * } catch (error) {
+   *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
+   *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
+   *   console.log(error.data.scrollTo); // "name" (first error field)
+   * }
+   * ```
+   */
+  formValidate(t, s) {
+    const n = es([t, this.schema]);
+    if (!n.success) {
+      const r = Object.keys(n.fieldErrors)[0];
+      throw new R({
+        fields: n.fields,
+        fieldErrors: n.fieldErrors,
+        data: { scrollTo: r },
+        message: s
+      });
+    }
+    return n.data;
+  }
+  /**
+   * Asynchronously validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
+   * This method is the async version of formValidate, designed for form validation with async schemas.
+   *
+   * @param {any} data - The form data to validate.
+   * @param {string} [message] - Optional custom error message.
+   *
+   * @returns {Promise<z.infer<T>>} A promise that resolves to the validated and parsed form data.
+   *
+   * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(userSchemaWithAsyncValidation);
+   *
+   * try {
+   *   const validFormData = await validator.formAsyncValidate(requestBody, "User data is invalid");
+   *   console.log(validFormData);
+   * } catch (error) {
+   *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
+   *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
+   *   console.log(error.data.scrollTo); // "name" (first error field)
+   * }
+   * ```
+   */
+  async formAsyncValidate(t, s) {
+    const n = await ss([t, this.schema]);
+    if (!n.success) {
+      const r = Object.keys(n.fieldErrors)[0];
+      throw new R({
+        fields: n.fields,
+        fieldErrors: n.fieldErrors,
+        data: { scrollTo: r },
+        message: s
+      });
+    }
+    return n.data;
+  }
+}
+const $s = (e) => {
+  if (!e || !/^[0-9-]+$/.test(e)) return !1;
+  const s = N(e), n = 8, r = /^\d{8}$/.test(s);
+  return s.length === n && r;
+};
+function ns(e) {
+  return e.length !== 14;
+}
+function rs(e) {
+  const [t] = e;
+  return [...e].every((s) => s === t);
+}
+function $(e, t) {
+  let s = 0;
+  for (let r = 0; r < t.length; r++)
+    s += parseInt(e[r]) * t[r];
+  const n = s % 11;
+  return n < 2 ? 0 : 11 - n;
+}
+function os(e) {
+  return e.slice(12);
+}
+const Os = (e) => {
+  if (!e) return !1;
+  const t = N(e);
+  if (ns(t) || rs(t)) return !1;
+  const s = t.slice(0, 12), n = $(s, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]), r = $(
+    s + n,
+    [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+  );
+  return os(t) === `${n}${r}`;
+};
+function as(e) {
+  return e.length !== 11;
+}
+function us(e) {
+  const [t] = e;
+  return [...e].every((s) => s === t);
+}
+function O(e, t) {
+  let s = 0;
+  for (const r of e)
+    t > 1 && (s += parseInt(r) * t--);
+  const n = s % 11;
+  return n < 2 ? 0 : 11 - n;
+}
+function is(e) {
+  return e.slice(9);
+}
+const Is = (e) => {
+  if (!e) return !1;
+  const t = N(e);
+  if (as(t) || us(t)) return !1;
+  const s = O(t, 10), n = O(t, 11);
+  return is(t) === `${s}${n}`;
+}, Cs = (e, t) => {
+  let s, n, r;
+  const a = (t == null ? void 0 : t.inputFormat) || "DD/MM/YYYY", c = (t == null ? void 0 : t.minYear) || 1900, h = (t == null ? void 0 : t.maxYear) || 3e3;
+  if (a === "DD/MM/YYYY") {
+    const f = /^(\d{2})\/(\d{2})\/(\d{4})$/;
+    if (!f.test(e)) return !1;
+    [, s, n, r] = e.match(f) || [];
+  } else if (a === "MM-DD-YYYY") {
+    const f = /^(\d{2})-(\d{2})-(\d{4})$/;
+    if (!f.test(e)) return !1;
+    [, n, s, r] = e.match(f) || [];
+  } else if (a === "YYYY-MM-DD") {
+    const f = /^(\d{4})-(\d{2})-(\d{2})$/;
+    if (!f.test(e)) return !1;
+    [, r, n, s] = e.match(f) || [];
+  } else
+    throw new Error("Invalid date format");
+  const i = parseInt(s, 10), l = parseInt(n, 10), u = parseInt(r, 10);
+  if (i < 1 || i > 31 || l < 1 || l > 12) return !1;
+  const d = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (l === 2) {
+    const f = u % 4 === 0 && u % 100 !== 0 || u % 400 === 0;
+    if (i > (f ? 29 : 28)) return !1;
+  } else if (i > d[l - 1])
+    return !1;
+  return u < c || u > h ? !1 : new Date(u, l - 1, i).getDate() === i;
+};
+function cs(e) {
+  return /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(e);
+}
+function hs(e) {
+  return !(e.length === 0 || e.length > 64 || e.startsWith(".") || e.endsWith(".") || e.includes("..") || !/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+$/.test(e));
+}
+function ls(e) {
+  return !(e.length === 0 || e.length > 63 || e.startsWith("-") || e.endsWith("-") || !/^[a-zA-Z0-9-]+$/.test(e));
+}
+function fs(e) {
+  if (e.length === 0 || e.length > 253 || e.startsWith(".") || e.endsWith(".") || e.startsWith("-") || e.endsWith("-"))
+    return !1;
+  const t = e.split(".");
+  if (t.length < 2) return !1;
+  for (const n of t) if (!ls(n)) return !1;
+  const s = t[t.length - 1];
+  return !(s.length < 2 || !/^[a-zA-Z]+$/.test(s));
+}
+function ds(e) {
+  const t = e.split("@");
+  if (t.length !== 2) return !1;
+  const [s, n] = t;
+  return !(!hs(s) || !fs(n));
+}
+function ps(e) {
+  const t = e.split("@");
+  return t.length === 2 ? t[1].toLowerCase() : null;
+}
+const js = async (e) => {
+  if (!e || typeof e != "string") return !1;
+  const t = e.trim();
+  return !(!cs(t) || !ds(t) || !ps(t));
+}, Js = (e) => {
+  if (!e) return !1;
+  const t = e.length >= 8, s = /[A-Z]/.test(e), n = /[a-z]/.test(e), r = /\d/.test(e), a = /[!@#$%^&*(),.?":{}|<>_\-+=~`[\]\\\/]/.test(
+    e
+  );
+  return [
+    t,
+    s,
+    n,
+    r,
+    a
+  ].every((c) => c);
+}, vs = (e) => {
+  for (const t of U) {
+    const s = t.code, n = t.prefix ? `-${t.prefix}` : "", r = t.mask.replace(/[^_]/g, "").length;
+    if (t.iso === "BR") {
+      if (new RegExp(`^\\${s} \\d{2}9?\\d{8}$`).test(e)) return !0;
+      continue;
+    }
+    if (new RegExp(`^\\${s}${n} \\d{${r}}$`).test(e)) return !0;
+  }
+  return !1;
+}, ws = (e) => {
+  if (!e || !/^[0-9a-zA-Z.-]+$/.test(e)) return !1;
+  const s = e.replace(/[^a-zA-Z0-9]/g, "");
+  return s.length < 7 || s.length > 9 ? !1 : /^[0-9]{7,8}[0-9Xx]?$/.test(s);
+};
+export {
+  xs as ApiService,
+  C as ArkynLogService,
+  L as BadGateway,
+  T as BadRequest,
+  B as Conflict,
+  P as Created,
+  I as DebugService,
+  k as Forbidden,
+  Y as Found,
+  z as NoContent,
+  H as NotFound,
+  q as NotImplemented,
+  Ds as SchemaValidator,
+  x as ServerError,
+  M as Success,
+  F as Unauthorized,
+  R as UnprocessableEntity,
+  _ as Updated,
+  Rs as decodeErrorMessageFromRequest,
+  Ns as decodeRequestBody,
+  Es as errorHandler,
+  g as flushDebugLogs,
+  ss as formAsyncParse,
+  es as formParse,
+  E as getCaller,
+  Ss as getScopedParams,
+  $s as validateCep,
+  Os as validateCnpj,
+  Is as validateCpf,
+  Cs as validateDate,
+  js as validateEmail,
+  Js as validatePassword,
+  vs as validatePhone,
+  ws as validateRg
+};