@forklaunch/validator 0.3.13 → 0.4.1

package/lib/src/typebox/index.d.ts

@@ -1,3 +1,213 @@
-export * from './staticSchemaValidator';
-export type { TypeboxSchemaValidator } from './typeboxSchemaValidator';
-//# sourceMappingURL=index.d.ts.map
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { SchemaObject } from 'openapi3-ts/oas31';
+import * as _sinclair_typebox_compiler from '@sinclair/typebox/compiler';
+import { TypeCheck } from '@sinclair/typebox/compiler';
+import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, a as ParseResult } from '../../schema.types-Do9dhcdB.js';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema, TKind } from '@sinclair/typebox';
+import '@forklaunch/common';
+import 'zod';
+
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaValidator}
+ */
+declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => TUnion<UnionTResolve<T[]>>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => SchemaObject> {
+    _Type: 'TypeBox';
+    _SchemaCatchall: TKind;
+    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
+    string: _sinclair_typebox.TString;
+    uuid: _sinclair_typebox.TString;
+    uri: _sinclair_typebox.TString;
+    email: _sinclair_typebox.TString;
+    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
+    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
+    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean | undefined>;
+    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
+    symbol: _sinclair_typebox.TSymbol;
+    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+    any: _sinclair_typebox.TAny;
+    unknown: _sinclair_typebox.TUnknown;
+    never: _sinclair_typebox.TNever;
+    /**
+     * Extracts the error type of a schema for error messages.
+     *
+     * @param {TCatchall} schema - A schema that contains some type information.
+     * @returns The type of the schema for error messages.
+     */
+    private errorType;
+    /**
+     * Compiles schema if this exists, for optimal performance.
+     *
+     * @param {TObject<TProperties>} schema - The schema to compile.
+     * @returns {TypeCheck<T>} - The compiled schema.
+     */
+    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
+    /**
+     * Convert a schema to a TypeBox schema.
+     * @param {TIdiomaticSchema} schema - The schema to convert.
+     * @returns {TResolve<T>} The resolved schema.
+     */
+    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
+    /**
+     * Create an array schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {TArray<TResolve<T>>} The array schema.
+     */
+    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<T>>} The union schema.
+     *
+     * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
+     * This is a limitation of TypeBox. Consider using "optional" instead.
+     */
+    union<T extends TUnionContainer>(schemas: [...T]): TUnion<UnionTResolve<T>>;
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
+    /**
+     * Create an enum schema.
+     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+     */
+    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): TUnion<UnionTResolve<T[]>>;
+    /**
+     * Check if a value is a TypeBox object schema.
+     * @param {unknown} value - The value to check.
+     * @returns {boolean} True if the value is a TypeBox object schema.
+     */
+    isSchema(value: unknown): value is TSchema;
+    /**
+     * Validate a value against a schema.
+     *
+     * @param {TSchema} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {boolean} True if valid, otherwise false.
+     */
+    validate<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
+    /**
+     * Parse a value against a schema.
+     *
+     * @param {TSchema} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {ParseResult<TResolve<T>>} The parsing result.
+     */
+    parse<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi<T extends TIdiomaticSchema | TSchema>(schema: T): SchemaObject;
+}
+
+/**
+ * Factory function for creating a TypeboxSchemaValidator instance.
+ * @returns {TypeboxSchemaValidator} The TypeboxSchemaValidator instance.
+ */
+declare const SchemaValidator: () => TypeboxSchemaValidator;
+/**
+ * TypeBox schema definition for string type.
+ */
+declare const string: _sinclair_typebox.TString;
+/**
+ * TypeBox schema definition for UUID type.
+ */
+declare const uuid: _sinclair_typebox.TString;
+/**
+ * TypeBox schema definition for URI type.
+ */
+declare const uri: _sinclair_typebox.TString;
+/**
+ * TypeBox schema definition for email type.
+ */
+declare const email: _sinclair_typebox.TString;
+/**
+ * TypeBox schema definition for number type.
+ */
+declare const number: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
+/**
+ * TypeBox schema definition for bigint type.
+ */
+declare const bigint: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
+/**
+ * TypeBox schema definition for boolean type.
+ */
+declare const boolean: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean | undefined>;
+/**
+ * TypeBox schema definition for date type.
+ */
+declare const date: _sinclair_typebox.TTransform<_sinclair_typebox.TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
+/**
+ * TypeBox schema definition for symbol type.
+ */
+declare const symbol: _sinclair_typebox.TSymbol;
+/**
+ * TypeBox schema definition for undefined, null, void types.
+ */
+declare const nullish: _sinclair_typebox.TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+/**
+ * TypeBox schema definition for any type.
+ */
+declare const any: _sinclair_typebox.TAny;
+/**
+ * TypeBox schema definition for unknown type.
+ */
+declare const unknown: _sinclair_typebox.TUnknown;
+/**
+ * TypeBox schema definition for never type.
+ */
+declare const never: _sinclair_typebox.TNever;
+/**
+ * Transforms valid schema into TypeBox schema.
+ */
+declare const schemify: <T extends TIdiomaticSchema>(schema: T) => TResolve<T>;
+/**
+ * Makes a valid schema optional.
+ */
+declare const optional: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebox.TOptional<TResolve<T>>;
+/**
+ * Defines an array for a valid schema.
+ */
+declare const array: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebox.TArray<TResolve<T>>;
+/**
+ * Defines a union for a valid schema.
+ */
+declare const union: <T extends TUnionContainer>(schemas: [...T]) => _sinclair_typebox.TUnion<UnionTResolve<T>>;
+/**
+ * Defines a literal for a valid schema.
+ */
+declare const literal: <T extends LiteralSchema>(value: T) => _sinclair_typebox.TLiteral<T>;
+/**
+ * Defines an enum for a valid schema.
+ */
+declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => _sinclair_typebox.TUnion<UnionTResolve<T[]>>;
+/**
+ * Checks if a value is a TypeBox schema.
+ */
+declare const isSchema: (value: unknown) => value is _sinclair_typebox.TSchema;
+/**
+ * Validates a value against a valid schema.
+ */
+declare const validate: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
+/**
+ * Parses a value against a valid schema.
+ */
+declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+
+export { SchemaValidator, TypeboxSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/typebox/index.js

@@ -1 +1,435 @@
-export * from './staticSchemaValidator';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typebox/index.ts
+var typebox_exports = {};
+__export(typebox_exports, {
+  SchemaValidator: () => SchemaValidator,
+  any: () => any,
+  array: () => array,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  date: () => date,
+  email: () => email,
+  enum_: () => enum_,
+  isSchema: () => isSchema,
+  literal: () => literal,
+  never: () => never,
+  nullish: () => nullish,
+  number: () => number,
+  openapi: () => openapi,
+  optional: () => optional,
+  parse: () => parse,
+  schemify: () => schemify,
+  string: () => string,
+  symbol: () => symbol,
+  union: () => union,
+  unknown: () => unknown,
+  uri: () => uri,
+  uuid: () => uuid,
+  validate: () => validate
+});
+module.exports = __toCommonJS(typebox_exports);
+
+// src/typebox/typeboxSchemaValidator.ts
+var import_typebox = require("@sinclair/typebox");
+var import_compiler = require("@sinclair/typebox/compiler");
+var import_errors = require("@sinclair/typebox/errors");
+var import_value = require("@sinclair/typebox/value");
+(0, import_errors.SetErrorFunction)((params) => {
+  switch (params.errorType) {
+    case import_errors.ValueErrorType.Union:
+    case import_errors.ValueErrorType.Array:
+    case import_errors.ValueErrorType.String:
+    case import_errors.ValueErrorType.Number:
+      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : (0, import_errors.DefaultErrorFunction)(params);
+    default:
+      return (0, import_errors.DefaultErrorFunction)(params);
+  }
+});
+var TypeboxSchemaValidator = class {
+  _Type;
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = import_typebox.Type.String();
+  // uuid = Type.String({ format: 'uuid' });
+  uuid = import_typebox.Type.String({
+    pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
+    errorType: "uuid"
+  });
+  uri = import_typebox.Type.String({
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    errorType: "uri"
+  });
+  email = import_typebox.Type.String({
+    pattern: `(?:[a-z0-9!#$%&'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])`,
+    errorType: "email"
+  });
+  number = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null(),
+        import_typebox.Type.Date(),
+        import_typebox.Type.BigInt()
+      ],
+      {
+        errorType: "number-like",
+        openapiType: import_typebox.Type.Number()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value !== "number") {
+      const num = Number(value);
+      if (isNaN(num)) {
+        throw new Error("Invalid number");
+      } else {
+        return num;
+      }
+    }
+    return value;
+  }).Encode(Number);
+  bigint = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.BigInt(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Date()
+      ],
+      {
+        errorType: "BigInt-like",
+        openapiType: import_typebox.Type.BigInt()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value !== "bigint") {
+      try {
+        return BigInt(value instanceof Date ? value.getTime() : value);
+      } catch {
+        throw new Error("Invalid bigint");
+      }
+    }
+    return value;
+  }).Encode(BigInt);
+  boolean = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.String({
+          pattern: "^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$"
+        })
+      ],
+      {
+        errorType: "boolean-like",
+        openapiType: import_typebox.Type.Boolean()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value === "string") {
+      if (value.toLowerCase() === "true") return true;
+      if (value.toLowerCase() === "false") return false;
+    } else {
+      return value;
+    }
+  }).Encode(Boolean);
+  date = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Date(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({
+          pattern: "^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$"
+        }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null()
+      ],
+      {
+        errorType: "date",
+        openapiType: import_typebox.Type.Date()
+      }
+    )
+  ).Decode((value) => {
+    if (!(value instanceof Date)) {
+      if (value === null || typeof value === "boolean") {
+        return /* @__PURE__ */ new Date(value ? 1 : 0);
+      }
+      return new Date(value);
+    }
+    return value;
+  }).Encode((value) => new Date(value));
+  symbol = import_typebox.Type.Symbol();
+  nullish = import_typebox.Type.Union([import_typebox.Type.Void(), import_typebox.Type.Null(), import_typebox.Type.Undefined()], {
+    errorType: "nullish"
+  });
+  any = import_typebox.Type.Any();
+  unknown = import_typebox.Type.Unknown();
+  never = import_typebox.Type.Never();
+  /**
+   * Extracts the error type of a schema for error messages.
+   *
+   * @param {TCatchall} schema - A schema that contains some type information.
+   * @returns The type of the schema for error messages.
+   */
+  errorType(schema) {
+    if (Object.hasOwn(schema, "errorType")) {
+      return schema.errorType;
+    } else if (import_typebox.KindGuard.IsLiteral(schema)) {
+      return schema.const;
+    }
+    return schema[import_typebox.Kind].toLowerCase();
+  }
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {TObject<TProperties>} schema - The schema to compile.
+   * @returns {TypeCheck<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return import_compiler.TypeCompiler.Compile(schema);
+  }
+  /**
+   * Convert a schema to a TypeBox schema.
+   * @param {TIdiomaticSchema} schema - The schema to convert.
+   * @returns {TResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return import_typebox.Type.Literal(schema);
+    }
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (import_typebox.KindGuard.IsSchema(schema[key])) {
+        newSchema[key] = schema[key];
+      } else {
+        const schemified = this.schemify(schema[key]);
+        newSchema[key] = schemified;
+      }
+    });
+    return import_typebox.Type.Object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {TIdiomaticSchema} schema - The schema to make optional.
+   * @returns {TOptional<TResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return import_typebox.Type.Optional(schemified);
+  }
+  /**
+   * Create an array schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {TArray<TResolve<T>>} The array schema.
+   */
+  array(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return import_typebox.Type.Array(schemified, {
+      errorType: `array of ${this.errorType(schemified)}`
+    });
+  }
+  /**
+   * Create a union schema.
+   * @param {TUnionContainer} schemas - The schemas to union.
+   * @returns {TUnion<UnionTResolve<T>>} The union schema.
+   *
+   * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
+   * This is a limitation of TypeBox. Consider using "optional" instead.
+   */
+  union(schemas) {
+    const unionTypes = schemas.map((schema) => {
+      return import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    });
+    return import_typebox.Type.Union(unionTypes, {
+      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
+      errorSuffix: true
+    });
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {TLiteral<T>} The literal schema.
+   */
+  literal(value) {
+    return import_typebox.Type.Literal(value, {
+      errorType: value
+    });
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(Object.values(schemaEnum));
+  }
+  /**
+   * Check if a value is a TypeBox object schema.
+   * @param {unknown} value - The value to check.
+   * @returns {boolean} True if the value is a TypeBox object schema.
+   */
+  isSchema(value) {
+    return import_typebox.KindGuard.IsSchema(value);
+  }
+  /**
+   * Validate a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {boolean} True if valid, otherwise false.
+   */
+  validate(schema, value) {
+    if (schema instanceof import_compiler.TypeCheck) {
+      return schema.Check(value);
+    } else {
+      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      return import_value.Value.Check(schemified, value);
+    }
+  }
+  /**
+   * Parse a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {ParseResult<TResolve<T>>} The parsing result.
+   */
+  parse(schema, value) {
+    let errors = [];
+    let conversion;
+    if (schema instanceof import_compiler.TypeCheck) {
+      if (schema.Check(value)) {
+        conversion = schema.Decode(value);
+      } else {
+        errors = Array.from(schema.Errors(value));
+      }
+    } else {
+      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      if (import_value.Value.Check(schemified, value)) {
+        conversion = import_value.Value.Decode(schemified, value);
+      } else {
+        errors = Array.from(import_value.Value.Errors(schemified, value));
+      }
+    }
+    return errors != null && errors.length === 0 ? {
+      ok: true,
+      value: conversion
+    } : {
+      ok: false,
+      errors: errors.map((error) => ({
+        path: error.path.split("/").slice(1),
+        message: error.message
+      }))
+    };
+  }
+  /**
+   * Convert a schema to an OpenAPI schema object.
+   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    if (Object.hasOwn(schemified, "openapiType") || import_typebox.KindGuard.IsLiteral(schemified)) {
+      return schemified.openapiType;
+    }
+    const newSchema = Object.assign({}, schemified);
+    if (Object.hasOwn(newSchema, "properties")) {
+      newSchema.properties = { ...schemified.properties };
+      if (newSchema.properties) {
+        Object.entries(newSchema.properties).forEach(([key, value]) => {
+          if (import_typebox.KindGuard.IsSchema(value) && newSchema.properties) {
+            newSchema.properties[key] = this.openapi(value);
+          }
+        });
+      }
+    }
+    return newSchema;
+  }
+};
+
+// src/typebox/staticSchemaValidator.ts
+var SchemaValidator = () => new TypeboxSchemaValidator();
+var StaticSchemaValidator = SchemaValidator();
+var string = StaticSchemaValidator.string;
+var uuid = StaticSchemaValidator.uuid;
+var uri = StaticSchemaValidator.uri;
+var email = StaticSchemaValidator.email;
+var number = StaticSchemaValidator.number;
+var bigint = StaticSchemaValidator.bigint;
+var boolean = StaticSchemaValidator.boolean;
+var date = StaticSchemaValidator.date;
+var symbol = StaticSchemaValidator.symbol;
+var nullish = StaticSchemaValidator.nullish;
+var any = StaticSchemaValidator.any;
+var unknown = StaticSchemaValidator.unknown;
+var never = StaticSchemaValidator.never;
+var schemify = StaticSchemaValidator.schemify.bind(
+  StaticSchemaValidator
+);
+var optional = StaticSchemaValidator.optional.bind(
+  StaticSchemaValidator
+);
+var array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
+var union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
+var literal = StaticSchemaValidator.literal.bind(
+  StaticSchemaValidator
+);
+var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var isSchema = StaticSchemaValidator.isSchema.bind(
+  StaticSchemaValidator
+);
+var validate = StaticSchemaValidator.validate.bind(
+  StaticSchemaValidator
+);
+var parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
+var openapi = StaticSchemaValidator.openapi.bind(
+  StaticSchemaValidator
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaValidator,
+  any,
+  array,
+  bigint,
+  boolean,
+  date,
+  email,
+  enum_,
+  isSchema,
+  literal,
+  never,
+  nullish,
+  number,
+  openapi,
+  optional,
+  parse,
+  schemify,
+  string,
+  symbol,
+  union,
+  unknown,
+  uri,
+  uuid,
+  validate
+});