@kaito-http/core 4.0.0-beta.3 → 4.0.0-beta.30

package/dist/chunk-DRJX3OJG.js

@@ -0,0 +1,1003 @@
+// src/schema/schema.ts
+function isPrimitiveJSONValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+var SchemaError = class extends Error {
+  constructor(issues) {
+    const first = issues.values().next().value;
+    if (first === void 0) {
+      throw new Error("SchemaError expects at least one issue to be provided");
+    }
+    super(first.message);
+    this.issues = issues;
+  }
+};
+var ParseContext = class _ParseContext {
+  static ISSUE = Symbol("ISSUE");
+  ISSUE = _ParseContext.ISSUE;
+  #issues = /* @__PURE__ */ new Set();
+  addIssue(message, path) {
+    this.#issues.add({ message, path });
+    return _ParseContext.ISSUE;
+  }
+  addIssues(issues, path) {
+    for (const issue of issues) {
+      this.#issues.add({ ...issue, path: [...path, ...issue.path] });
+    }
+    return _ParseContext.ISSUE;
+  }
+  get issues() {
+    return this.#issues;
+  }
+  static result(fn) {
+    const result = _ParseContext.with(fn);
+    if (result.type === "FATAL" || result.issues.size > 0) {
+      return {
+        success: false,
+        issues: result.issues
+      };
+    }
+    return {
+      success: true,
+      result: result.data
+    };
+  }
+  static with(fn) {
+    const ctx = new _ParseContext();
+    const data = fn(ctx);
+    if (data === _ParseContext.ISSUE) {
+      return {
+        type: "FATAL",
+        issues: ctx.issues
+      };
+    }
+    return {
+      type: "PARSED",
+      issues: ctx.issues,
+      data
+    };
+  }
+};
+var BaseSchema = class {
+  /** @internal */
+  _input;
+  /** @internal */
+  _output;
+  def;
+  getSchemaObject() {
+    const schema = {};
+    if (this.def.description !== void 0) {
+      schema.description = this.def.description;
+    }
+    if (this.def.example !== void 0) {
+      schema.example = this.def.example;
+    }
+    return schema;
+  }
+  clone(def) {
+    return new this.constructor({
+      ...this.def,
+      ...def
+    });
+  }
+  constructor(def) {
+    this.def = def;
+  }
+  or(other) {
+    return k.union([this, other]);
+  }
+  example(example) {
+    if (example === void 0) {
+      return this.def.example;
+    }
+    return this.clone({ example });
+  }
+  description(description) {
+    if (description === void 0) {
+      return this.def.description;
+    }
+    return this.clone({ description });
+  }
+};
+var STRING_FORMAT_REGEXES = {
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i,
+  email: /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i,
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv6: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/,
+  date: /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/.+|^[a-zA-Z][a-zA-Z0-9+.-]*:[^\/].+/,
+  hostname: /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/
+};
+var KString = class _KString extends BaseSchema {
+  static create = () => new _KString({});
+  serialize(value) {
+    return value;
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const schema = {
+      ...baseSchema,
+      type: "string"
+    };
+    if (this.def.regex) {
+      schema.pattern = this.def.regex.regex.source;
+    }
+    if (this.def.format) {
+      schema.format = this.def.format.format;
+    }
+    if (this.def.min !== void 0) {
+      schema.minLength = this.def.min.val;
+    }
+    if (this.def.max !== void 0) {
+      schema.maxLength = this.def.max.val;
+    }
+    return schema;
+  }
+  /**
+   * Sets the minimum length of the string
+   *
+   * @param min The minimum length of the string
+   * @returns A clone of the schema with the minimum length set
+   */
+  min(min, message) {
+    return this.setCheck({ type: "min", val: min, message });
+  }
+  /**
+   * Sets the maximum length of the string
+   *
+   * @param max The maximum length of the string
+   * @returns A clone of the schema with the maximum length set
+   */
+  max(max, message) {
+    return this.setCheck({ type: "max", val: max, message });
+  }
+  regex(regex, message) {
+    return this.setCheck({ type: "regex", regex, message });
+  }
+  startsWith(prefix, message) {
+    return this.setCheck({ type: "startsWith", prefix, message });
+  }
+  endsWith(suffix, message) {
+    return this.setCheck({ type: "endsWith", suffix, message });
+  }
+  format(format, message) {
+    return this.setCheck({ type: "format", format, message });
+  }
+  uri(message) {
+    return this.format("uri", message);
+  }
+  /**
+   * Deprecated because OpenAPI uses the term "uri"
+   * but this method exists for making migration from
+   * Zod easier.
+   *
+   * @deprecated Use {@link uri} instead
+   */
+  url(message) {
+    return this.uri(message);
+  }
+  email(message) {
+    return this.format("email", message);
+  }
+  uuid(message) {
+    return this.format("uuid", message);
+  }
+  ipv4(message) {
+    return this.format("ipv4", message);
+  }
+  ipv6(message) {
+    return this.format("ipv6", message);
+  }
+  date(message) {
+    return this.format("date", message);
+  }
+  dateTime(message) {
+    return this.format("date-time", message);
+  }
+  password(message) {
+    return this.format("password", message);
+  }
+  byte(message) {
+    return this.format("byte", message);
+  }
+  binary(message) {
+    return this.format("binary", message);
+  }
+  hostname(message) {
+    return this.format("hostname", message);
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "string") {
+        return ctx.addIssue("Expected string", []);
+      }
+      if (this.def.min !== void 0 && json.length < this.def.min.val) {
+        ctx.addIssue(this.def.min.message ?? `String must be at least ${this.def.min.val} characters`, []);
+      }
+      if (this.def.max !== void 0 && json.length > this.def.max.val) {
+        ctx.addIssue(this.def.max.message ?? `String must be at most ${this.def.max.val} characters`, []);
+      }
+      if (this.def.regex !== void 0 && !this.def.regex.regex.test(json)) {
+        ctx.addIssue(this.def.regex.message ?? `String must match ${this.def.regex.regex.source}`, []);
+      }
+      if (this.def.startsWith !== void 0 && !json.startsWith(this.def.startsWith.prefix)) {
+        ctx.addIssue(this.def.startsWith.message ?? `String must start with "${this.def.startsWith.prefix}"`, []);
+      }
+      if (this.def.endsWith !== void 0 && !json.endsWith(this.def.endsWith.suffix)) {
+        ctx.addIssue(this.def.endsWith.message ?? `String must end with "${this.def.endsWith.suffix}"`, []);
+      }
+      if (this.def.format !== void 0) {
+        switch (this.def.format.format) {
+          case "uuid":
+            if (!STRING_FORMAT_REGEXES.uuid.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid UUID format", []);
+            }
+            break;
+          case "email":
+            if (!STRING_FORMAT_REGEXES.email.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid email format", []);
+            }
+            break;
+          case "ipv4":
+            if (!STRING_FORMAT_REGEXES.ipv4.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid IPv4 address", []);
+            }
+            break;
+          case "ipv6":
+            if (!STRING_FORMAT_REGEXES.ipv6.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid IPv6 address", []);
+            }
+            break;
+          case "date":
+            if (!STRING_FORMAT_REGEXES.date.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid date format", []);
+            }
+            break;
+          case "date-time":
+            if (Number.isNaN(new Date(json).getTime())) {
+              ctx.addIssue(this.def.format.message ?? "Invalid date-time format", []);
+            }
+            break;
+          case "byte":
+            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(json) || json.length % 4 !== 0) {
+              ctx.addIssue(this.def.format.message ?? "Invalid base64 format", []);
+            }
+            break;
+          case "uri":
+            if (!STRING_FORMAT_REGEXES.uri.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid URI format", []);
+            }
+            break;
+          case "hostname":
+            if (!STRING_FORMAT_REGEXES.hostname.test(json)) {
+              ctx.addIssue(this.def.format.message ?? "Invalid hostname format", []);
+            }
+            break;
+          case "binary":
+            break;
+          case "password":
+            break;
+          default:
+            this.def.format.format;
+            break;
+        }
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KNumber = class _KNumber extends BaseSchema {
+  static create = () => new _KNumber({});
+  serialize(value) {
+    return value;
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const schema = {
+      ...baseSchema,
+      type: "number"
+    };
+    if (this.def.min !== void 0) {
+      schema.minimum = this.def.min.val;
+    }
+    if (this.def.max !== void 0) {
+      schema.maximum = this.def.max.val;
+    }
+    if (this.def.multipleOf !== void 0) {
+      schema.multipleOf = this.def.multipleOf.val;
+    }
+    if (this.def.integer) {
+      schema.type = "integer";
+    }
+    if (this.def.format) {
+      switch (this.def.format.format) {
+        case "float":
+          schema.format = "float";
+          schema.type = "number";
+          break;
+        case "double":
+          schema.format = "double";
+          schema.type = "number";
+          break;
+        case "int32":
+          schema.format = "int32";
+          schema.type = "integer";
+          break;
+        case "int64":
+          schema.format = "int64";
+          schema.type = "integer";
+          break;
+      }
+    }
+    if (this.def.format) {
+      schema.format = this.def.format.format;
+    }
+    return schema;
+  }
+  min(min) {
+    return this.setCheck({ type: "min", val: min });
+  }
+  max(max) {
+    return this.setCheck({ type: "max", val: max });
+  }
+  integer() {
+    return this.setCheck({ type: "integer" });
+  }
+  multipleOf(multipleOf) {
+    if (multipleOf <= 0) {
+      throw new Error("multipleOf must be a positive number");
+    }
+    return this.setCheck({ type: "multipleOf", val: multipleOf });
+  }
+  float() {
+    return this.setCheck({ type: "format", format: "float" });
+  }
+  double() {
+    return this.setCheck({ type: "format", format: "double" });
+  }
+  int32() {
+    return this.setCheck({ type: "format", format: "int32" }).integer();
+  }
+  int64() {
+    return this.setCheck({ type: "format", format: "int64" }).integer();
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "number") {
+        return ctx.addIssue("Expected number", []);
+      }
+      if (this.def.integer && !Number.isInteger(json)) {
+        ctx.addIssue(this.def.integer.message ?? "Expected integer", []);
+      }
+      if (this.def.min !== void 0 && json < this.def.min.val) {
+        ctx.addIssue(this.def.min.message ?? `Number must be greater than or equal to ${this.def.min.val}`, []);
+      }
+      if (this.def.max !== void 0 && json > this.def.max.val) {
+        ctx.addIssue(this.def.max.message ?? `Number must be less than or equal to ${this.def.max.val}`, []);
+      }
+      if (this.def.multipleOf !== void 0 && json % this.def.multipleOf.val !== 0) {
+        ctx.addIssue(this.def.multipleOf.message ?? `Number must be multiple of ${this.def.multipleOf.val}`, []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KBoolean = class _KBoolean extends BaseSchema {
+  static create = () => new _KBoolean({});
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "boolean"
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "boolean") {
+        return ctx.addIssue("Expected boolean", []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KArray = class _KArray extends BaseSchema {
+  static create = (items) => new _KArray({ items });
+  serialize(value) {
+    return value.map((item) => this.def.items.serialize(item));
+  }
+  setCheck(check) {
+    return this.clone({ [check.type]: check });
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "array",
+      items: this.def.items.toOpenAPI(),
+      ...this.def.minItems !== void 0 ? { minItems: this.def.minItems.val } : {},
+      ...this.def.maxItems !== void 0 ? { maxItems: this.def.maxItems.val } : {},
+      ...this.def.uniqueItems !== void 0 ? { uniqueItems: this.def.uniqueItems.val } : {}
+    };
+  }
+  min(minItems) {
+    return this.setCheck({ type: "minItems", val: minItems });
+  }
+  max(maxItems) {
+    return this.setCheck({ type: "maxItems", val: maxItems });
+  }
+  unique() {
+    return this.setCheck({ type: "uniqueItems", val: true });
+  }
+  notUnique() {
+    return this.setCheck({ type: "uniqueItems", val: false });
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (!Array.isArray(json)) {
+        return ctx.addIssue("Expected array", []);
+      }
+      if (this.def.minItems !== void 0 && json.length < this.def.minItems.val) {
+        ctx.addIssue(this.def.minItems.message ?? `Array must have at least ${this.def.minItems.val} items`, []);
+      }
+      if (this.def.maxItems !== void 0 && json.length > this.def.maxItems.val) {
+        ctx.addIssue(this.def.maxItems.message ?? `Array must have at most ${this.def.maxItems.val} items`, []);
+      }
+      if (this.def.uniqueItems?.val === true && new Set(json).size !== json.length) {
+        ctx.addIssue(this.def.uniqueItems.message ?? "Array items must be unique", []);
+      }
+      const items = [];
+      for (let i = 0; i < json.length; i++) {
+        const item = json[i];
+        const result = this.def.items.parseSafe(item);
+        if (!result.success) {
+          ctx.addIssues(result.issues, [i.toString()]);
+        } else {
+          items.push(result.result);
+        }
+      }
+      return items;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    const child = this.def.items;
+    visitor(child);
+    child.visit(visitor);
+  }
+};
+var KNull = class _KNull extends BaseSchema {
+  static create = () => new _KNull({});
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "null"
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (json !== null) {
+        return ctx.addIssue("Expected null", []);
+      }
+      return null;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KObject = class _KObject extends BaseSchema {
+  static create = (shape) => new _KObject({ shape });
+  serialize(value) {
+    const result = {};
+    for (const key in this.def.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+        const fieldValue = value[key];
+        if (fieldValue === void 0) {
+          throw new Error(`Missing required property: ${key}`);
+        }
+        result[key] = this.def.shape[key].serialize(fieldValue);
+      }
+    }
+    return result;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "object",
+      properties: Object.fromEntries(
+        Object.entries(this.def.shape).map((entry) => {
+          const [key, value] = entry;
+          return [key, value.toOpenAPI()];
+        })
+      ),
+      required: Object.keys(this.def.shape)
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue(`Expected object, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json[key];
+          if (value === void 0) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  get shape() {
+    return this.def.shape;
+  }
+  visit(visitor) {
+    for (const child of Object.values(this.def.shape)) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+};
+var KObjectFromURLSearchParams = class _KObjectFromURLSearchParams extends KObject {
+  static create = (shape) => new _KObjectFromURLSearchParams({ shape });
+  serialize(value) {
+    return super.serialize(value);
+  }
+  toOpenAPI() {
+    return super.toOpenAPI();
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (!(json instanceof URLSearchParams)) {
+        return ctx.addIssue(`Expected URLSearchParams, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json.get(key);
+          if (value === null) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+};
+var KRef = class _KRef extends BaseSchema {
+  static create = (name, shape) => new _KRef({ name, shape });
+  serialize(value) {
+    const result = {};
+    for (const key in this.def.shape) {
+      if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+        const fieldValue = value[key];
+        if (fieldValue === void 0) {
+          throw new Error(`Missing required property: ${key}`);
+        }
+        result[key] = this.def.shape[key].serialize(fieldValue);
+      }
+    }
+    return result;
+  }
+  visit(visitor) {
+    for (const child of Object.values(this.def.shape)) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+  example() {
+    throw new Error("Cannot set an example on a KRef");
+  }
+  toOpenAPI() {
+    return {
+      $ref: `#/components/schemas/${this.def.name}`,
+      ...this.def.description ? { description: this.def.description } : {},
+      ...this.def.summary ? { summary: this.def.summary } : {}
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue(`Expected object, got ${typeof json}`, []);
+      }
+      const result = {};
+      for (const key in this.def.shape) {
+        if (Object.prototype.hasOwnProperty.call(this.def.shape, key)) {
+          const value = json[key];
+          if (value === void 0) {
+            return ctx.addIssue(`Missing required property: ${key}`, [key]);
+          }
+          const parseResult = this.def.shape[key].parseSafe(value);
+          if (!parseResult.success) {
+            return ctx.addIssues(parseResult.issues, [key]);
+          }
+          result[key] = parseResult.result;
+        }
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  summary(summary) {
+    if (summary === void 0) {
+      return this.def.summary;
+    }
+    return this.clone({ summary });
+  }
+  get shape() {
+    return this.def.shape;
+  }
+  get name() {
+    return this.def.name;
+  }
+};
+var KScalar = class _KScalar extends BaseSchema {
+  static create = (options) => new _KScalar(options);
+  constructor(def) {
+    super({
+      ...def,
+      example: def.schema.example(),
+      description: def.schema.description()
+    });
+  }
+  serialize(value) {
+    return this.def.toClient(value);
+  }
+  toOpenAPI() {
+    return {
+      ...this.def.schema.toOpenAPI(),
+      ...this.def.description ? { description: this.def.description } : {},
+      ...this.def.example ? { example: this.def.example } : {}
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      const jsonValue = this.def.schema.parseSafe(json);
+      if (!jsonValue.success) {
+        return ctx.addIssues(jsonValue.issues, []);
+      }
+      try {
+        return this.def.toServer(jsonValue.result);
+      } catch (error) {
+        return ctx.addIssue(error instanceof Error ? error.message : "Conversion failed", []);
+      }
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    const child = this.def.schema;
+    visitor(child);
+    child.visit(visitor);
+  }
+};
+var KUnion = class _KUnion extends BaseSchema {
+  static create = (items) => new _KUnion({ items });
+  static enum = (values) => k.union(values.map((v) => k.literal(v)));
+  serialize(value) {
+    for (const option of this.def.items) {
+      try {
+        return option.serialize(value);
+      } catch {
+      }
+    }
+    throw new Error("Value does not match any union option for serialization");
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      oneOf: this.def.items.map((option) => option.toOpenAPI())
+    };
+  }
+  parseSafe(json) {
+    let lastIssues;
+    for (const option of this.def.items) {
+      const result = option.parseSafe(json);
+      if (result.success) {
+        return { success: true, result: result.result };
+      } else {
+        lastIssues = result.issues;
+      }
+    }
+    return { success: false, issues: lastIssues ?? /* @__PURE__ */ new Set([{ message: "No union option matched", path: [] }]) };
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    for (const child of this.def.items) {
+      visitor(child);
+      child.visit(visitor);
+    }
+  }
+};
+var KLiteral = class _KLiteral extends BaseSchema {
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  static create = (value) => new _KLiteral({ value });
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const type = typeof this.def.value;
+    return {
+      ...baseSchema,
+      type,
+      enum: [this.def.value]
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (json !== this.def.value) {
+        return ctx.addIssue(`Expected ${this.def.value}`, []);
+      }
+      return this.def.value;
+    });
+  }
+  visit() {
+  }
+};
+var KNativeEnum = class _KNativeEnum extends BaseSchema {
+  static create = (enumObject) => new _KNativeEnum({ enum: enumObject });
+  serialize(value) {
+    return value;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    const actualValues = Object.keys(this.def.enum).filter((key) => Number.isNaN(Number(key))).map((key) => this.def.enum[key]);
+    const uniqueValues = [...new Set(actualValues)];
+    const type = typeof uniqueValues[0] === "number" ? "number" : "string";
+    return {
+      ...baseSchema,
+      type,
+      enum: uniqueValues
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      const actualValues = Object.keys(this.def.enum).filter((key) => Number.isNaN(Number(key))).map((key) => this.def.enum[key]);
+      if (!actualValues.includes(json)) {
+        return ctx.addIssue(`Expected one of: ${actualValues.join(", ")}`, []);
+      }
+      return json;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit() {
+  }
+};
+var KRecord = class _KRecord extends BaseSchema {
+  static create = (keys, values) => new _KRecord({ keys, values });
+  serialize(value) {
+    const result = {};
+    for (const key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      const keySerialize = this.def.keys.serialize(key);
+      const valueSerialize = this.def.values.serialize(value[key]);
+      result[keySerialize] = valueSerialize;
+    }
+    return result;
+  }
+  toOpenAPI() {
+    const baseSchema = this.getSchemaObject();
+    return {
+      ...baseSchema,
+      type: "object",
+      propertyNames: this.def.keys.toOpenAPI(),
+      additionalProperties: this.def.values.toOpenAPI()
+    };
+  }
+  parseSafe(json) {
+    return ParseContext.result((ctx) => {
+      if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        return ctx.addIssue("Expected object", []);
+      }
+      const result = {};
+      for (const key in json) {
+        if (!Object.prototype.hasOwnProperty.call(json, key)) continue;
+        const keyParse = this.def.keys.parseSafe(key);
+        if (!keyParse.success) {
+          return ctx.addIssues(keyParse.issues, [key]);
+        }
+        const value = json[keyParse.result];
+        const valueParse = this.def.values.parseSafe(value);
+        if (!valueParse.success) {
+          return ctx.addIssues(valueParse.issues, [key]);
+        }
+        result[keyParse.result] = valueParse.result;
+      }
+      return result;
+    });
+  }
+  parse(json) {
+    const result = this.parseSafe(json);
+    if (!result.success) {
+      throw new SchemaError(result.issues);
+    }
+    return result.result;
+  }
+  visit(visitor) {
+    visitor(this.def.keys);
+    visitor(this.def.values);
+  }
+};
+var KLazy = class _KLazy extends BaseSchema {
+  schema;
+  static create = (getter) => new _KLazy({ getter });
+  getSchema() {
+    if (!this.schema) {
+      this.schema = this.def.getter();
+    }
+    return this.schema;
+  }
+  serialize(value) {
+    return this.getSchema().serialize(value);
+  }
+  toOpenAPI() {
+    return this.getSchema().toOpenAPI();
+  }
+  parseSafe(json) {
+    return this.getSchema().parseSafe(json);
+  }
+  parse(json) {
+    return this.getSchema().parse(json);
+  }
+  visit(visitor) {
+    const schema = this.getSchema();
+    visitor(schema);
+    schema.visit(visitor);
+  }
+};
+var k = {
+  string: KString.create,
+  number: KNumber.create,
+  boolean: KBoolean.create,
+  array: KArray.create,
+  null: KNull.create,
+  ref: KRef.create,
+  record: KRecord.create,
+  object: KObject.create,
+  scalar: KScalar.create,
+  literal: KLiteral.create,
+  enum: KUnion.enum,
+  nativeEnum: KNativeEnum.create,
+  union: KUnion.create,
+  lazy: KLazy.create,
+  /**
+   * Schema for any valid JSON value
+   */
+  json: () => {
+    const jsonSchema = k.lazy(
+      () => k.union([k.string(), k.number(), k.boolean(), k.null(), k.array(jsonSchema), k.record(k.string(), jsonSchema)])
+    );
+    return jsonSchema;
+  },
+  /**
+   * @internal
+   * @experimental
+   */
+  objectFromURLSearchParams: KObjectFromURLSearchParams.create
+};
+
+export {
+  isPrimitiveJSONValue,
+  SchemaError,
+  ParseContext,
+  BaseSchema,
+  STRING_FORMAT_REGEXES,
+  KString,
+  KNumber,
+  KBoolean,
+  KArray,
+  KNull,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRef,
+  KScalar,
+  KUnion,
+  KLiteral,
+  KNativeEnum,
+  KRecord,
+  KLazy,
+  k
+};