@arrirpc/schema 0.81.1 → 0.81.3

package/README.md

@@ -53,6 +53,7 @@ Originally this library was created as a way for building schemas for [Json Type
     - [Serialize](#serialize)
     - [Serialize Unsafe](#serialize-unsafe)
     - [Errors](#errors)
+    - [To JSON Schema](#to-json-schema)
 - [Metadata](#metadata)
 - [Compiled Validators](#compiled-validators)
 - [Benchmarks](#benchmarks)
@@ -989,6 +990,79 @@ a.errors(User, { id: 1, date: 'hello world' });
  */
 ```
 
+### To JSON Schema
+
+Use `a.toJsonSchema()` to convert an Arri schema to [JSON Schema](https://json-schema.org/) format. This is useful for:
+
+- **Editor support** - YAML/JSON files using Arri-defined schemas can get autocomplete in VS Code, IntelliJ, etc.
+- **Interoperability** - Integration with tools that consume JSON Schema (OpenAPI, documentation generators, etc.)
+- **Configuration validation** - Users defining config files can reference a JSON Schema URL for validation
+
+```ts
+const User = a.object(
+    {
+        id: a.string(),
+        name: a.string(),
+        email: a.nullable(a.string()),
+        role: a.enumerator(['USER', 'ADMIN']),
+        createdAt: a.timestamp(),
+    },
+    { id: 'User', description: 'A user in the system' },
+);
+
+const jsonSchema = a.toJsonSchema(User, {
+    $id: 'https://example.com/schemas/user.json',
+    title: 'User Schema',
+});
+```
+
+**Result:**
+
+```json
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://example.com/schemas/user.json",
+    "title": "User Schema",
+    "type": "object",
+    "properties": {
+        "id": { "type": "string" },
+        "name": { "type": "string" },
+        "email": { "type": ["string", "null"] },
+        "role": { "type": "string", "enum": ["USER", "ADMIN"] },
+        "createdAt": { "type": "string", "format": "date-time" }
+    },
+    "required": ["id", "name", "email", "role", "createdAt"]
+}
+```
+
+#### Options
+
+| Option        | Type   | Description                                                                             |
+| ------------- | ------ | --------------------------------------------------------------------------------------- |
+| `$id`         | string | The `$id` to use for the root schema                                                    |
+| `title`       | string | The title to use for the root schema                                                    |
+| `description` | string | The description to use for the root schema                                              |
+| `$schema`     | string | The JSON Schema draft version (default: `https://json-schema.org/draft/2020-12/schema`) |
+
+#### Type Mappings
+
+| Arri Schema         | JSON Schema Equivalent                                         |
+| ------------------- | -------------------------------------------------------------- |
+| `a.any()`           | `{}` (any)                                                     |
+| `a.string()`        | `{ "type": "string" }`                                         |
+| `a.boolean()`       | `{ "type": "boolean" }`                                        |
+| `a.timestamp()`     | `{ "type": "string", "format": "date-time" }`                  |
+| `a.float32/64()`    | `{ "type": "number" }`                                         |
+| `a.int8/16/32()`    | `{ "type": "integer", "minimum": X, "maximum": Y }`            |
+| `a.uint8/16/32()`   | `{ "type": "integer", "minimum": 0, "maximum": Y }`            |
+| `a.int64/uint64()`  | `{ "type": "string", "pattern": "^-?[0-9]+$" }`                |
+| `a.enumerator()`    | `{ "type": "string", "enum": [...] }`                          |
+| `a.array()`         | `{ "type": "array", "items": {...} }`                          |
+| `a.object()`        | `{ "type": "object", "properties": {...}, "required": [...] }` |
+| `a.record()`        | `{ "type": "object", "additionalProperties": {...} }`          |
+| `a.discriminator()` | `{ "oneOf": [...] }` with const discriminator                  |
+| `a.nullable()`      | Adds `"null"` to type array                                    |
+
 ## Metadata
 
 Metadata is used during cross-language code generation. Arri schemas allow you to specify the following metadata fields:

package/dist/adapters.d.cts

@@ -1,5 +1,5 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { m as ValidationContext, A as ASchema } from './shared/schema.CS4qvHhE.cjs';
+import { m as ValidationContext, A as ASchema } from './shared/schema.puFjotry.cjs';
 import '@arrirpc/type-defs';
 
 declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined, vendor?: string): StandardSchemaV1<T>['~standard'];

package/dist/adapters.d.mts

@@ -1,5 +1,5 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { m as ValidationContext, A as ASchema } from './shared/schema.CS4qvHhE.mjs';
+import { m as ValidationContext, A as ASchema } from './shared/schema.puFjotry.mjs';
 import '@arrirpc/type-defs';
 
 declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined, vendor?: string): StandardSchemaV1<T>['~standard'];

package/dist/adapters.d.ts

@@ -1,5 +1,5 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { m as ValidationContext, A as ASchema } from './shared/schema.CS4qvHhE.js';
+import { m as ValidationContext, A as ASchema } from './shared/schema.puFjotry.js';
 import '@arrirpc/type-defs';
 
 declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined, vendor?: string): StandardSchemaV1<T>['~standard'];

package/dist/index.cjs

@@ -2818,6 +2818,136 @@ function enumerator(paramA, paramB) {
   return result;
 }
 
+function toJsonSchema(schema, options) {
+  return applyRootOptions(
+    schemaToJsonSchema(schema),
+    options
+  );
+}
+function schemaToJsonSchema(schema) {
+  return convertSchema(schema);
+}
+function applyRootOptions(schema, options) {
+  return {
+    ...schema,
+    $schema: options?.$schema ?? "https://json-schema.org/draft/2020-12/schema",
+    ...options?.$id && { $id: options.$id },
+    ...options?.title && { title: options.title },
+    ...options?.description && { description: options.description }
+  };
+}
+const SCALAR_MAPPINGS = {
+  string: { type: "string" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  float32: { type: "number" },
+  float64: { type: "number" },
+  int8: { type: "integer", minimum: int8Min, maximum: int8Max },
+  uint8: { type: "integer", minimum: uint8Min, maximum: uint8Max },
+  int16: { type: "integer", minimum: int16Min, maximum: int16Max },
+  uint16: { type: "integer", minimum: uint16Min, maximum: uint16Max },
+  int32: { type: "integer", minimum: int32Min, maximum: int32Max },
+  uint32: { type: "integer", minimum: uint32Min, maximum: uint32Max },
+  int64: { type: "string", pattern: "^-?[0-9]+$" },
+  uint64: { type: "string", pattern: "^[0-9]+$" }
+};
+function convertSchema(schema) {
+  const base = getBaseSchema(schema);
+  return schema.isNullable ? makeNullable(base, schema) : applyMetadata(base, schema);
+}
+function getBaseSchema(schema) {
+  if (typeDefs.isSchemaFormType(schema)) {
+    const mapping = SCALAR_MAPPINGS[schema.type];
+    return mapping ? { ...mapping } : {};
+  }
+  if (typeDefs.isSchemaFormEnum(schema)) {
+    return {
+      type: "string",
+      enum: [...schema.enum]
+    };
+  }
+  if (typeDefs.isSchemaFormElements(schema)) {
+    return {
+      type: "array",
+      items: convertSchema(schema.elements)
+    };
+  }
+  if (typeDefs.isSchemaFormProperties(schema)) {
+    return convertObject(schema);
+  }
+  if (typeDefs.isSchemaFormValues(schema)) {
+    return {
+      type: "object",
+      additionalProperties: convertSchema(schema.values)
+    };
+  }
+  if (typeDefs.isSchemaFormDiscriminator(schema)) {
+    return convertDiscriminator(schema);
+  }
+  if (typeDefs.isSchemaFormRef(schema)) {
+    return { $ref: `#/$defs/${schema.ref}` };
+  }
+  if (typeDefs.isSchemaFormEmpty(schema)) return {};
+  return {};
+}
+function convertObject(schema) {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+    properties[key] = convertSchema(prop);
+    required.push(key);
+  }
+  for (const [key, prop] of Object.entries(schema.optionalProperties ?? {})) {
+    properties[key] = convertSchema(prop);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required },
+    ...schema.isStrict && { additionalProperties: false }
+  };
+}
+function convertDiscriminator(schema) {
+  const oneOf = Object.entries(schema.mapping).map(
+    ([value, mappingSchema]) => {
+      const variant = convertObject(mappingSchema);
+      variant.properties = {
+        ...variant.properties,
+        [schema.discriminator]: { type: "string", const: value }
+      };
+      variant.required = [
+        ...variant.required ?? [],
+        schema.discriminator
+      ];
+      return variant;
+    }
+  );
+  return { oneOf };
+}
+function makeNullable(jsonSchema, atdSchema) {
+  if (jsonSchema.$ref || jsonSchema.oneOf) {
+    return applyMetadata(
+      { anyOf: [jsonSchema, { type: "null" }] },
+      atdSchema
+    );
+  }
+  if (jsonSchema.type) {
+    const types = Array.isArray(jsonSchema.type) ? jsonSchema.type : [jsonSchema.type];
+    jsonSchema.type = types.includes("null") ? types : [...types, "null"];
+    return applyMetadata(jsonSchema, atdSchema);
+  }
+  return applyMetadata({ anyOf: [jsonSchema, { type: "null" }] }, atdSchema);
+}
+function applyMetadata(jsonSchema, { metadata }) {
+  if (!metadata) return jsonSchema;
+  return {
+    ...jsonSchema,
+    ...metadata.id && { title: metadata.id },
+    ...metadata.description && { description: metadata.description },
+    ...metadata.isDeprecated && { deprecated: true }
+  };
+}
+
 function nullable(schema, opts = {}) {
   const isType = (val) => {
     if (val === null) {
@@ -4279,11 +4409,13 @@ const _namespace = {
     pick: pick,
     record: record,
     recursive: recursive,
+    schemaToJsonSchema: schemaToJsonSchema,
     serialize: serialize,
     serializeUnsafe: serializeUnsafe,
     string: string,
     stringEnum: stringEnum,
     timestamp: timestamp,
+    toJsonSchema: toJsonSchema,
     uint16: uint16,
     uint32: uint32,
     uint64: uint64,
@@ -4353,6 +4485,7 @@ exports.pick = pick;
 exports.record = record;
 exports.recursive = recursive;
 exports.sanitizeJson = sanitizeJson;
+exports.schemaToJsonSchema = schemaToJsonSchema;
 exports.serialize = serialize;
 exports.serializeObject = serializeObject;
 exports.serializeSmallString = serializeSmallString;
@@ -4361,6 +4494,7 @@ exports.serializeUnsafe = serializeUnsafe;
 exports.string = string;
 exports.stringEnum = stringEnum;
 exports.timestamp = timestamp;
+exports.toJsonSchema = toJsonSchema;
 exports.uint16 = uint16;
 exports.uint16Max = uint16Max;
 exports.uint16Min = uint16Min;

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { Schema } from '@arrirpc/type-defs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.CS4qvHhE.cjs';
-export { G as AArraySchemaWithAdapters, K as ADiscriminatorSchema, O as ARecordSchema, _ as ARefSchemaWithAdapters, C as AScalarSchema, H as AStringEnumSchema, U as InferObjectOptionalKeys, X as InferObjectRawType, M as MaybeNullable, E as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as ResultFailure, v as ResultSuccess, y as SchemaMetadata, t as ValidationException, s as errorMessageFromErrors, F as isAAraySchema, L as isADiscriminatorSchema, T as isAObjectSchema, Q as isARecordSchema, Z as isARefSchema, D as isAScalarSchema, z as isASchema, J as isAStringEnumSchema, Y as isObject, u as isValidationException, r as isValueError, x as newValidationContext } from './shared/schema.CS4qvHhE.cjs';
+import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.puFjotry.cjs';
+export { r as AArraySchemaWithAdapters, s as ADiscriminatorSchema, t as ARecordSchema, u as ARefSchemaWithAdapters, v as AScalarSchema, w as AStringEnumSchema, x as InferObjectOptionalKeys, y as InferObjectRawType, M as MaybeNullable, N as NumberType, z as NumberTypeValues, P as PartialBy, B as Resolve, C as ResultFailure, D as ResultSuccess, E as SchemaMetadata, F as ValidationException, G as errorMessageFromErrors, H as isAAraySchema, J as isADiscriminatorSchema, K as isAObjectSchema, L as isARecordSchema, O as isARefSchema, Q as isAScalarSchema, T as isASchema, U as isAStringEnumSchema, X as isObject, Y as isValidationException, Z as isValueError, _ as newValidationContext } from './shared/schema.puFjotry.cjs';
 
 declare function createParsingTemplate(input: string, schema: Schema, shouldCoerce?: boolean): string;
 
@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { Schema } from '@arrirpc/type-defs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.CS4qvHhE.mjs';
-export { G as AArraySchemaWithAdapters, K as ADiscriminatorSchema, O as ARecordSchema, _ as ARefSchemaWithAdapters, C as AScalarSchema, H as AStringEnumSchema, U as InferObjectOptionalKeys, X as InferObjectRawType, M as MaybeNullable, E as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as ResultFailure, v as ResultSuccess, y as SchemaMetadata, t as ValidationException, s as errorMessageFromErrors, F as isAAraySchema, L as isADiscriminatorSchema, T as isAObjectSchema, Q as isARecordSchema, Z as isARefSchema, D as isAScalarSchema, z as isASchema, J as isAStringEnumSchema, Y as isObject, u as isValidationException, r as isValueError, x as newValidationContext } from './shared/schema.CS4qvHhE.mjs';
+import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.puFjotry.mjs';
+export { r as AArraySchemaWithAdapters, s as ADiscriminatorSchema, t as ARecordSchema, u as ARefSchemaWithAdapters, v as AScalarSchema, w as AStringEnumSchema, x as InferObjectOptionalKeys, y as InferObjectRawType, M as MaybeNullable, N as NumberType, z as NumberTypeValues, P as PartialBy, B as Resolve, C as ResultFailure, D as ResultSuccess, E as SchemaMetadata, F as ValidationException, G as errorMessageFromErrors, H as isAAraySchema, J as isADiscriminatorSchema, K as isAObjectSchema, L as isARecordSchema, O as isARefSchema, Q as isAScalarSchema, T as isASchema, U as isAStringEnumSchema, X as isObject, Y as isValidationException, Z as isValueError, _ as newValidationContext } from './shared/schema.puFjotry.mjs';
 
 declare function createParsingTemplate(input: string, schema: Schema, shouldCoerce?: boolean): string;
 
@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Schema } from '@arrirpc/type-defs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.CS4qvHhE.js';
-export { G as AArraySchemaWithAdapters, K as ADiscriminatorSchema, O as ARecordSchema, _ as ARefSchemaWithAdapters, C as AScalarSchema, H as AStringEnumSchema, U as InferObjectOptionalKeys, X as InferObjectRawType, M as MaybeNullable, E as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as ResultFailure, v as ResultSuccess, y as SchemaMetadata, t as ValidationException, s as errorMessageFromErrors, F as isAAraySchema, L as isADiscriminatorSchema, T as isAObjectSchema, Q as isARecordSchema, Z as isARefSchema, D as isAScalarSchema, z as isASchema, J as isAStringEnumSchema, Y as isObject, u as isValidationException, r as isValueError, x as newValidationContext } from './shared/schema.CS4qvHhE.js';
+import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, V as VALIDATOR_KEY, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaWithAdapters, k as AObjectSchemaOptions, l as InferObjectOutput, m as ValidationContext, n as ARecordSchemaWithAdapters, o as ARefSchema, p as ValueError, q as InferSubType } from './shared/schema.puFjotry.js';
+export { r as AArraySchemaWithAdapters, s as ADiscriminatorSchema, t as ARecordSchema, u as ARefSchemaWithAdapters, v as AScalarSchema, w as AStringEnumSchema, x as InferObjectOptionalKeys, y as InferObjectRawType, M as MaybeNullable, N as NumberType, z as NumberTypeValues, P as PartialBy, B as Resolve, C as ResultFailure, D as ResultSuccess, E as SchemaMetadata, F as ValidationException, G as errorMessageFromErrors, H as isAAraySchema, J as isADiscriminatorSchema, K as isAObjectSchema, L as isARecordSchema, O as isARefSchema, Q as isAScalarSchema, T as isASchema, U as isAStringEnumSchema, X as isObject, Y as isValidationException, Z as isValueError, _ as newValidationContext } from './shared/schema.puFjotry.js';
 
 declare function createParsingTemplate(input: string, schema: Schema, shouldCoerce?: boolean): string;
 
@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.mjs

@@ -2817,6 +2817,136 @@ function enumerator(paramA, paramB) {
   return result;
 }
 
+function toJsonSchema(schema, options) {
+  return applyRootOptions(
+    schemaToJsonSchema(schema),
+    options
+  );
+}
+function schemaToJsonSchema(schema) {
+  return convertSchema(schema);
+}
+function applyRootOptions(schema, options) {
+  return {
+    ...schema,
+    $schema: options?.$schema ?? "https://json-schema.org/draft/2020-12/schema",
+    ...options?.$id && { $id: options.$id },
+    ...options?.title && { title: options.title },
+    ...options?.description && { description: options.description }
+  };
+}
+const SCALAR_MAPPINGS = {
+  string: { type: "string" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  float32: { type: "number" },
+  float64: { type: "number" },
+  int8: { type: "integer", minimum: int8Min, maximum: int8Max },
+  uint8: { type: "integer", minimum: uint8Min, maximum: uint8Max },
+  int16: { type: "integer", minimum: int16Min, maximum: int16Max },
+  uint16: { type: "integer", minimum: uint16Min, maximum: uint16Max },
+  int32: { type: "integer", minimum: int32Min, maximum: int32Max },
+  uint32: { type: "integer", minimum: uint32Min, maximum: uint32Max },
+  int64: { type: "string", pattern: "^-?[0-9]+$" },
+  uint64: { type: "string", pattern: "^[0-9]+$" }
+};
+function convertSchema(schema) {
+  const base = getBaseSchema(schema);
+  return schema.isNullable ? makeNullable(base, schema) : applyMetadata(base, schema);
+}
+function getBaseSchema(schema) {
+  if (isSchemaFormType(schema)) {
+    const mapping = SCALAR_MAPPINGS[schema.type];
+    return mapping ? { ...mapping } : {};
+  }
+  if (isSchemaFormEnum(schema)) {
+    return {
+      type: "string",
+      enum: [...schema.enum]
+    };
+  }
+  if (isSchemaFormElements(schema)) {
+    return {
+      type: "array",
+      items: convertSchema(schema.elements)
+    };
+  }
+  if (isSchemaFormProperties(schema)) {
+    return convertObject(schema);
+  }
+  if (isSchemaFormValues(schema)) {
+    return {
+      type: "object",
+      additionalProperties: convertSchema(schema.values)
+    };
+  }
+  if (isSchemaFormDiscriminator(schema)) {
+    return convertDiscriminator(schema);
+  }
+  if (isSchemaFormRef(schema)) {
+    return { $ref: `#/$defs/${schema.ref}` };
+  }
+  if (isSchemaFormEmpty(schema)) return {};
+  return {};
+}
+function convertObject(schema) {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+    properties[key] = convertSchema(prop);
+    required.push(key);
+  }
+  for (const [key, prop] of Object.entries(schema.optionalProperties ?? {})) {
+    properties[key] = convertSchema(prop);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required },
+    ...schema.isStrict && { additionalProperties: false }
+  };
+}
+function convertDiscriminator(schema) {
+  const oneOf = Object.entries(schema.mapping).map(
+    ([value, mappingSchema]) => {
+      const variant = convertObject(mappingSchema);
+      variant.properties = {
+        ...variant.properties,
+        [schema.discriminator]: { type: "string", const: value }
+      };
+      variant.required = [
+        ...variant.required ?? [],
+        schema.discriminator
+      ];
+      return variant;
+    }
+  );
+  return { oneOf };
+}
+function makeNullable(jsonSchema, atdSchema) {
+  if (jsonSchema.$ref || jsonSchema.oneOf) {
+    return applyMetadata(
+      { anyOf: [jsonSchema, { type: "null" }] },
+      atdSchema
+    );
+  }
+  if (jsonSchema.type) {
+    const types = Array.isArray(jsonSchema.type) ? jsonSchema.type : [jsonSchema.type];
+    jsonSchema.type = types.includes("null") ? types : [...types, "null"];
+    return applyMetadata(jsonSchema, atdSchema);
+  }
+  return applyMetadata({ anyOf: [jsonSchema, { type: "null" }] }, atdSchema);
+}
+function applyMetadata(jsonSchema, { metadata }) {
+  if (!metadata) return jsonSchema;
+  return {
+    ...jsonSchema,
+    ...metadata.id && { title: metadata.id },
+    ...metadata.description && { description: metadata.description },
+    ...metadata.isDeprecated && { deprecated: true }
+  };
+}
+
 function nullable(schema, opts = {}) {
   const isType = (val) => {
     if (val === null) {
@@ -4278,11 +4408,13 @@ const _namespace = {
     pick: pick,
     record: record,
     recursive: recursive,
+    schemaToJsonSchema: schemaToJsonSchema,
     serialize: serialize,
     serializeUnsafe: serializeUnsafe,
     string: string,
     stringEnum: stringEnum,
     timestamp: timestamp,
+    toJsonSchema: toJsonSchema,
     uint16: uint16,
     uint32: uint32,
     uint64: uint64,
@@ -4291,4 +4423,4 @@ const _namespace = {
     validate: validate
 };
 
-export { STR_ESCAPE, VALIDATOR_KEY, ValidationException, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errorMessageFromErrors, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isObject, isValidationException, isValueError, newValidationContext, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export { STR_ESCAPE, VALIDATOR_KEY, ValidationException, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errorMessageFromErrors, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isObject, isValidationException, isValueError, newValidationContext, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };

package/dist/shared/{schema.CS4qvHhE.d.cts → schema.puFjotry.d.cts}

@@ -176,5 +176,5 @@ interface ARefSchema<T> extends ASchema<T> {
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 type ARefSchemaWithAdapters<T> = ARefSchema<T> & WithAdapters<T>;
 
-export { isAScalarSchema as D, isAAraySchema as F, isAStringEnumSchema as J, isADiscriminatorSchema as L, NumberTypeValues as N, isARecordSchema as Q, isAObjectSchema as T, VALIDATOR_KEY as V, isObject as Y, isARefSchema as Z, isValueError as r, errorMessageFromErrors as s, ValidationException as t, isValidationException as u, newValidationContext as x, isASchema as z };
-export type { ASchema as A, Resolve as B, AScalarSchema as C, NumberType as E, AArraySchemaWithAdapters as G, AStringEnumSchema as H, InferType as I, ADiscriminatorSchema as K, MaybeNullable as M, ARecordSchema as O, PartialBy as P, Result as R, SchemaValidator as S, InferObjectOptionalKeys as U, WithAdapters as W, InferObjectRawType as X, ARefSchemaWithAdapters as _, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, ResultSuccess as v, ResultFailure as w, SchemaMetadata as y };
+export { ValidationException as F, errorMessageFromErrors as G, isAAraySchema as H, isADiscriminatorSchema as J, isAObjectSchema as K, isARecordSchema as L, isARefSchema as O, isAScalarSchema as Q, isASchema as T, isAStringEnumSchema as U, VALIDATOR_KEY as V, isObject as X, isValidationException as Y, isValueError as Z, newValidationContext as _, NumberTypeValues as z };
+export type { ASchema as A, Resolve as B, ResultFailure as C, ResultSuccess as D, SchemaMetadata as E, InferType as I, MaybeNullable as M, NumberType as N, PartialBy as P, Result as R, SchemaValidator as S, WithAdapters as W, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, AArraySchemaWithAdapters as r, ADiscriminatorSchema as s, ARecordSchema as t, ARefSchemaWithAdapters as u, AScalarSchema as v, AStringEnumSchema as w, InferObjectOptionalKeys as x, InferObjectRawType as y };

package/dist/shared/{schema.CS4qvHhE.d.mts → schema.puFjotry.d.mts}

@@ -176,5 +176,5 @@ interface ARefSchema<T> extends ASchema<T> {
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 type ARefSchemaWithAdapters<T> = ARefSchema<T> & WithAdapters<T>;
 
-export { isAScalarSchema as D, isAAraySchema as F, isAStringEnumSchema as J, isADiscriminatorSchema as L, NumberTypeValues as N, isARecordSchema as Q, isAObjectSchema as T, VALIDATOR_KEY as V, isObject as Y, isARefSchema as Z, isValueError as r, errorMessageFromErrors as s, ValidationException as t, isValidationException as u, newValidationContext as x, isASchema as z };
-export type { ASchema as A, Resolve as B, AScalarSchema as C, NumberType as E, AArraySchemaWithAdapters as G, AStringEnumSchema as H, InferType as I, ADiscriminatorSchema as K, MaybeNullable as M, ARecordSchema as O, PartialBy as P, Result as R, SchemaValidator as S, InferObjectOptionalKeys as U, WithAdapters as W, InferObjectRawType as X, ARefSchemaWithAdapters as _, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, ResultSuccess as v, ResultFailure as w, SchemaMetadata as y };
+export { ValidationException as F, errorMessageFromErrors as G, isAAraySchema as H, isADiscriminatorSchema as J, isAObjectSchema as K, isARecordSchema as L, isARefSchema as O, isAScalarSchema as Q, isASchema as T, isAStringEnumSchema as U, VALIDATOR_KEY as V, isObject as X, isValidationException as Y, isValueError as Z, newValidationContext as _, NumberTypeValues as z };
+export type { ASchema as A, Resolve as B, ResultFailure as C, ResultSuccess as D, SchemaMetadata as E, InferType as I, MaybeNullable as M, NumberType as N, PartialBy as P, Result as R, SchemaValidator as S, WithAdapters as W, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, AArraySchemaWithAdapters as r, ADiscriminatorSchema as s, ARecordSchema as t, ARefSchemaWithAdapters as u, AScalarSchema as v, AStringEnumSchema as w, InferObjectOptionalKeys as x, InferObjectRawType as y };

package/dist/shared/{schema.CS4qvHhE.d.ts → schema.puFjotry.d.ts}

@@ -176,5 +176,5 @@ interface ARefSchema<T> extends ASchema<T> {
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 type ARefSchemaWithAdapters<T> = ARefSchema<T> & WithAdapters<T>;
 
-export { isAScalarSchema as D, isAAraySchema as F, isAStringEnumSchema as J, isADiscriminatorSchema as L, NumberTypeValues as N, isARecordSchema as Q, isAObjectSchema as T, VALIDATOR_KEY as V, isObject as Y, isARefSchema as Z, isValueError as r, errorMessageFromErrors as s, ValidationException as t, isValidationException as u, newValidationContext as x, isASchema as z };
-export type { ASchema as A, Resolve as B, AScalarSchema as C, NumberType as E, AArraySchemaWithAdapters as G, AStringEnumSchema as H, InferType as I, ADiscriminatorSchema as K, MaybeNullable as M, ARecordSchema as O, PartialBy as P, Result as R, SchemaValidator as S, InferObjectOptionalKeys as U, WithAdapters as W, InferObjectRawType as X, ARefSchemaWithAdapters as _, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, ResultSuccess as v, ResultFailure as w, SchemaMetadata as y };
+export { ValidationException as F, errorMessageFromErrors as G, isAAraySchema as H, isADiscriminatorSchema as J, isAObjectSchema as K, isARecordSchema as L, isARefSchema as O, isAScalarSchema as Q, isASchema as T, isAStringEnumSchema as U, VALIDATOR_KEY as V, isObject as X, isValidationException as Y, isValueError as Z, newValidationContext as _, NumberTypeValues as z };
+export type { ASchema as A, Resolve as B, ResultFailure as C, ResultSuccess as D, SchemaMetadata as E, InferType as I, MaybeNullable as M, NumberType as N, PartialBy as P, Result as R, SchemaValidator as S, WithAdapters as W, ASchemaStrict as a, ASchemaOptions as b, ASchemaWithAdapters as c, AArraySchema as d, AScalarSchemaWithAdapters as e, AObjectSchema as f, ADiscriminatorSchemaWithAdapters as g, ResolveObject as h, AStringEnumSchemaWithAdapters as i, AObjectSchemaWithAdapters as j, AObjectSchemaOptions as k, InferObjectOutput as l, ValidationContext as m, ARecordSchemaWithAdapters as n, ARefSchema as o, ValueError as p, InferSubType as q, AArraySchemaWithAdapters as r, ADiscriminatorSchema as s, ARecordSchema as t, ARefSchemaWithAdapters as u, AScalarSchema as v, AStringEnumSchema as w, InferObjectOptionalKeys as x, InferObjectRawType as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/schema",
-  "version": "0.81.1",
+  "version": "0.81.3",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -22,19 +22,19 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0",
+    "@standard-schema/spec": "1.1.0",
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "@arrirpc/type-defs": "0.81.1"
+    "@arrirpc/type-defs": "0.81.3"
   },
   "devDependencies": {
-    "@samchon/openapi": "^5.1.0",
-    "@sinclair/typebox": "^0.34.41",
+    "@samchon/openapi": "^6.0.1",
+    "@sinclair/typebox": "^0.34.48",
     "ajv": "^8.17.1",
-    "arktype": "^2.1.28",
+    "arktype": "^2.1.29",
     "benny": "^3.7.1",
-    "typia": "^10.1.0",
+    "typia": "^11.0.3",
     "valibot": "1.2.0",
-    "zod": "^4.1.13"
+    "zod": "^4.3.6"
   }
 }