@forklaunch/validator 0.4.12 → 0.5.0

package/lib/__test__/utils/mockSchemaValidator.d.mts

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-LkSEBFTv.mjs';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-BL6n8u4w.mjs';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';
@@ -13,11 +13,26 @@ declare module '@forklaunch/validator' {
         Mock: T;
     }
 }
+/**
+ * Creates a union type string from an array of string literals.
+ *
+ * @template T - Array of string literals
+ * @example
+ * type Result = RecursiveUnion<['a', 'b', 'c']>; // 'a | b | c'
+ */
 type RecursiveUnion<T extends readonly string[]> = T extends readonly [
     infer F extends string,
     ...infer R extends readonly string[]
 ] ? R extends [] ? F : `${F} | ${RecursiveUnion<R>}` : '';
-declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
+type SerializeStringArray<T extends string[]> = T extends [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends [] ? F : `${F}, ${SerializeStringArray<R>}` : '';
+/**
+ * A mock implementation of SchemaValidator for testing purposes.
+ * This validator represents schemas as strings and provides simple string-based operations.
+ */
+declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
     _Type: "Mock";
     _SchemaCatchall: string;
     _ValidSchemaObject: string;
@@ -34,16 +49,106 @@ declare class MockSchemaValidator implements SchemaValidator<(<T extends string>
     any: string;
     unknown: string;
     never: string;
+    /**
+     * Compiles a schema string.
+     *
+     * @param {T} schema - The schema string to compile
+     * @returns {T} The same schema string
+     */
     compile<T extends string>(schema: T): T;
+    /**
+     * Converts a schema string to its schemified form.
+     *
+     * @param {T} schema - The schema string to schemify
+     * @returns {T} The same schema string
+     */
     schemify<T extends string>(schema: T): T;
+    /**
+     * Makes a schema string optional.
+     *
+     * @param {T} schema - The schema string to make optional
+     * @returns {`optional ${T}`} The schema string prefixed with 'optional'
+     */
     optional<T extends string>(schema: T): `optional ${T}`;
+    /**
+     * Creates an array schema string.
+     *
+     * @param {T} schema - The schema string to convert to an array
+     * @returns {`array ${T}`} The schema string prefixed with 'array'
+     */
     array<T extends string>(schema: T): `array ${T}`;
+    /**
+     * Creates a union schema string from multiple schema strings.
+     *
+     * @param {T} schemas - Array of schema strings to union
+     * @returns {RecursiveUnion<T>} The schema strings joined with ' | '
+     */
     union<T extends readonly string[]>(schemas: T): RecursiveUnion<T>;
+    /**
+     * Creates a literal schema string.
+     *
+     * @param {T} schema - The literal value
+     * @returns {`literal ${T}`} The schema string prefixed with 'literal'
+     */
     literal<T extends LiteralSchema>(schema: T): `literal ${T}`;
+    /**
+     * Creates an enum schema string.
+     *
+     * @param {Record<string, T>} schemaEnum - The enum values
+     * @returns {`enum ${T}`} The schema string prefixed with 'enum'
+     */
     enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): `enum ${T}`;
+    /**
+     * Creates a function schema string.
+     *
+     * @param {Args} args - The arguments of the function
+     * @param {ReturnType} returnType - The return type of the function
+     * @returns {`function(${SerializeStringArray<Args>}) => ${ReturnType}`} The schema string prefixed with 'function'
+     */
+    function_<Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType): `function(${SerializeStringArray<Args>}) => ${ReturnType}`;
+    /**
+     * Creates a record schema string.
+     *
+     * @param {Key} key - The key schema string
+     * @param {Value} value - The value schema string
+     * @returns {`{${Key}: ${Value}}`} The schema string prefixed with 'record'
+     */
+    record<Key extends string, Value extends string>(key: Key, value: Value): `{${Key}: ${Value}}`;
+    /**
+     * Creates a promise schema string.
+     *
+     * @param {T} schema - The schema string to convert to a promise
+     * @returns {`Promise<${T}>`} The schema string prefixed with 'Promise'
+     */
+    promise<T extends string>(schema: T): `Promise<${T}>`;
+    /**
+     * Checks if a value is a schema string.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is a string
+     */
     isSchema(value: unknown): value is string;
+    /**
+     * Validates a value against a schema string.
+     *
+     * @param {T} schema - The schema string to validate against
+     * @param {string} value - The value to validate
+     * @returns {boolean} True if the schema and value strings match
+     */
     validate<T extends string>(schema: T, value: string): boolean;
+    /**
+     * Parses a value against a schema string.
+     *
+     * @param {T} schema - The schema string to parse against
+     * @param {string} value - The value to parse
+     * @returns {ParseResult<T>} Success if the schema and value strings match, error otherwise
+     */
     parse<T extends string>(schema: T, value: string): ParseResult<T>;
+    /**
+     * Generates a mock OpenAPI schema object.
+     *
+     * @returns {SchemaObject} A simple string type schema object
+     */
     openapi(): SchemaObject;
 }
 declare const mockSchemaValidator: MockSchemaValidator;
@@ -63,7 +168,10 @@ declare const array: <T extends string>(schema: T) => `array ${T}`;
 declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
 declare const literal: <T extends LiteralSchema>(schema: T) => `literal ${T}`;
 declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`;
+declare const function_: <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`;
+declare const record: <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`;
+declare const promise: <T extends string>(schema: T) => `Promise<${T}>`;
 declare const validate: <T extends string>(schema: T, value: string) => boolean;
 declare const openapi: () => SchemaObject;
 
-export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, schemify, string, symbol, union, unknown, validate };
+export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, function_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, promise, record, schemify, string, symbol, union, unknown, validate };

package/lib/__test__/utils/mockSchemaValidator.d.ts

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-LkSEBFTv.js';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-BL6n8u4w.js';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';
@@ -13,11 +13,26 @@ declare module '@forklaunch/validator' {
         Mock: T;
     }
 }
+/**
+ * Creates a union type string from an array of string literals.
+ *
+ * @template T - Array of string literals
+ * @example
+ * type Result = RecursiveUnion<['a', 'b', 'c']>; // 'a | b | c'
+ */
 type RecursiveUnion<T extends readonly string[]> = T extends readonly [
     infer F extends string,
     ...infer R extends readonly string[]
 ] ? R extends [] ? F : `${F} | ${RecursiveUnion<R>}` : '';
-declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
+type SerializeStringArray<T extends string[]> = T extends [
+    infer F extends string,
+    ...infer R extends string[]
+] ? R extends [] ? F : `${F}, ${SerializeStringArray<R>}` : '';
+/**
+ * A mock implementation of SchemaValidator for testing purposes.
+ * This validator represents schemas as strings and provides simple string-based operations.
+ */
+declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
     _Type: "Mock";
     _SchemaCatchall: string;
     _ValidSchemaObject: string;
@@ -34,16 +49,106 @@ declare class MockSchemaValidator implements SchemaValidator<(<T extends string>
     any: string;
     unknown: string;
     never: string;
+    /**
+     * Compiles a schema string.
+     *
+     * @param {T} schema - The schema string to compile
+     * @returns {T} The same schema string
+     */
     compile<T extends string>(schema: T): T;
+    /**
+     * Converts a schema string to its schemified form.
+     *
+     * @param {T} schema - The schema string to schemify
+     * @returns {T} The same schema string
+     */
     schemify<T extends string>(schema: T): T;
+    /**
+     * Makes a schema string optional.
+     *
+     * @param {T} schema - The schema string to make optional
+     * @returns {`optional ${T}`} The schema string prefixed with 'optional'
+     */
     optional<T extends string>(schema: T): `optional ${T}`;
+    /**
+     * Creates an array schema string.
+     *
+     * @param {T} schema - The schema string to convert to an array
+     * @returns {`array ${T}`} The schema string prefixed with 'array'
+     */
     array<T extends string>(schema: T): `array ${T}`;
+    /**
+     * Creates a union schema string from multiple schema strings.
+     *
+     * @param {T} schemas - Array of schema strings to union
+     * @returns {RecursiveUnion<T>} The schema strings joined with ' | '
+     */
     union<T extends readonly string[]>(schemas: T): RecursiveUnion<T>;
+    /**
+     * Creates a literal schema string.
+     *
+     * @param {T} schema - The literal value
+     * @returns {`literal ${T}`} The schema string prefixed with 'literal'
+     */
     literal<T extends LiteralSchema>(schema: T): `literal ${T}`;
+    /**
+     * Creates an enum schema string.
+     *
+     * @param {Record<string, T>} schemaEnum - The enum values
+     * @returns {`enum ${T}`} The schema string prefixed with 'enum'
+     */
     enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): `enum ${T}`;
+    /**
+     * Creates a function schema string.
+     *
+     * @param {Args} args - The arguments of the function
+     * @param {ReturnType} returnType - The return type of the function
+     * @returns {`function(${SerializeStringArray<Args>}) => ${ReturnType}`} The schema string prefixed with 'function'
+     */
+    function_<Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType): `function(${SerializeStringArray<Args>}) => ${ReturnType}`;
+    /**
+     * Creates a record schema string.
+     *
+     * @param {Key} key - The key schema string
+     * @param {Value} value - The value schema string
+     * @returns {`{${Key}: ${Value}}`} The schema string prefixed with 'record'
+     */
+    record<Key extends string, Value extends string>(key: Key, value: Value): `{${Key}: ${Value}}`;
+    /**
+     * Creates a promise schema string.
+     *
+     * @param {T} schema - The schema string to convert to a promise
+     * @returns {`Promise<${T}>`} The schema string prefixed with 'Promise'
+     */
+    promise<T extends string>(schema: T): `Promise<${T}>`;
+    /**
+     * Checks if a value is a schema string.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is a string
+     */
     isSchema(value: unknown): value is string;
+    /**
+     * Validates a value against a schema string.
+     *
+     * @param {T} schema - The schema string to validate against
+     * @param {string} value - The value to validate
+     * @returns {boolean} True if the schema and value strings match
+     */
     validate<T extends string>(schema: T, value: string): boolean;
+    /**
+     * Parses a value against a schema string.
+     *
+     * @param {T} schema - The schema string to parse against
+     * @param {string} value - The value to parse
+     * @returns {ParseResult<T>} Success if the schema and value strings match, error otherwise
+     */
     parse<T extends string>(schema: T, value: string): ParseResult<T>;
+    /**
+     * Generates a mock OpenAPI schema object.
+     *
+     * @returns {SchemaObject} A simple string type schema object
+     */
     openapi(): SchemaObject;
 }
 declare const mockSchemaValidator: MockSchemaValidator;
@@ -63,7 +168,10 @@ declare const array: <T extends string>(schema: T) => `array ${T}`;
 declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
 declare const literal: <T extends LiteralSchema>(schema: T) => `literal ${T}`;
 declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`;
+declare const function_: <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`;
+declare const record: <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`;
+declare const promise: <T extends string>(schema: T) => `Promise<${T}>`;
 declare const validate: <T extends string>(schema: T, value: string) => boolean;
 declare const openapi: () => SchemaObject;
 
-export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, schemify, string, symbol, union, unknown, validate };
+export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, function_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, promise, record, schemify, string, symbol, union, unknown, validate };

package/lib/__test__/utils/mockSchemaValidator.js

@@ -27,6 +27,7 @@ __export(mockSchemaValidator_exports, {
   boolean: () => boolean,
   date: () => date,
   enum_: () => enum_,
+  function_: () => function_,
   literal: () => literal,
   mockSchemaValidator: () => mockSchemaValidator,
   never: () => never,
@@ -34,6 +35,8 @@ __export(mockSchemaValidator_exports, {
   number: () => number,
   openapi: () => openapi,
   optional: () => optional,
+  promise: () => promise,
+  record: () => record,
   schemify: () => schemify,
   string: () => string,
   symbol: () => symbol,
@@ -59,33 +62,124 @@ var MockSchemaValidator = class {
   any = "any";
   unknown = "unknown";
   never = "never";
+  /**
+   * Compiles a schema string.
+   *
+   * @param {T} schema - The schema string to compile
+   * @returns {T} The same schema string
+   */
   compile(schema) {
     return schema;
   }
+  /**
+   * Converts a schema string to its schemified form.
+   *
+   * @param {T} schema - The schema string to schemify
+   * @returns {T} The same schema string
+   */
   schemify(schema) {
     return schema;
   }
+  /**
+   * Makes a schema string optional.
+   *
+   * @param {T} schema - The schema string to make optional
+   * @returns {`optional ${T}`} The schema string prefixed with 'optional'
+   */
   optional(schema) {
     return `optional ${schema}`;
   }
+  /**
+   * Creates an array schema string.
+   *
+   * @param {T} schema - The schema string to convert to an array
+   * @returns {`array ${T}`} The schema string prefixed with 'array'
+   */
   array(schema) {
     return `array ${schema}`;
   }
+  /**
+   * Creates a union schema string from multiple schema strings.
+   *
+   * @param {T} schemas - Array of schema strings to union
+   * @returns {RecursiveUnion<T>} The schema strings joined with ' | '
+   */
   union(schemas) {
     return schemas.join(" | ");
   }
+  /**
+   * Creates a literal schema string.
+   *
+   * @param {T} schema - The literal value
+   * @returns {`literal ${T}`} The schema string prefixed with 'literal'
+   */
   literal(schema) {
     return `literal ${schema}`;
   }
+  /**
+   * Creates an enum schema string.
+   *
+   * @param {Record<string, T>} schemaEnum - The enum values
+   * @returns {`enum ${T}`} The schema string prefixed with 'enum'
+   */
   enum_(schemaEnum) {
     return `enum ${Object.values(schemaEnum).join(" | ")}`;
   }
+  /**
+   * Creates a function schema string.
+   *
+   * @param {Args} args - The arguments of the function
+   * @param {ReturnType} returnType - The return type of the function
+   * @returns {`function(${SerializeStringArray<Args>}) => ${ReturnType}`} The schema string prefixed with 'function'
+   */
+  function_(args, returnType) {
+    return `function(${args.join(", ")}) => ${returnType}`;
+  }
+  /**
+   * Creates a record schema string.
+   *
+   * @param {Key} key - The key schema string
+   * @param {Value} value - The value schema string
+   * @returns {`{${Key}: ${Value}}`} The schema string prefixed with 'record'
+   */
+  record(key, value) {
+    return `{${key}: ${value}}`;
+  }
+  /**
+   * Creates a promise schema string.
+   *
+   * @param {T} schema - The schema string to convert to a promise
+   * @returns {`Promise<${T}>`} The schema string prefixed with 'Promise'
+   */
+  promise(schema) {
+    return `Promise<${schema}>`;
+  }
+  /**
+   * Checks if a value is a schema string.
+   *
+   * @param {unknown} value - The value to check
+   * @returns {boolean} True if the value is a string
+   */
   isSchema(value) {
     return typeof value === "string";
   }
+  /**
+   * Validates a value against a schema string.
+   *
+   * @param {T} schema - The schema string to validate against
+   * @param {string} value - The value to validate
+   * @returns {boolean} True if the schema and value strings match
+   */
   validate(schema, value) {
     return schema === value;
   }
+  /**
+   * Parses a value against a schema string.
+   *
+   * @param {T} schema - The schema string to parse against
+   * @param {string} value - The value to parse
+   * @returns {ParseResult<T>} Success if the schema and value strings match, error otherwise
+   */
   parse(schema, value) {
     return JSON.stringify(schema) === JSON.stringify(value) ? {
       ok: true,
@@ -95,6 +189,11 @@ var MockSchemaValidator = class {
       errors: [{ path: [], message: "Some error" }]
     };
   }
+  /**
+   * Generates a mock OpenAPI schema object.
+   *
+   * @returns {SchemaObject} A simple string type schema object
+   */
   openapi() {
     return {
       type: "string"
@@ -118,6 +217,9 @@ var array = mockSchemaValidator.array.bind(mockSchemaValidator);
 var union = mockSchemaValidator.union.bind(mockSchemaValidator);
 var literal = mockSchemaValidator.literal.bind(mockSchemaValidator);
 var enum_ = mockSchemaValidator.enum_.bind(mockSchemaValidator);
+var function_ = mockSchemaValidator.function_.bind(mockSchemaValidator);
+var record = mockSchemaValidator.record.bind(mockSchemaValidator);
+var promise = mockSchemaValidator.promise.bind(mockSchemaValidator);
 var validate = mockSchemaValidator.validate.bind(mockSchemaValidator);
 var openapi = mockSchemaValidator.openapi.bind(mockSchemaValidator);
 // Annotate the CommonJS export names for ESM import in node:
@@ -129,6 +231,7 @@ var openapi = mockSchemaValidator.openapi.bind(mockSchemaValidator);
   boolean,
   date,
   enum_,
+  function_,
   literal,
   mockSchemaValidator,
   never,
@@ -136,6 +239,8 @@ var openapi = mockSchemaValidator.openapi.bind(mockSchemaValidator);
   number,
   openapi,
   optional,
+  promise,
+  record,
   schemify,
   string,
   symbol,

package/lib/__test__/utils/mockSchemaValidator.mjs

@@ -16,33 +16,124 @@ var MockSchemaValidator = class {
   any = "any";
   unknown = "unknown";
   never = "never";
+  /**
+   * Compiles a schema string.
+   *
+   * @param {T} schema - The schema string to compile
+   * @returns {T} The same schema string
+   */
   compile(schema) {
     return schema;
   }
+  /**
+   * Converts a schema string to its schemified form.
+   *
+   * @param {T} schema - The schema string to schemify
+   * @returns {T} The same schema string
+   */
   schemify(schema) {
     return schema;
   }
+  /**
+   * Makes a schema string optional.
+   *
+   * @param {T} schema - The schema string to make optional
+   * @returns {`optional ${T}`} The schema string prefixed with 'optional'
+   */
   optional(schema) {
     return `optional ${schema}`;
   }
+  /**
+   * Creates an array schema string.
+   *
+   * @param {T} schema - The schema string to convert to an array
+   * @returns {`array ${T}`} The schema string prefixed with 'array'
+   */
   array(schema) {
     return `array ${schema}`;
   }
+  /**
+   * Creates a union schema string from multiple schema strings.
+   *
+   * @param {T} schemas - Array of schema strings to union
+   * @returns {RecursiveUnion<T>} The schema strings joined with ' | '
+   */
   union(schemas) {
     return schemas.join(" | ");
   }
+  /**
+   * Creates a literal schema string.
+   *
+   * @param {T} schema - The literal value
+   * @returns {`literal ${T}`} The schema string prefixed with 'literal'
+   */
   literal(schema) {
     return `literal ${schema}`;
   }
+  /**
+   * Creates an enum schema string.
+   *
+   * @param {Record<string, T>} schemaEnum - The enum values
+   * @returns {`enum ${T}`} The schema string prefixed with 'enum'
+   */
   enum_(schemaEnum) {
     return `enum ${Object.values(schemaEnum).join(" | ")}`;
   }
+  /**
+   * Creates a function schema string.
+   *
+   * @param {Args} args - The arguments of the function
+   * @param {ReturnType} returnType - The return type of the function
+   * @returns {`function(${SerializeStringArray<Args>}) => ${ReturnType}`} The schema string prefixed with 'function'
+   */
+  function_(args, returnType) {
+    return `function(${args.join(", ")}) => ${returnType}`;
+  }
+  /**
+   * Creates a record schema string.
+   *
+   * @param {Key} key - The key schema string
+   * @param {Value} value - The value schema string
+   * @returns {`{${Key}: ${Value}}`} The schema string prefixed with 'record'
+   */
+  record(key, value) {
+    return `{${key}: ${value}}`;
+  }
+  /**
+   * Creates a promise schema string.
+   *
+   * @param {T} schema - The schema string to convert to a promise
+   * @returns {`Promise<${T}>`} The schema string prefixed with 'Promise'
+   */
+  promise(schema) {
+    return `Promise<${schema}>`;
+  }
+  /**
+   * Checks if a value is a schema string.
+   *
+   * @param {unknown} value - The value to check
+   * @returns {boolean} True if the value is a string
+   */
   isSchema(value) {
     return typeof value === "string";
   }
+  /**
+   * Validates a value against a schema string.
+   *
+   * @param {T} schema - The schema string to validate against
+   * @param {string} value - The value to validate
+   * @returns {boolean} True if the schema and value strings match
+   */
   validate(schema, value) {
     return schema === value;
   }
+  /**
+   * Parses a value against a schema string.
+   *
+   * @param {T} schema - The schema string to parse against
+   * @param {string} value - The value to parse
+   * @returns {ParseResult<T>} Success if the schema and value strings match, error otherwise
+   */
   parse(schema, value) {
     return JSON.stringify(schema) === JSON.stringify(value) ? {
       ok: true,
@@ -52,6 +143,11 @@ var MockSchemaValidator = class {
       errors: [{ path: [], message: "Some error" }]
     };
   }
+  /**
+   * Generates a mock OpenAPI schema object.
+   *
+   * @returns {SchemaObject} A simple string type schema object
+   */
   openapi() {
     return {
       type: "string"
@@ -75,6 +171,9 @@ var array = mockSchemaValidator.array.bind(mockSchemaValidator);
 var union = mockSchemaValidator.union.bind(mockSchemaValidator);
 var literal = mockSchemaValidator.literal.bind(mockSchemaValidator);
 var enum_ = mockSchemaValidator.enum_.bind(mockSchemaValidator);
+var function_ = mockSchemaValidator.function_.bind(mockSchemaValidator);
+var record = mockSchemaValidator.record.bind(mockSchemaValidator);
+var promise = mockSchemaValidator.promise.bind(mockSchemaValidator);
 var validate = mockSchemaValidator.validate.bind(mockSchemaValidator);
 var openapi = mockSchemaValidator.openapi.bind(mockSchemaValidator);
 export {
@@ -85,6 +184,7 @@ export {
   boolean,
   date,
   enum_,
+  function_,
   literal,
   mockSchemaValidator,
   never,
@@ -92,6 +192,8 @@ export {
   number,
   openapi,
   optional,
+  promise,
+  record,
   schemify,
   string,
   symbol,

package/lib/index.d.mts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-LkSEBFTv.mjs';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-LkSEBFTv.mjs';
+import { P as ParseError } from './schema.types-BL6n8u4w.mjs';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-BL6n8u4w.mjs';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-LkSEBFTv.js';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-LkSEBFTv.js';
+import { P as ParseError } from './schema.types-BL6n8u4w.js';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-BL6n8u4w.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';