@power-plant/schema 0.0.2

package/dist/constants-Cx9_Shfk.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants-Cx9_Shfk.d.cts","names":[],"sources":["../src/constants.ts"],"mappings":";cAoBa,4BAAA;AAAA,cAiBA,mBAAA;EAAA;;;;;;;;cAUA,2BAAA;AAAA,cAQA,iBAAA;AAAA,cAMA,yBAAA;;;;;cAoBA,sBAAA,EAAsB,GAAA;;AAlCnC;;;cA8Ca,sBAAA,EAAsB,GAAA;AAxCzB;AAEV;;;AAFU,cAyDG,4BAAA,EAA4B,GAAA"}

package/dist/constants-Cx9_Shfk.d.mts

@@ -0,0 +1,32 @@
+//#region src/constants.d.ts
+declare const VALID_SOURCE_FILE_EXTENSIONS: string[];
+declare const JsonSchemaTypeNames: {
+  readonly STRING: "string";
+  readonly NUMBER: "number";
+  readonly INTEGER: "integer";
+  readonly BOOLEAN: "boolean";
+  readonly NULL: "null";
+  readonly OBJECT: "object";
+  readonly ARRAY: "array";
+};
+declare const JSON_SCHEMA_PRIMITIVE_TYPES: readonly ["string", "number", "integer", "boolean", "null"];
+declare const JSON_SCHEMA_TYPES: readonly ["string", "number", "integer", "boolean", "null", "array", "object"];
+declare const JSON_SCHEMA_METADATA_KEYS: ("title" | "description" | "docs" | "examples" | "alias" | "tags" | "deprecated" | "hidden" | "ignore" | "internal" | "runtime" | "readOnly" | "writeOnly")[];
+/**
+ * Keywords whose values are a flat record of named JSON Schema fragments.
+ * Each child schema is merged recursively with its counterpart.
+ */
+declare const SCHEMA_RECORD_KEYWORDS: Set<string>;
+/**
+ * Keywords whose value is a single JSON Schema fragment that should be
+ * recursively merged when both sides define it.
+ */
+declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;
+/**
+ * Keywords whose values are arrays of JSON Schema fragments that should be
+ * concatenated (rather than overridden) during a merge.
+ */
+declare const SCHEMA_ARRAY_CONCAT_KEYWORDS: Set<string>;
+//#endregion
+export { SCHEMA_ARRAY_CONCAT_KEYWORDS as a, VALID_SOURCE_FILE_EXTENSIONS as c, JsonSchemaTypeNames as i, JSON_SCHEMA_PRIMITIVE_TYPES as n, SCHEMA_RECORD_KEYWORDS as o, JSON_SCHEMA_TYPES as r, SCHEMA_SINGLE_KEYWORDS as s, JSON_SCHEMA_METADATA_KEYS as t };
+//# sourceMappingURL=constants-Cx9_Shfk.d.mts.map

package/dist/constants-Cx9_Shfk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants-Cx9_Shfk.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":""}

package/dist/constants.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=[`ts`,`cts`,`mts`,`tsx`,`js`,`cjs`,`mjs`,`jsx`,`json`,`jsonc`,`json5`,`yaml`,`yml`,`toml`],t={STRING:`string`,NUMBER:`number`,INTEGER:`integer`,BOOLEAN:`boolean`,NULL:`null`,OBJECT:`object`,ARRAY:`array`},n=[t.STRING,t.NUMBER,t.INTEGER,t.BOOLEAN,t.NULL],r=[...n,t.ARRAY,t.OBJECT],i=[`docs`,`deprecated`,`title`,`description`,`examples`,`hidden`,`ignore`,`internal`,`runtime`,`readOnly`,`writeOnly`,`alias`,`tags`],a=new Set([`properties`,`patternProperties`,`$defs`,`definitions`,`dependentSchemas`]),o=new Set([`if`,`then`,`else`,`not`,`contains`,`items`,`additionalProperties`,`unevaluatedProperties`,`propertyNames`,`unevaluatedItems`]),s=new Set([`allOf`,`anyOf`,`oneOf`]);exports.JSON_SCHEMA_METADATA_KEYS=i,exports.JSON_SCHEMA_PRIMITIVE_TYPES=n,exports.JSON_SCHEMA_TYPES=r,exports.JsonSchemaTypeNames=t,exports.SCHEMA_ARRAY_CONCAT_KEYWORDS=s,exports.SCHEMA_RECORD_KEYWORDS=a,exports.SCHEMA_SINGLE_KEYWORDS=o,exports.VALID_SOURCE_FILE_EXTENSIONS=e;

package/dist/constants.d.cts

@@ -0,0 +1,2 @@
+import { a as SCHEMA_ARRAY_CONCAT_KEYWORDS, c as VALID_SOURCE_FILE_EXTENSIONS, i as JsonSchemaTypeNames, n as JSON_SCHEMA_PRIMITIVE_TYPES, o as SCHEMA_RECORD_KEYWORDS, r as JSON_SCHEMA_TYPES, s as SCHEMA_SINGLE_KEYWORDS, t as JSON_SCHEMA_METADATA_KEYS } from "./constants-Cx9_Shfk.cjs";
+export { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, VALID_SOURCE_FILE_EXTENSIONS };

package/dist/constants.d.mts

@@ -0,0 +1,2 @@
+import { a as SCHEMA_ARRAY_CONCAT_KEYWORDS, c as VALID_SOURCE_FILE_EXTENSIONS, i as JsonSchemaTypeNames, n as JSON_SCHEMA_PRIMITIVE_TYPES, o as SCHEMA_RECORD_KEYWORDS, r as JSON_SCHEMA_TYPES, s as SCHEMA_SINGLE_KEYWORDS, t as JSON_SCHEMA_METADATA_KEYS } from "./constants-Cx9_Shfk.mjs";
+export { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, SCHEMA_ARRAY_CONCAT_KEYWORDS, SCHEMA_RECORD_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, VALID_SOURCE_FILE_EXTENSIONS };

package/dist/constants.mjs

@@ -0,0 +1,2 @@
+const e=[`ts`,`cts`,`mts`,`tsx`,`js`,`cjs`,`mjs`,`jsx`,`json`,`jsonc`,`json5`,`yaml`,`yml`,`toml`],t={STRING:`string`,NUMBER:`number`,INTEGER:`integer`,BOOLEAN:`boolean`,NULL:`null`,OBJECT:`object`,ARRAY:`array`},n=[t.STRING,t.NUMBER,t.INTEGER,t.BOOLEAN,t.NULL],r=[...n,t.ARRAY,t.OBJECT],i=[`docs`,`deprecated`,`title`,`description`,`examples`,`hidden`,`ignore`,`internal`,`runtime`,`readOnly`,`writeOnly`,`alias`,`tags`],a=new Set([`properties`,`patternProperties`,`$defs`,`definitions`,`dependentSchemas`]),o=new Set([`if`,`then`,`else`,`not`,`contains`,`items`,`additionalProperties`,`unevaluatedProperties`,`propertyNames`,`unevaluatedItems`]),s=new Set([`allOf`,`anyOf`,`oneOf`]);export{i as JSON_SCHEMA_METADATA_KEYS,n as JSON_SCHEMA_PRIMITIVE_TYPES,r as JSON_SCHEMA_TYPES,t as JsonSchemaTypeNames,s as SCHEMA_ARRAY_CONCAT_KEYWORDS,a as SCHEMA_RECORD_KEYWORDS,o as SCHEMA_SINGLE_KEYWORDS,e as VALID_SOURCE_FILE_EXTENSIONS};
+//# sourceMappingURL=constants.mjs.map

package/dist/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":[],"mappings":""}

package/dist/extract.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require("./type-checks.cjs");const e=require("./persistence-CLni2zCP.cjs");exports.bundleReferences=e.o,exports.extract=e.s,exports.extractHash=e.c,exports.extractJsonSchema=e.l,exports.extractResolvedVariant=e.u,exports.extractSchema=e.d,exports.extractSchemaWithSource=e.f,exports.extractSource=e.p,exports.extractVariant=e.m;

package/dist/extract.d.cts

@@ -0,0 +1,130 @@
+import { BundleOptions } from "./bundle.cjs";
+import { ExtractedSchema, JsonSchema, SchemaInput, SchemaInputVariant, SchemaOf, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.cjs";
+
+//#region src/extract.d.ts
+/**
+ * Bundles all external references in a JSON Schema into a single schema document by collecting all reference targets and rewriting the references to point to the bundled definitions. This ensures that the resulting schema is self-contained and can be used independently without relying on external documents.
+ *
+ * @param schema - The JSON Schema to bundle references for.
+ * @returns A new JSON Schema with all references bundled and rewritten to point to the bundled definitions.
+ */
+declare function bundleReferences(schema: JsonSchema): JsonSchema;
+/**
+ * Creates a hash string for a given schema definition input.
+ */
+declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
+/**
+ * Extracts a JSON Schema from Zod, Standard Schema, Valibot, untyped, or JSON Schema inputs.
+ *
+ * @param schema - The schema input to extract a JSON Schema from.
+ * @returns The extracted JSON Schema, or `undefined` if the input is not a supported schema type.
+ */
+declare function extractJsonSchema(schema: unknown): JsonSchema | undefined;
+/**
+ * Resolves the concrete source variant for a schema source input.
+ *
+ * @param input - The schema source input to inspect.
+ * @returns The resolved schema source variant.
+ * @throws Will throw an error when the input cannot be mapped to a supported source variant.
+ */
+declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
+/**
+ * Determines the top-level input variant for schema extraction.
+ *
+ * @param input - The schema input to classify.
+ * @returns The resolved schema input variant.
+ */
+declare function extractVariant(input: SchemaInput): SchemaInputVariant;
+/**
+ * Extracts and normalizes a JSON Schema from a concrete schema source input.
+ *
+ * @param input - The schema source input to extract from.
+ * @param variant - Optional source variant override. When omitted, the variant is inferred from the input.
+ * @returns A promise that resolves to a bundled JSON Schema.
+ * @throws Will throw an error if no valid JSON Schema can be extracted from the input.
+ */
+declare function extractSchema(input: SchemaSourceInput, variant?: SchemaInputVariant): Promise<JsonSchema>;
+/**
+ * Builds source metadata for a schema input using a known source variant.
+ *
+ * @param variant - The schema source variant associated with the input.
+ * @param input - The schema source input to wrap.
+ * @returns The normalized schema source payload, including the source hash and variant.
+ * @throws Will throw an error if the provided variant is unsupported.
+ */
+declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource;
+/**
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+ *
+ * @example
+ * ```ts
+ * Resolve a schema definition from a JSON schema file
+ * const schema1 = await extract(context, "./schemas/my-json-schema.json");
+ * // Resolve a schema definition from a TypeScript module export
+ * const schema2 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema3 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema4 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a Valibot schema
+ * const schema5 = await extract(context, valibotSchema);
+ * // Resolve a schema definition from an untyped schema
+ * const schema6 = await extract(context, untypedSchema);
+ * ```
+ *
+ * @see https://zod.dev/
+ * @see https://valibot.dev/
+ * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
+ * @see https://json-schema.org/
+ * @see https://ajv.js.org/json-type-definition.html
+ * @see https://github.com/vega/ts-json-schema-generator
+ * @see https://github.com/unjs/untyped
+ * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+ *
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options.
+ * @param options - Optional overrides for the configuration used during extraction.
+ * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+ * @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+ */
+declare function extractSchemaWithSource<TSpec = any>(input: SchemaInput, options?: ExtractOptions): Promise<ExtractedSchema<TSpec>>;
+type ExtractOptions = BundleOptions & {
+  cachePath?: string;
+  skipCache?: boolean;
+};
+/**
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+ *
+ * @example
+ * ```ts
+ * Resolve a schema definition from a JSON schema file
+ * const schema1 = await extract(context, "./schemas/my-json-schema.json");
+ * // Resolve a schema definition from a TypeScript module export
+ * const schema2 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema3 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema4 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a Valibot schema
+ * const schema5 = await extract(context, valibotSchema);
+ * // Resolve a schema definition from an untyped schema
+ * const schema6 = await extract(context, untypedSchema);
+ * ```
+ *
+ * @see https://zod.dev/
+ * @see https://valibot.dev/
+ * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
+ * @see https://json-schema.org/
+ * @see https://ajv.js.org/json-type-definition.html
+ * @see https://github.com/vega/ts-json-schema-generator
+ * @see https://github.com/unjs/untyped
+ * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+ *
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options.
+ * @param options - Optional overrides for the configuration used during extraction.
+ * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+ * @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+ */
+declare function extract<TSpec = any>(input: SchemaInput<TSpec>, options?: ExtractOptions): Promise<SchemaOf<TSpec>>;
+//#endregion
+export { ExtractOptions, bundleReferences, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractVariant };
+//# sourceMappingURL=extract.d.cts.map

package/dist/extract.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.cts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;AAiRA;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,UAAA,GAAa,UAAU;;;;iBAgMhD,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAW;AAFpB;;;;;;AAAA,iBAkDgB,iBAAA,CAAkB,MAAA,YAAkB,UAAU;;;AAhD1C;AAgDpB;;;;iBAoCgB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAmB;AAFtB;;;;;;AAAA,iBA4BgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAkB;;AA1BhD;AA0BtB;;;;;;iBAsBsB,aAAA,CACpB,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,UAAA;;AAzB2D;AAsBtE;;;;;;iBAsCgB,aAAA,CACd,OAAA,EAAS,mBAAA,EACT,KAAA,EAAO,iBAAA,GACN,YAAA;;;;;;;;;;AAtCkB;AAmCrB;;;;;;;;;;;;;;AAGe;AAuEf;;;;;;;;iBAAsB,uBAAA,cACpB,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,cAAA,GACR,OAAA,CAAQ,eAAA,CAAgB,KAAA;AAAA,KA0Hf,cAAA,GAAiB,aAAa;EACxC,SAAA;EACA,SAAA;AAAA;;;;;;;AA5H8B;AA0HhC;;;;;;;;AAEW;AAoCX;;;;;;;;;;;;;;;;;iBAAsB,OAAA,cACpB,KAAA,EAAO,WAAA,CAAY,KAAA,GACnB,OAAA,GAAS,cAAA,GACR,OAAA,CAAQ,QAAA,CAAS,KAAA"}

package/dist/extract.d.mts

@@ -0,0 +1,130 @@
+import { BundleOptions } from "./bundle.mjs";
+import { ExtractedSchema, JsonSchema, SchemaInput, SchemaInputVariant, SchemaOf, SchemaSource, SchemaSourceInput, SchemaSourceVariant } from "./types.mjs";
+
+//#region src/extract.d.ts
+/**
+ * Bundles all external references in a JSON Schema into a single schema document by collecting all reference targets and rewriting the references to point to the bundled definitions. This ensures that the resulting schema is self-contained and can be used independently without relying on external documents.
+ *
+ * @param schema - The JSON Schema to bundle references for.
+ * @returns A new JSON Schema with all references bundled and rewritten to point to the bundled definitions.
+ */
+declare function bundleReferences(schema: JsonSchema): JsonSchema;
+/**
+ * Creates a hash string for a given schema definition input.
+ */
+declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
+/**
+ * Extracts a JSON Schema from Zod, Standard Schema, Valibot, untyped, or JSON Schema inputs.
+ *
+ * @param schema - The schema input to extract a JSON Schema from.
+ * @returns The extracted JSON Schema, or `undefined` if the input is not a supported schema type.
+ */
+declare function extractJsonSchema(schema: unknown): JsonSchema | undefined;
+/**
+ * Resolves the concrete source variant for a schema source input.
+ *
+ * @param input - The schema source input to inspect.
+ * @returns The resolved schema source variant.
+ * @throws Will throw an error when the input cannot be mapped to a supported source variant.
+ */
+declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
+/**
+ * Determines the top-level input variant for schema extraction.
+ *
+ * @param input - The schema input to classify.
+ * @returns The resolved schema input variant.
+ */
+declare function extractVariant(input: SchemaInput): SchemaInputVariant;
+/**
+ * Extracts and normalizes a JSON Schema from a concrete schema source input.
+ *
+ * @param input - The schema source input to extract from.
+ * @param variant - Optional source variant override. When omitted, the variant is inferred from the input.
+ * @returns A promise that resolves to a bundled JSON Schema.
+ * @throws Will throw an error if no valid JSON Schema can be extracted from the input.
+ */
+declare function extractSchema(input: SchemaSourceInput, variant?: SchemaInputVariant): Promise<JsonSchema>;
+/**
+ * Builds source metadata for a schema input using a known source variant.
+ *
+ * @param variant - The schema source variant associated with the input.
+ * @param input - The schema source input to wrap.
+ * @returns The normalized schema source payload, including the source hash and variant.
+ * @throws Will throw an error if the provided variant is unsupported.
+ */
+declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource;
+/**
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+ *
+ * @example
+ * ```ts
+ * Resolve a schema definition from a JSON schema file
+ * const schema1 = await extract(context, "./schemas/my-json-schema.json");
+ * // Resolve a schema definition from a TypeScript module export
+ * const schema2 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema3 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema4 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a Valibot schema
+ * const schema5 = await extract(context, valibotSchema);
+ * // Resolve a schema definition from an untyped schema
+ * const schema6 = await extract(context, untypedSchema);
+ * ```
+ *
+ * @see https://zod.dev/
+ * @see https://valibot.dev/
+ * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
+ * @see https://json-schema.org/
+ * @see https://ajv.js.org/json-type-definition.html
+ * @see https://github.com/vega/ts-json-schema-generator
+ * @see https://github.com/unjs/untyped
+ * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+ *
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options.
+ * @param options - Optional overrides for the configuration used during extraction.
+ * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+ * @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+ */
+declare function extractSchemaWithSource<TSpec = any>(input: SchemaInput, options?: ExtractOptions): Promise<ExtractedSchema<TSpec>>;
+type ExtractOptions = BundleOptions & {
+  cachePath?: string;
+  skipCache?: boolean;
+};
+/**
+ * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options. If the input is a {@link FileReferenceInput} (e.g. a file path with an export), the source code will be bundled with [esbuild](esbuild.github.io) using [ts-json-schema-generator](https://github.com/vega/ts-json-schema-generator) to obtain the actual schema definition before extraction.
+ *
+ * @example
+ * ```ts
+ * Resolve a schema definition from a JSON schema file
+ * const schema1 = await extract(context, "./schemas/my-json-schema.json");
+ * // Resolve a schema definition from a TypeScript module export
+ * const schema2 = await extract(context, "./schemas.ts#MySchema");
+ * // Resolve a schema definition from a JSON Schema object
+ * const schema3 = await extract(context, schemaObject);
+ * // Resolve a schema definition from a Zod schema
+ * const schema4 = await extract(context, zodSchema);
+ * // Resolve a schema definition from a Valibot schema
+ * const schema5 = await extract(context, valibotSchema);
+ * // Resolve a schema definition from an untyped schema
+ * const schema6 = await extract(context, untypedSchema);
+ * ```
+ *
+ * @see https://zod.dev/
+ * @see https://valibot.dev/
+ * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
+ * @see https://json-schema.org/
+ * @see https://ajv.js.org/json-type-definition.html
+ * @see https://github.com/vega/ts-json-schema-generator
+ * @see https://github.com/unjs/untyped
+ * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
+ *
+ * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a {@link FileReferenceInput} to an exported TypeScript type definition or any of the previous options.
+ * @param options - Optional overrides for the configuration used during extraction.
+ * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
+ * @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
+ */
+declare function extract<TSpec = any>(input: SchemaInput<TSpec>, options?: ExtractOptions): Promise<SchemaOf<TSpec>>;
+//#endregion
+export { ExtractOptions, bundleReferences, extract, extractHash, extractJsonSchema, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractVariant };
+//# sourceMappingURL=extract.d.mts.map

package/dist/extract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":""}

package/dist/extract.mjs

@@ -0,0 +1 @@
+import"./type-checks.mjs";import{c as e,d as t,f as n,l as r,m as i,o as a,p as o,s,u as c}from"./persistence-B9pzElsC.mjs";export{a as bundleReferences,s as extract,e as extractHash,r as extractJsonSchema,c as extractResolvedVariant,t as extractSchema,n as extractSchemaWithSource,o as extractSource,i as extractVariant};

package/dist/helpers.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./constants.cjs"),t=require("./type-checks.cjs"),n=require("./metadata.cjs");let r=require("@stryke/type-checks"),i=require("@stryke/path/find"),a=require("@stryke/helpers/get-unique");function o(e){let n=t.isSchema(e)?e.schema:e;if(!t.isJsonSchema(n))throw TypeError(`The provided input is not a valid JSON Schema`);return n}function s(e){let n=o(e);if(!t.isJsonSchemaObject(n))throw TypeError(`The provided input is not a valid JSON Schema object`);return n}function c(e){let t=s(e);return(0,r.isSetObject)(t.properties)?Object.entries(t.properties).reduce((e,[n,r])=>(r.name=n,r.required=!h(t,n),r.default=t.default?.[n]??r.default,e[n]=r,e),{}):{}}function l(e){return Object.values(c(e))}function u(e,t){let n=s(e);if(!(0,r.isSetObject)(n.properties))throw TypeError(`The provided schema does not have any properties`);let i=n.properties[t];if(!i)throw TypeError(`The provided schema does not have a property named "${t}"`);return{...i,name:t,required:!h(n,t),default:n.default?.[t]??i?.default}}function d(e,t,n){let r=s(e);r.properties??={},r.required??=[],n.name=t,r.properties[t]=n,r.required.includes(t)||r.required.push(t),r.required.length===0&&delete r.required}function f(n,i){let o={...n};for(let[n,s]of Object.entries(i)){let i=o[n];if(n===`required`)o[n]=(0,a.getUnique)([...Array.isArray(i)?i:[],...Array.isArray(s)?s:[]]);else if(e.SCHEMA_RECORD_KEYWORDS.has(n)&&(0,r.isSetObject)(i)&&(0,r.isSetObject)(s)){let e={...i};for(let[n,r]of Object.entries(s)){let i=e[n];e[n]=t.isJsonSchema(i)&&t.isJsonSchema(r)?f(i,r):r}o[n]=e}else e.SCHEMA_ARRAY_CONCAT_KEYWORDS.has(n)&&Array.isArray(i)&&Array.isArray(s)?o[n]=[...i,...s]:e.SCHEMA_SINGLE_KEYWORDS.has(n)&&t.isJsonSchema(i)&&t.isJsonSchema(s)?o[n]=f(i,s):o[n]=s}return o}function p(...e){let t=e.map(e=>o(e));return t.length===0?{}:t.reduce((e,t)=>{let n=e.type,r=t.type;return n&&r&&n!==r?t:f(e,t)})}function m(e){return(0,r.isSetObject)(e)?e.nullable===!0?!0:n.readSchemaTypes(e).includes(`null`):!1}function h(e,t){if(!e.properties?.[t])throw Error(`The property "${t}" does not exist in the parent schema.`);return!(e.required??[]).includes(t)}function g(t){return e.VALID_SOURCE_FILE_EXTENSIONS.includes((0,i.findFileExtensionSafe)(t))}exports.addProperty=d,exports.getJsonSchema=o,exports.getJsonSchemaObject=s,exports.getProperties=c,exports.getPropertiesList=l,exports.getProperty=u,exports.isPropertyOptional=h,exports.isSchemaNullable=m,exports.isValidSchemaInputFile=g,exports.merge=p;

package/dist/helpers.d.cts

@@ -0,0 +1,123 @@
+import { JsonSchema, JsonSchemaObject, Schema } from "./types.cjs";
+
+//#region src/helpers.d.ts
+type GetPropertyResult = JsonSchema & {
+  name: string;
+  required: boolean;
+  default?: unknown;
+};
+/**
+ * Retrieves the JSON Schema from a Schema wrapper or returns the input if it's already a JSON Schema.
+ *
+ * @remarks
+ * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+ *
+ * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+ * @returns The JSON Schema object.
+ * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+ */
+declare function getJsonSchema(input: Schema | JsonSchema): JsonSchema;
+/**
+ * Retrieves the JSON Schema in Object form from a Schema wrapper or returns the input if it's already a JSON Schema.
+ *
+ * @remarks
+ * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema object, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+ *
+ * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+ * @returns The JSON Schema object.
+ * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+ */
+declare function getJsonSchemaObject(input: Schema | JsonSchema): JsonSchemaObject;
+/**
+ * Extracts object properties from a JSON Schema object form.
+ *
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+ */
+declare function getProperties(obj: Schema | JsonSchemaObject): Record<string, GetPropertyResult>;
+/**
+ * Returns object properties as an array.
+ *
+ * @remarks
+ * This is a convenience function that extracts properties using `getProperties` and returns them as an array.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An array of JSON Schema fragments representing the properties, each including metadata.
+ */
+declare function getPropertiesList(obj: Schema | JsonSchemaObject): GetPropertyResult[];
+/**
+ * Extracts object properties from a JSON Schema object form.
+ *
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+ */
+declare function getProperty<TSchema extends JsonSchemaObject>(obj: Schema<TSchema> | TSchema, name: keyof TSchema["properties"] & string): GetPropertyResult;
+/**
+ * Adds a property to a JSON Schema object form.
+ *
+ * @remarks
+ * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
+ * @param name - The name of the property to add.
+ * @param property - The JSON Schema fragment representing the property's schema, including metadata.
+ * @throws Will throw an error if the provided schema is not an object form.
+ */
+declare function addProperty(obj: Schema | JsonSchemaObject, name: string, property: JsonSchema): void;
+/**
+ * Merges multiple JSON Schemas into one.
+ *
+ * @remarks
+ * This function takes multiple JSON Schemas or Schema wrappers and merges them
+ * into a single JSON Schema object. Later schemas in the argument list take
+ * precedence over earlier ones for scalar conflicts.
+ *
+ * Structured keywords are merged recursively:
+ * - Named child schemas (`properties`, `$defs`, etc.) are merged
+ *   per-property via recursive calls to `merge`.
+ * - Composition arrays (`allOf`, `anyOf`, `oneOf`) are concatenated.
+ * - Single-schema keywords (`if`, `then`, `else`, `not`, `items`, etc.)
+ *   are merged recursively when both sides define them.
+ * - `required` arrays are unioned and deduplicated.
+ *
+ * @param schemas - An array of JSON Schemas or Schema wrappers to merge.
+ * @returns A new JSON Schema that is the result of merging all input schemas.
+ */
+declare function merge(...schemas: (JsonSchema | Schema)[]): JsonSchema;
+/**
+ * Returns whether a JSON Schema fragment accepts `null`.
+ *
+ * @remarks
+ * This is true if the schema has `nullable: true` or if its `type` includes `"null"`.
+ *
+ * @param schema - The JSON Schema fragment to check.
+ * @returns `true` if the schema accepts `null`, otherwise `false`.
+ */
+declare function isSchemaNullable(schema?: JsonSchema): boolean;
+/**
+ * Returns whether an object property is optional (not listed in `required`).
+ *
+ * @remarks
+ * In JSON Schema, object properties are optional by default unless they are listed in the `required` array of the parent schema. This function checks whether a given property name is not included in the `required` array of its parent schema, indicating that it is optional.
+ *
+ * @param parent - The parent JSON Schema object containing the property.
+ * @param propertyName - The name of the property to check for optionality.
+ * @returns `true` if the property is optional, otherwise `false`.
+ */
+declare function isPropertyOptional(parent: JsonSchemaObject, propertyName: string): boolean;
+/**
+ * Checks if a given file name has a valid schema input file extension.
+ *
+ * @param fileName - The file name to check for a valid schema input extension.
+ * @returns `true` if the file name has a valid schema input extension, otherwise `false`.
+ */
+declare function isValidSchemaInputFile(fileName: string): boolean;
+//#endregion
+export { GetPropertyResult, addProperty, getJsonSchema, getJsonSchemaObject, getProperties, getPropertiesList, getProperty, isPropertyOptional, isSchemaNullable, isValidSchemaInputFile, merge };
+//# sourceMappingURL=helpers.d.cts.map

package/dist/helpers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.cts","names":[],"sources":["../src/helpers.ts"],"mappings":";;;KAoCY,iBAAA,GAAoB,UAAU;EACxC,IAAA;EACA,QAAA;EACA,OAAA;AAAA;;;;;;;AAAO;AAaT;;;iBAAgB,aAAA,CAAc,KAAA,EAAO,MAAA,GAAS,UAAA,GAAa,UAAA;;;;;;;;;;AAAU;iBAmBrD,mBAAA,CACd,KAAA,EAAO,MAAA,GAAS,UAAA,GACf,gBAAA;;;;;;;;;;iBAkBa,aAAA,CACd,GAAA,EAAK,MAAA,GAAS,gBAAA,GACb,MAAA,SAAe,iBAAA;;;AApBC;AAkBnB;;;;;;iBA+BgB,iBAAA,CAAkB,GAAA,EAAK,MAAA,GAAS,gBAAA,GAAgB,iBAAA;;;;;;;;;AA7B7B;iBA0CnB,WAAA,iBAA4B,gBAAA,EAC1C,GAAA,EAAK,MAAA,CAAO,OAAA,IAAW,OAAA,EACvB,IAAA,QAAY,OAAA,0BACX,iBAAA;;;;;;;;;;;;iBAgCa,WAAA,CACd,GAAA,EAAK,MAAA,GAAS,gBAAA,EACd,IAAA,UACA,QAAA,EAAU,UAAA;AAnDoD;AAahE;;;;;;;;;;;;;;;;;;AAbgE,iBA4JhD,KAAA,IAAS,OAAA,GAAU,UAAA,GAAa,MAAA,MAAY,UAAA;;;AA5IxC;AAgCpB;;;;;;iBAwIgB,gBAAA,CAAiB,MAAmB,GAAV,UAAU;;;;;;;;;AArI9B;AAyGtB;iBAkDgB,kBAAA,CACd,MAAA,EAAQ,gBAAgB,EACxB,YAAA;;;;;;;iBAiBc,sBAAA,CAAuB,QAAgB"}

package/dist/helpers.d.mts

@@ -0,0 +1,123 @@
+import { JsonSchema, JsonSchemaObject, Schema } from "./types.mjs";
+
+//#region src/helpers.d.ts
+type GetPropertyResult = JsonSchema & {
+  name: string;
+  required: boolean;
+  default?: unknown;
+};
+/**
+ * Retrieves the JSON Schema from a Schema wrapper or returns the input if it's already a JSON Schema.
+ *
+ * @remarks
+ * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+ *
+ * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+ * @returns The JSON Schema object.
+ * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+ */
+declare function getJsonSchema(input: Schema | JsonSchema): JsonSchema;
+/**
+ * Retrieves the JSON Schema in Object form from a Schema wrapper or returns the input if it's already a JSON Schema.
+ *
+ * @remarks
+ * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema object, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
+ *
+ * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
+ * @returns The JSON Schema object.
+ * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
+ */
+declare function getJsonSchemaObject(input: Schema | JsonSchema): JsonSchemaObject;
+/**
+ * Extracts object properties from a JSON Schema object form.
+ *
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+ */
+declare function getProperties(obj: Schema | JsonSchemaObject): Record<string, GetPropertyResult>;
+/**
+ * Returns object properties as an array.
+ *
+ * @remarks
+ * This is a convenience function that extracts properties using `getProperties` and returns them as an array.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An array of JSON Schema fragments representing the properties, each including metadata.
+ */
+declare function getPropertiesList(obj: Schema | JsonSchemaObject): GetPropertyResult[];
+/**
+ * Extracts object properties from a JSON Schema object form.
+ *
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
+ */
+declare function getProperty<TSchema extends JsonSchemaObject>(obj: Schema<TSchema> | TSchema, name: keyof TSchema["properties"] & string): GetPropertyResult;
+/**
+ * Adds a property to a JSON Schema object form.
+ *
+ * @remarks
+ * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
+ * @param name - The name of the property to add.
+ * @param property - The JSON Schema fragment representing the property's schema, including metadata.
+ * @throws Will throw an error if the provided schema is not an object form.
+ */
+declare function addProperty(obj: Schema | JsonSchemaObject, name: string, property: JsonSchema): void;
+/**
+ * Merges multiple JSON Schemas into one.
+ *
+ * @remarks
+ * This function takes multiple JSON Schemas or Schema wrappers and merges them
+ * into a single JSON Schema object. Later schemas in the argument list take
+ * precedence over earlier ones for scalar conflicts.
+ *
+ * Structured keywords are merged recursively:
+ * - Named child schemas (`properties`, `$defs`, etc.) are merged
+ *   per-property via recursive calls to `merge`.
+ * - Composition arrays (`allOf`, `anyOf`, `oneOf`) are concatenated.
+ * - Single-schema keywords (`if`, `then`, `else`, `not`, `items`, etc.)
+ *   are merged recursively when both sides define them.
+ * - `required` arrays are unioned and deduplicated.
+ *
+ * @param schemas - An array of JSON Schemas or Schema wrappers to merge.
+ * @returns A new JSON Schema that is the result of merging all input schemas.
+ */
+declare function merge(...schemas: (JsonSchema | Schema)[]): JsonSchema;
+/**
+ * Returns whether a JSON Schema fragment accepts `null`.
+ *
+ * @remarks
+ * This is true if the schema has `nullable: true` or if its `type` includes `"null"`.
+ *
+ * @param schema - The JSON Schema fragment to check.
+ * @returns `true` if the schema accepts `null`, otherwise `false`.
+ */
+declare function isSchemaNullable(schema?: JsonSchema): boolean;
+/**
+ * Returns whether an object property is optional (not listed in `required`).
+ *
+ * @remarks
+ * In JSON Schema, object properties are optional by default unless they are listed in the `required` array of the parent schema. This function checks whether a given property name is not included in the `required` array of its parent schema, indicating that it is optional.
+ *
+ * @param parent - The parent JSON Schema object containing the property.
+ * @param propertyName - The name of the property to check for optionality.
+ * @returns `true` if the property is optional, otherwise `false`.
+ */
+declare function isPropertyOptional(parent: JsonSchemaObject, propertyName: string): boolean;
+/**
+ * Checks if a given file name has a valid schema input file extension.
+ *
+ * @param fileName - The file name to check for a valid schema input extension.
+ * @returns `true` if the file name has a valid schema input extension, otherwise `false`.
+ */
+declare function isValidSchemaInputFile(fileName: string): boolean;
+//#endregion
+export { GetPropertyResult, addProperty, getJsonSchema, getJsonSchemaObject, getProperties, getPropertiesList, getProperty, isPropertyOptional, isSchemaNullable, isValidSchemaInputFile, merge };
+//# sourceMappingURL=helpers.d.mts.map

package/dist/helpers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.mts","names":[],"sources":["../src/helpers.ts"],"mappings":""}

package/dist/helpers.mjs

@@ -0,0 +1,2 @@
+import{SCHEMA_ARRAY_CONCAT_KEYWORDS as e,SCHEMA_RECORD_KEYWORDS as t,SCHEMA_SINGLE_KEYWORDS as n,VALID_SOURCE_FILE_EXTENSIONS as r}from"./constants.mjs";import{isJsonSchema as i,isJsonSchemaObject as a,isSchema as o}from"./type-checks.mjs";import{readSchemaTypes as s}from"./metadata.mjs";import{isSetObject as c}from"@stryke/type-checks";import{findFileExtensionSafe as l}from"@stryke/path/find";import{getUnique as u}from"@stryke/helpers/get-unique";function d(e){let t=o(e)?e.schema:e;if(!i(t))throw TypeError(`The provided input is not a valid JSON Schema`);return t}function f(e){let t=d(e);if(!a(t))throw TypeError(`The provided input is not a valid JSON Schema object`);return t}function p(e){let t=f(e);return c(t.properties)?Object.entries(t.properties).reduce((e,[n,r])=>(r.name=n,r.required=!b(t,n),r.default=t.default?.[n]??r.default,e[n]=r,e),{}):{}}function m(e){return Object.values(p(e))}function h(e,t){let n=f(e);if(!c(n.properties))throw TypeError(`The provided schema does not have any properties`);let r=n.properties[t];if(!r)throw TypeError(`The provided schema does not have a property named "${t}"`);return{...r,name:t,required:!b(n,t),default:n.default?.[t]??r?.default}}function g(e,t,n){let r=f(e);r.properties??={},r.required??=[],n.name=t,r.properties[t]=n,r.required.includes(t)||r.required.push(t),r.required.length===0&&delete r.required}function _(r,a){let o={...r};for(let[r,s]of Object.entries(a)){let a=o[r];if(r===`required`)o[r]=u([...Array.isArray(a)?a:[],...Array.isArray(s)?s:[]]);else if(t.has(r)&&c(a)&&c(s)){let e={...a};for(let[t,n]of Object.entries(s)){let r=e[t];e[t]=i(r)&&i(n)?_(r,n):n}o[r]=e}else e.has(r)&&Array.isArray(a)&&Array.isArray(s)?o[r]=[...a,...s]:n.has(r)&&i(a)&&i(s)?o[r]=_(a,s):o[r]=s}return o}function v(...e){let t=e.map(e=>d(e));return t.length===0?{}:t.reduce((e,t)=>{let n=e.type,r=t.type;return n&&r&&n!==r?t:_(e,t)})}function y(e){return c(e)?e.nullable===!0?!0:s(e).includes(`null`):!1}function b(e,t){if(!e.properties?.[t])throw Error(`The property "${t}" does not exist in the parent schema.`);return!(e.required??[]).includes(t)}function x(e){return r.includes(l(e))}export{g as addProperty,d as getJsonSchema,f as getJsonSchemaObject,p as getProperties,m as getPropertiesList,h as getProperty,b as isPropertyOptional,y as isSchemaNullable,x as isValidSchemaInputFile,v as merge};
+//# sourceMappingURL=helpers.mjs.map

package/dist/helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.mjs","names":[],"sources":[],"mappings":""}

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require("./types.cjs");const e=require("./constants.cjs"),t=require("./type-checks.cjs"),n=require("./bundle.cjs"),r=require("./resolve.cjs"),i=require("./persistence-CLni2zCP.cjs"),a=require("./metadata.cjs"),o=require("./helpers.cjs"),s=require("./codegen.cjs");exports.JSON_SCHEMA_METADATA_KEYS=e.JSON_SCHEMA_METADATA_KEYS,exports.JSON_SCHEMA_PRIMITIVE_TYPES=e.JSON_SCHEMA_PRIMITIVE_TYPES,exports.JSON_SCHEMA_TYPES=e.JSON_SCHEMA_TYPES,exports.JsonSchemaTypeNames=e.JsonSchemaTypeNames,exports.SCHEMA_ARRAY_CONCAT_KEYWORDS=e.SCHEMA_ARRAY_CONCAT_KEYWORDS,exports.SCHEMA_RECORD_KEYWORDS=e.SCHEMA_RECORD_KEYWORDS,exports.SCHEMA_SINGLE_KEYWORDS=e.SCHEMA_SINGLE_KEYWORDS,exports.VALID_SOURCE_FILE_EXTENSIONS=e.VALID_SOURCE_FILE_EXTENSIONS,exports.addProperty=o.addProperty,exports.applyJsonSchemaMetadata=a.applyJsonSchemaMetadata,exports.bundle=n.bundle,exports.bundleReferences=i.o,exports.extract=i.s,exports.extractHash=i.c,exports.extractJsonSchema=i.l,exports.extractResolvedVariant=i.u,exports.extractSchema=i.d,exports.extractSchemaWithSource=i.f,exports.extractSource=i.p,exports.extractVariant=i.m,exports.generateParserCode=s.generateParserCode,exports.getCacheDirectory=i.t,exports.getCacheFilePath=i.n,exports.getJsonSchema=o.getJsonSchema,exports.getJsonSchemaObject=o.getJsonSchemaObject,exports.getJsonSchemaType=s.getJsonSchemaType,exports.getPrimarySchemaType=a.getPrimarySchemaType,exports.getProperties=o.getProperties,exports.getPropertiesList=o.getPropertiesList,exports.getProperty=o.getProperty,exports.isFileReference=t.isFileReference,exports.isJsonSchema=t.isJsonSchema,exports.isJsonSchemaAllOf=t.isJsonSchemaAllOf,exports.isJsonSchemaAny=t.isJsonSchemaAny,exports.isJsonSchemaAnyOf=t.isJsonSchemaAnyOf,exports.isJsonSchemaArray=t.isJsonSchemaArray,exports.isJsonSchemaBigint=t.isJsonSchemaBigint,exports.isJsonSchemaBoolean=t.isJsonSchemaBoolean,exports.isJsonSchemaDate=t.isJsonSchemaDate,exports.isJsonSchemaDecimal=t.isJsonSchemaDecimal,exports.isJsonSchemaEnum=t.isJsonSchemaEnum,exports.isJsonSchemaInteger=t.isJsonSchemaInteger,exports.isJsonSchemaKeywords=t.isJsonSchemaKeywords,exports.isJsonSchemaLiteral=t.isJsonSchemaLiteral,exports.isJsonSchemaMap=t.isJsonSchemaMap,exports.isJsonSchemaNativeEnum=t.isJsonSchemaNativeEnum,exports.isJsonSchemaNever=t.isJsonSchemaNever,exports.isJsonSchemaNull=t.isJsonSchemaNull,exports.isJsonSchemaNullable=t.isJsonSchemaNullable,exports.isJsonSchemaNumber=t.isJsonSchemaNumber,exports.isJsonSchemaObject=t.isJsonSchemaObject,exports.isJsonSchemaPrimitiveType=t.isJsonSchemaPrimitiveType,exports.isJsonSchemaPrimitiveUnion=t.isJsonSchemaPrimitiveUnion,exports.isJsonSchemaRecord=t.isJsonSchemaRecord,exports.isJsonSchemaRef=t.isJsonSchemaRef,exports.isJsonSchemaSet=t.isJsonSchemaSet,exports.isJsonSchemaString=t.isJsonSchemaString,exports.isJsonSchemaTuple=t.isJsonSchemaTuple,exports.isJsonSchemaType=t.isJsonSchemaType,exports.isJsonSchemaUndefined=t.isJsonSchemaUndefined,exports.isJsonSchemaUnion=t.isJsonSchemaUnion,exports.isJsonSchemaUnknown=t.isJsonSchemaUnknown,exports.isNullOnlyJsonSchema=t.isNullOnlyJsonSchema,exports.isPropertyOptional=o.isPropertyOptional,exports.isSchema=t.isSchema,exports.isSchemaNullable=o.isSchemaNullable,exports.isSchemaObject=t.isSchemaObject,exports.isSchemaWithSource=t.isSchemaWithSource,exports.isStandardSchema=t.isStandardSchema,exports.isUntypedInput=t.isUntypedInput,exports.isUntypedInputStrict=t.isUntypedInputStrict,exports.isUntypedSchema=t.isUntypedSchema,exports.isUntypedSchemaStrict=t.isUntypedSchemaStrict,exports.isValibotSchema=t.isValibotSchema,exports.isValidSchemaInputFile=o.isValidSchemaInputFile,exports.merge=o.merge,exports.readSchema=i.r,exports.readSchemaSafe=i.i,exports.readSchemaTypes=a.readSchemaTypes,exports.resolve=r.resolve,exports.resolveModule=r.resolveModule,exports.resolveSafe=r.resolveSafe,exports.resolveTSType=r.resolveTSType,exports.stringifyType=s.stringifyType,exports.stringifyValue=s.stringifyValue,exports.writeSchema=i.a;