@powerlines/schema 0.8.67 → 0.9.0

package/dist/type-checks.cjs

@@ -0,0 +1,76 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_json_schema = require("@stryke/json/schema");
+
+//#region src/type-checks.ts
+/**
+* Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
+* @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+*/
+function isJTDSchema(input) {
+	return (0, _stryke_json_schema.isJsonSchemaObjectType)(input) && "jtd" in input && input.jtd === true;
+}
+/**
+* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+*
+* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
+* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+*/
+function isUntypedSchema(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const schema = input;
+	if ("id" in schema && !(0, _stryke_type_checks.isSetString)(schema.id)) return false;
+	if ("title" in schema && !(0, _stryke_type_checks.isSetString)(schema.title)) return false;
+	if ("description" in schema && !(0, _stryke_type_checks.isSetString)(schema.description)) return false;
+	if ("$schema" in schema && !(0, _stryke_type_checks.isSetString)(schema.$schema)) return false;
+	if ("tsType" in schema && !(0, _stryke_type_checks.isSetString)(schema.tsType)) return false;
+	if ("markdownType" in schema && !(0, _stryke_type_checks.isSetString)(schema.markdownType)) return false;
+	if ("type" in schema && !(0, _stryke_type_checks.isSetString)(schema.type) && !Array.isArray(schema.type)) return false;
+	if ("required" in schema && !Array.isArray(schema.required)) return false;
+	if ("tags" in schema && !Array.isArray(schema.tags)) return false;
+	if ("args" in schema && !Array.isArray(schema.args)) return false;
+	if ("properties" in schema && !(0, _stryke_type_checks.isSetObject)(schema.properties)) return false;
+	if ("resolve" in schema && !(0, _stryke_type_checks.isFunction)(schema.resolve)) return false;
+	return true;
+}
+/**
+* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+*
+* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
+* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+*/
+function isUntypedInput(input) {
+	if (!(0, _stryke_type_checks.isSetObject)(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && !isUntypedSchema(inputObject.$schema)) return false;
+	if ("$resolve" in inputObject && !(0, _stryke_type_checks.isFunction)(inputObject.$resolve)) return false;
+	return true;
+}
+/**
+* Type guard to check if a given input is a {@link Schema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link Schema}; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a {@link Schema}.
+* @returns `true` if the input is a {@link Schema}, otherwise `false`.
+*/
+function isSchema(input) {
+	return (0, _stryke_type_checks.isSetObject)(input) && "schema" in input && isJTDSchema(input.schema) && "input" in input && (0, _stryke_type_checks.isSetObject)(input.input) && "variant" in input && (0, _stryke_type_checks.isSetString)(input.variant);
+}
+/**
+* Type guard to check if a given input is a {@link ExtractedSchema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link ExtractedSchema}; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a {@link ExtractedSchema}.
+* @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
+*/
+function isExtractedSchema(input) {
+	return isSchema(input) && "source" in input && (0, _stryke_type_checks.isSetObject)(input.source) && "schema" in input.source && isJTDSchema(input.source.schema) && "variant" in input.source && (0, _stryke_type_checks.isSetString)(input.source.variant);
+}
+
+//#endregion
+exports.isExtractedSchema = isExtractedSchema;
+exports.isJTDSchema = isJTDSchema;
+exports.isSchema = isSchema;
+exports.isUntypedInput = isUntypedInput;
+exports.isUntypedSchema = isUntypedSchema;

package/dist/type-checks.d.cts

@@ -0,0 +1,43 @@
+import { ExtractedSchema, Schema as Schema$1 } from "./types.cjs";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
+import { InputObject, Schema } from "untyped";
+
+//#region src/type-checks.d.ts
+/**
+ * Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
+ * @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+ */
+declare function isJTDSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is JTDSchemaType<T, D>;
+/**
+ * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+ *
+ * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
+ * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+ */
+declare function isUntypedSchema(input: unknown): input is Schema;
+/**
+ * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+ *
+ * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
+ * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+ */
+declare function isUntypedInput(input: unknown): input is InputObject;
+/**
+ * Type guard to check if a given input is a {@link Schema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link Schema}; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a {@link Schema}.
+ * @returns `true` if the input is a {@link Schema}, otherwise `false`.
+ */
+declare function isSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is Schema$1<T, D>;
+/**
+ * Type guard to check if a given input is a {@link ExtractedSchema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link ExtractedSchema}; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a {@link ExtractedSchema}.
+ * @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
+ */
+declare function isExtractedSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is ExtractedSchema<T, D>;
+//#endregion
+export { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema };
+//# sourceMappingURL=type-checks.d.cts.map

package/dist/type-checks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checks.d.cts","names":[],"sources":["../src/type-checks.ts"],"mappings":";;;;;;;AAiCA;;;;iBAAgB,WAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,aAAA,CAAc,CAAA,EAAG,CAAA;;;;;;;iBAU7B,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAA;;;;;;;iBAwD1C,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAA;;;AAxDzD;;;;iBA8EgB,QAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,QAAA,CAAO,CAAA,EAAG,CAAA;;;;;AAzBtC;;iBA2CgB,iBAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,eAAA,CAAgB,CAAA,EAAG,CAAA"}

package/dist/type-checks.d.mts

@@ -0,0 +1,43 @@
+import { ExtractedSchema, Schema as Schema$1 } from "./types.mjs";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
+import { InputObject, Schema } from "untyped";
+
+//#region src/type-checks.d.ts
+/**
+ * Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
+ * @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+ */
+declare function isJTDSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is JTDSchemaType<T, D>;
+/**
+ * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+ *
+ * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
+ * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+ */
+declare function isUntypedSchema(input: unknown): input is Schema;
+/**
+ * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+ *
+ * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
+ * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+ */
+declare function isUntypedInput(input: unknown): input is InputObject;
+/**
+ * Type guard to check if a given input is a {@link Schema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link Schema}; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a {@link Schema}.
+ * @returns `true` if the input is a {@link Schema}, otherwise `false`.
+ */
+declare function isSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is Schema$1<T, D>;
+/**
+ * Type guard to check if a given input is a {@link ExtractedSchema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link ExtractedSchema}; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a {@link ExtractedSchema}.
+ * @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
+ */
+declare function isExtractedSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>>(input: unknown): input is ExtractedSchema<T, D>;
+//#endregion
+export { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema };
+//# sourceMappingURL=type-checks.d.mts.map

package/dist/type-checks.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checks.d.mts","names":[],"sources":["../src/type-checks.ts"],"mappings":";;;;;;;AAiCA;;;;iBAAgB,WAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,aAAA,CAAc,CAAA,EAAG,CAAA;;;;;;;iBAU7B,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAA;;;;;;;iBAwD1C,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAA;;;AAxDzD;;;;iBA8EgB,QAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,QAAA,CAAO,CAAA,EAAG,CAAA;;;;;AAzBtC;;iBA2CgB,iBAAA,wBAEJ,MAAA,oBAA0B,MAAA,kBAAA,CACpC,KAAA,YAAiB,KAAA,IAAS,eAAA,CAAgB,CAAA,EAAG,CAAA"}

package/dist/type-checks.mjs

@@ -0,0 +1,71 @@
+import { isFunction, isSetObject, isSetString } from "@stryke/type-checks";
+import { isJsonSchemaObjectType } from "@stryke/json/schema";
+
+//#region src/type-checks.ts
+/**
+* Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
+* @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+*/
+function isJTDSchema(input) {
+	return isJsonSchemaObjectType(input) && "jtd" in input && input.jtd === true;
+}
+/**
+* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+*
+* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
+* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+*/
+function isUntypedSchema(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if ("id" in schema && !isSetString(schema.id)) return false;
+	if ("title" in schema && !isSetString(schema.title)) return false;
+	if ("description" in schema && !isSetString(schema.description)) return false;
+	if ("$schema" in schema && !isSetString(schema.$schema)) return false;
+	if ("tsType" in schema && !isSetString(schema.tsType)) return false;
+	if ("markdownType" in schema && !isSetString(schema.markdownType)) return false;
+	if ("type" in schema && !isSetString(schema.type) && !Array.isArray(schema.type)) return false;
+	if ("required" in schema && !Array.isArray(schema.required)) return false;
+	if ("tags" in schema && !Array.isArray(schema.tags)) return false;
+	if ("args" in schema && !Array.isArray(schema.args)) return false;
+	if ("properties" in schema && !isSetObject(schema.properties)) return false;
+	if ("resolve" in schema && !isFunction(schema.resolve)) return false;
+	return true;
+}
+/**
+* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+*
+* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
+* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+*/
+function isUntypedInput(input) {
+	if (!isSetObject(input)) return false;
+	const inputObject = input;
+	if ("$schema" in inputObject && !isUntypedSchema(inputObject.$schema)) return false;
+	if ("$resolve" in inputObject && !isFunction(inputObject.$resolve)) return false;
+	return true;
+}
+/**
+* Type guard to check if a given input is a {@link Schema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link Schema}; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a {@link Schema}.
+* @returns `true` if the input is a {@link Schema}, otherwise `false`.
+*/
+function isSchema(input) {
+	return isSetObject(input) && "schema" in input && isJTDSchema(input.schema) && "input" in input && isSetObject(input.input) && "variant" in input && isSetString(input.variant);
+}
+/**
+* Type guard to check if a given input is a {@link ExtractedSchema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link ExtractedSchema}; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a {@link ExtractedSchema}.
+* @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
+*/
+function isExtractedSchema(input) {
+	return isSchema(input) && "source" in input && isSetObject(input.source) && "schema" in input.source && isJTDSchema(input.source.schema) && "variant" in input.source && isSetString(input.source.variant);
+}
+
+//#endregion
+export { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema };
+//# sourceMappingURL=type-checks.mjs.map

package/dist/type-checks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checks.mjs","names":[],"sources":["../src/type-checks.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { isJsonSchemaObjectType } from \"@stryke/json/schema\";\nimport { isFunction, isSetObject, isSetString } from \"@stryke/type-checks\";\nimport { JTDSchemaType } from \"ajv/dist/types/jtd-schema\";\nimport {\n  InputObject as UntypedInputObject,\n  Schema as UntypedSchema\n} from \"untyped\";\nimport { ExtractedSchema, Schema } from \"./types\";\n\n/**\n * Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).\n * @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.\n */\nexport function isJTDSchema<\n  T = unknown,\n  D extends Record<string, unknown> = Record<string, unknown>\n>(input: unknown): input is JTDSchemaType<T, D> {\n  return isJsonSchemaObjectType(input) && \"jtd\" in input && input.jtd === true;\n}\n\n/**\n * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.\n *\n * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.\n * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.\n */\nexport function isUntypedSchema(input: unknown): input is UntypedSchema {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const schema = input as Record<string, unknown>;\n  if (\"id\" in schema && !isSetString(schema.id)) {\n    return false;\n  }\n  if (\"title\" in schema && !isSetString(schema.title)) {\n    return false;\n  }\n  if (\"description\" in schema && !isSetString(schema.description)) {\n    return false;\n  }\n  if (\"$schema\" in schema && !isSetString(schema.$schema)) {\n    return false;\n  }\n  if (\"tsType\" in schema && !isSetString(schema.tsType)) {\n    return false;\n  }\n  if (\"markdownType\" in schema && !isSetString(schema.markdownType)) {\n    return false;\n  }\n  if (\n    \"type\" in schema &&\n    !isSetString(schema.type) &&\n    !Array.isArray(schema.type)\n  ) {\n    return false;\n  }\n  if (\"required\" in schema && !Array.isArray(schema.required)) {\n    return false;\n  }\n  if (\"tags\" in schema && !Array.isArray(schema.tags)) {\n    return false;\n  }\n  if (\"args\" in schema && !Array.isArray(schema.args)) {\n    return false;\n  }\n  if (\"properties\" in schema && !isSetObject(schema.properties)) {\n    return false;\n  }\n  if (\"resolve\" in schema && !isFunction(schema.resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.\n *\n * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.\n * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.\n */\nexport function isUntypedInput(input: unknown): input is UntypedInputObject {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const inputObject = input as Record<string, unknown>;\n  if (\"$schema\" in inputObject && !isUntypedSchema(inputObject.$schema)) {\n    return false;\n  }\n  if (\"$resolve\" in inputObject && !isFunction(inputObject.$resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard to check if a given input is a {@link Schema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants (\"json-schema\", \"standard-schema\", \"zod3\", or \"reflection\"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link Schema}; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a {@link Schema}.\n * @returns `true` if the input is a {@link Schema}, otherwise `false`.\n */\nexport function isSchema<\n  T = unknown,\n  D extends Record<string, unknown> = Record<string, unknown>\n>(input: unknown): input is Schema<T, D> {\n  return (\n    isSetObject(input) &&\n    \"schema\" in input &&\n    isJTDSchema(input.schema) &&\n    \"input\" in input &&\n    isSetObject(input.input) &&\n    \"variant\" in input &&\n    isSetString(input.variant)\n  );\n}\n\n/**\n * Type guard to check if a given input is a {@link ExtractedSchema} object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants (\"json-schema\", \"standard-schema\", \"zod3\", or \"reflection\"). If all these conditions are met, the function returns `true`, indicating that the input is a valid {@link ExtractedSchema}; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a {@link ExtractedSchema}.\n * @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.\n */\nexport function isExtractedSchema<\n  T = unknown,\n  D extends Record<string, unknown> = Record<string, unknown>\n>(input: unknown): input is ExtractedSchema<T, D> {\n  return (\n    isSchema<T, D>(input) &&\n    \"source\" in input &&\n    isSetObject(input.source) &&\n    \"schema\" in input.source &&\n    isJTDSchema(input.source.schema) &&\n    \"variant\" in input.source &&\n    isSetString(input.source.variant)\n  );\n}\n"],"mappings":";;;;;;;;;;AAiCA,SAAgB,YAGd,OAA8C;AAC9C,QAAO,uBAAuB,MAAM,IAAI,SAAS,SAAS,MAAM,QAAQ;;;;;;;;AAS1E,SAAgB,gBAAgB,OAAwC;AACtE,KAAI,CAAC,YAAY,MAAM,CACrB,QAAO;CAGT,MAAM,SAAS;AACf,KAAI,QAAQ,UAAU,CAAC,YAAY,OAAO,GAAG,CAC3C,QAAO;AAET,KAAI,WAAW,UAAU,CAAC,YAAY,OAAO,MAAM,CACjD,QAAO;AAET,KAAI,iBAAiB,UAAU,CAAC,YAAY,OAAO,YAAY,CAC7D,QAAO;AAET,KAAI,aAAa,UAAU,CAAC,YAAY,OAAO,QAAQ,CACrD,QAAO;AAET,KAAI,YAAY,UAAU,CAAC,YAAY,OAAO,OAAO,CACnD,QAAO;AAET,KAAI,kBAAkB,UAAU,CAAC,YAAY,OAAO,aAAa,CAC/D,QAAO;AAET,KACE,UAAU,UACV,CAAC,YAAY,OAAO,KAAK,IACzB,CAAC,MAAM,QAAQ,OAAO,KAAK,CAE3B,QAAO;AAET,KAAI,cAAc,UAAU,CAAC,MAAM,QAAQ,OAAO,SAAS,CACzD,QAAO;AAET,KAAI,UAAU,UAAU,CAAC,MAAM,QAAQ,OAAO,KAAK,CACjD,QAAO;AAET,KAAI,UAAU,UAAU,CAAC,MAAM,QAAQ,OAAO,KAAK,CACjD,QAAO;AAET,KAAI,gBAAgB,UAAU,CAAC,YAAY,OAAO,WAAW,CAC3D,QAAO;AAET,KAAI,aAAa,UAAU,CAAC,WAAW,OAAO,QAAQ,CACpD,QAAO;AAGT,QAAO;;;;;;;;AAST,SAAgB,eAAe,OAA6C;AAC1E,KAAI,CAAC,YAAY,MAAM,CACrB,QAAO;CAGT,MAAM,cAAc;AACpB,KAAI,aAAa,eAAe,CAAC,gBAAgB,YAAY,QAAQ,CACnE,QAAO;AAET,KAAI,cAAc,eAAe,CAAC,WAAW,YAAY,SAAS,CAChE,QAAO;AAGT,QAAO;;;;;;;;AAST,SAAgB,SAGd,OAAuC;AACvC,QACE,YAAY,MAAM,IAClB,YAAY,SACZ,YAAY,MAAM,OAAO,IACzB,WAAW,SACX,YAAY,MAAM,MAAM,IACxB,aAAa,SACb,YAAY,MAAM,QAAQ;;;;;;;;AAU9B,SAAgB,kBAGd,OAAgD;AAChD,QACE,SAAe,MAAM,IACrB,YAAY,SACZ,YAAY,MAAM,OAAO,IACzB,YAAY,MAAM,UAClB,YAAY,MAAM,OAAO,OAAO,IAChC,aAAa,MAAM,UACnB,YAAY,MAAM,OAAO,QAAQ"}

package/dist/types.d.cts

@@ -1,39 +1,95 @@
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
 import { StandardJSONSchemaV1 } from "@standard-schema/spec";
-import { TypeDefinitionParameter } from "@stryke/types/configuration";
+import { JsonSchemaType } from "@stryke/json/types";
+import { TypeDefinition } from "@stryke/types/configuration";
+import { InputObject, Schema as Schema$1 } from "untyped";
 import * as z3 from "zod/v3";
 
 //#region src/types.d.ts
-type SchemaDefinitionVariant = "json-schema" | "standard-schema" | "zod3" | "reflection";
-interface SchemaDefinitionBase {
-  schema: JsonSchema7Type;
-  variant: SchemaDefinitionVariant;
-  input: SchemaDefinitionInput;
-}
-interface SchemaDefinitionJsonSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+type UntypedInputObject = InputObject;
+type UntypedSchema = Schema$1;
+/**
+ * The set of numeric `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JtdNumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
+/**
+ * The set of `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JtdType = JtdNumberType | "string" | "timestamp" | "boolean";
+interface JsonSchemaLike {
+  type?: string | string[];
+  format?: string;
+  enum?: unknown[];
+  const?: unknown;
+  items?: JsonSchemaLike | JsonSchemaLike[];
+  properties?: Record<string, JsonSchemaLike>;
+  patternProperties?: Record<string, JsonSchemaLike>;
+  additionalProperties?: boolean | JsonSchemaLike;
+  required?: string[];
+  anyOf?: JsonSchemaLike[];
+  oneOf?: JsonSchemaLike[];
+  allOf?: JsonSchemaLike[];
+  $ref?: string;
+  description?: string;
+  title?: string;
+  default?: unknown;
+  examples?: unknown[];
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number | boolean;
+  exclusiveMaximum?: number | boolean;
+  nullable?: boolean;
+  definitions?: Record<string, JsonSchemaLike>;
+  $defs?: Record<string, JsonSchemaLike>;
+  discriminator?: {
+    propertyName?: string;
+  } | string;
+  [key: string]: unknown;
+}
+type SchemaSourceVariant = "standard-schema" | "jtd-schema" | "json-schema" | "zod3" | "untyped" | "reflection";
+type SchemaInputVariant = SchemaSourceVariant | "type-definition";
+type SchemaSourceInput<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> = StandardJSONSchemaV1 | JTDSchemaType<T, D> | JsonSchemaType | z3.ZodTypeAny | UntypedInputObject | UntypedSchema | Type;
+type TypeDefinitionReference = TypeDefinition | string;
+type SchemaInput = SchemaSourceInput | Schema | TypeDefinitionReference;
+interface Schema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> {
+  hash: string;
+  variant: SchemaInputVariant;
+  schema: JTDSchemaType<T, D>;
+}
+interface BaseSchemaSource {
+  hash: string;
+  variant: SchemaSourceVariant;
+  schema: SchemaSourceInput;
+}
+interface JTDSchemaSchemaSource<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> extends BaseSchemaSource {
+  variant: "jtd-schema";
+  schema: JTDSchemaType<T, D>;
+}
+interface JsonSchemaSchemaSource extends BaseSchemaSource {
   variant: "json-schema";
-  input: JsonSchema7Type;
+  schema: JsonSchemaType;
 }
-interface SchemaDefinitionStandardSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface StandardSchemaSchemaSource extends BaseSchemaSource {
   variant: "standard-schema";
-  input: StandardJSONSchemaV1;
+  schema: StandardJSONSchemaV1;
 }
-interface SchemaDefinitionZod3 extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface Zod3SchemaSource extends BaseSchemaSource {
   variant: "zod3";
-  input: z3.ZodTypeAny;
+  schema: z3.ZodTypeAny;
 }
-interface SchemaDefinitionReflection extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface ReflectionSchemaSource extends BaseSchemaSource {
   variant: "reflection";
-  input: Type;
+  schema: Type;
+}
+interface UntypedSchemaSource extends BaseSchemaSource {
+  variant: "untyped";
+  schema: UntypedInputObject | UntypedSchema;
+}
+type SchemaSource = JsonSchemaSchemaSource | JTDSchemaSchemaSource | StandardSchemaSchemaSource | Zod3SchemaSource | UntypedSchemaSource | ReflectionSchemaSource;
+interface ExtractedSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> extends Schema<T, D> {
+  source: SchemaSource;
 }
-type SchemaDefinition = SchemaDefinitionJsonSchema | SchemaDefinitionStandardSchema | SchemaDefinitionZod3 | SchemaDefinitionReflection;
-type SchemaDefinitionInput = SchemaDefinition | JsonSchema7Type | StandardJSONSchemaV1 | z3.ZodTypeAny | Type;
-type SchemaDefinitionParameter = SchemaDefinitionInput | TypeDefinitionParameter;
 //#endregion
-export { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 };
+export { BaseSchemaSource, ExtractedSchema, JTDSchemaSchemaSource, JsonSchemaLike, JsonSchemaSchemaSource, JtdNumberType, JtdType, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource };
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;KAwBY,uBAAA;AAAA,UAMK,oBAAA;EACf,MAAA,EAAQ,eAAA;EACR,OAAA,EAAS,uBAAA;EACT,KAAA,EAAO,qBAAA;AAAA;AAAA,UAGQ,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,eAAA;AAAA;AAAA,UAGQ,8BAAA,SAAuC,oBAAA;EACtD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,oBAAA;AAAA;AAAA,UAGQ,oBAAA,SAA6B,oBAAA;EAC5C,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,EAAA,CAAG,UAAA;AAAA;AAAA,UAGK,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,IAAA;AAAA;AAAA,KAGG,gBAAA,GACR,0BAAA,GACA,8BAAA,GACA,oBAAA,GACA,0BAAA;AAAA,KAEQ,qBAAA,GACR,gBAAA,GACA,eAAA,GACA,oBAAA,GACA,EAAA,CAAG,UAAA,GACH,IAAA;AAAA,KAEQ,yBAAA,GACR,qBAAA,GACA,uBAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;KA0BY,kBAAA,GAAqB,WAAA;AAAA,KACrB,aAAA,GAAgB,QAAA;AAD5B;;;AAAA,KAMY,aAAA;;AALZ;;KAkBY,OAAA,GAAU,aAAA;AAAA,UAEL,cAAA;EACf,IAAA;EACA,MAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA,GAAQ,cAAA,GAAiB,cAAA;EACzB,UAAA,GAAa,MAAA,SAAe,cAAA;EAC5B,iBAAA,GAAoB,MAAA,SAAe,cAAA;EACnC,oBAAA,aAAiC,cAAA;EACjC,QAAA;EACA,KAAA,GAAQ,cAAA;EACR,KAAA,GAAQ,cAAA;EACR,KAAA,GAAQ,cAAA;EACR,IAAA;EACA,WAAA;EACA,KAAA;EACA,OAAA;EACA,QAAA;EACA,OAAA;EACA,OAAA;EACA,gBAAA;EACA,gBAAA;EACA,QAAA;EACA,WAAA,GAAc,MAAA,SAAe,cAAA;EAC7B,KAAA,GAAQ,MAAA,SAAe,cAAA;EACvB,aAAA;IAAkB,YAAA;EAAA;EAAA,CACjB,GAAA;AAAA;AAAA,KAGS,mBAAA;AAAA,KAQA,kBAAA,GAAqB,mBAAA;AAAA,KAErB,iBAAA,wBAEA,MAAA,oBAA0B,MAAA,qBAElC,oBAAA,GACA,aAAA,CAAc,CAAA,EAAG,CAAA,IACjB,cAAA,GACA,EAAA,CAAG,UAAA,GACH,kBAAA,GACA,aAAA,GACA,IAAA;AAAA,KAEQ,uBAAA,GAA0B,cAAA;AAAA,KAE1B,WAAA,GAAc,iBAAA,GAAoB,MAAA,GAAS,uBAAA;AAAA,UAEtC,MAAA,wBAEL,MAAA,oBAA0B,MAAA;EAEpC,IAAA;EACA,OAAA,EAAS,kBAAA;EACT,MAAA,EAAQ,aAAA,CAAc,CAAA,EAAG,CAAA;AAAA;AAAA,UAGV,gBAAA;EACf,IAAA;EACA,OAAA,EAAS,mBAAA;EACT,MAAA,EAAQ,iBAAA;AAAA;AAAA,UAGO,qBAAA,wBAEL,MAAA,oBAA0B,MAAA,2BAC5B,gBAAA;EACR,OAAA;EACA,MAAA,EAAQ,aAAA,CAAc,CAAA,EAAG,CAAA;AAAA;AAAA,UAGV,sBAAA,SAA+B,gBAAA;EAC9C,OAAA;EACA,MAAA,EAAQ,cAAA;AAAA;AAAA,UAGO,0BAAA,SAAmC,gBAAA;EAClD,OAAA;EACA,MAAA,EAAQ,oBAAA;AAAA;AAAA,UAGO,gBAAA,SAAyB,gBAAA;EACxC,OAAA;EACA,MAAA,EAAQ,EAAA,CAAG,UAAA;AAAA;AAAA,UAGI,sBAAA,SAA+B,gBAAA;EAC9C,OAAA;EACA,MAAA,EAAQ,IAAA;AAAA;AAAA,UAGO,mBAAA,SAA4B,gBAAA;EAC3C,OAAA;EACA,MAAA,EAAQ,kBAAA,GAAqB,aAAA;AAAA;AAAA,KAGnB,YAAA,GACR,sBAAA,GACA,qBAAA,GACA,0BAAA,GACA,gBAAA,GACA,mBAAA,GACA,sBAAA;AAAA,UAEa,eAAA,wBAEL,MAAA,oBAA0B,MAAA,2BAC5B,MAAA,CAAO,CAAA,EAAG,CAAA;EAClB,MAAA,EAAQ,YAAA;AAAA"}

package/dist/types.d.mts

@@ -1,39 +1,95 @@
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
 import { StandardJSONSchemaV1 } from "@standard-schema/spec";
-import { TypeDefinitionParameter } from "@stryke/types/configuration";
+import { JsonSchemaType } from "@stryke/json/types";
+import { TypeDefinition } from "@stryke/types/configuration";
+import { InputObject, Schema as Schema$1 } from "untyped";
 import * as z3 from "zod/v3";
 
 //#region src/types.d.ts
-type SchemaDefinitionVariant = "json-schema" | "standard-schema" | "zod3" | "reflection";
-interface SchemaDefinitionBase {
-  schema: JsonSchema7Type;
-  variant: SchemaDefinitionVariant;
-  input: SchemaDefinitionInput;
-}
-interface SchemaDefinitionJsonSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+type UntypedInputObject = InputObject;
+type UntypedSchema = Schema$1;
+/**
+ * The set of numeric `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JtdNumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
+/**
+ * The set of `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JtdType = JtdNumberType | "string" | "timestamp" | "boolean";
+interface JsonSchemaLike {
+  type?: string | string[];
+  format?: string;
+  enum?: unknown[];
+  const?: unknown;
+  items?: JsonSchemaLike | JsonSchemaLike[];
+  properties?: Record<string, JsonSchemaLike>;
+  patternProperties?: Record<string, JsonSchemaLike>;
+  additionalProperties?: boolean | JsonSchemaLike;
+  required?: string[];
+  anyOf?: JsonSchemaLike[];
+  oneOf?: JsonSchemaLike[];
+  allOf?: JsonSchemaLike[];
+  $ref?: string;
+  description?: string;
+  title?: string;
+  default?: unknown;
+  examples?: unknown[];
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number | boolean;
+  exclusiveMaximum?: number | boolean;
+  nullable?: boolean;
+  definitions?: Record<string, JsonSchemaLike>;
+  $defs?: Record<string, JsonSchemaLike>;
+  discriminator?: {
+    propertyName?: string;
+  } | string;
+  [key: string]: unknown;
+}
+type SchemaSourceVariant = "standard-schema" | "jtd-schema" | "json-schema" | "zod3" | "untyped" | "reflection";
+type SchemaInputVariant = SchemaSourceVariant | "type-definition";
+type SchemaSourceInput<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> = StandardJSONSchemaV1 | JTDSchemaType<T, D> | JsonSchemaType | z3.ZodTypeAny | UntypedInputObject | UntypedSchema | Type;
+type TypeDefinitionReference = TypeDefinition | string;
+type SchemaInput = SchemaSourceInput | Schema | TypeDefinitionReference;
+interface Schema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> {
+  hash: string;
+  variant: SchemaInputVariant;
+  schema: JTDSchemaType<T, D>;
+}
+interface BaseSchemaSource {
+  hash: string;
+  variant: SchemaSourceVariant;
+  schema: SchemaSourceInput;
+}
+interface JTDSchemaSchemaSource<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> extends BaseSchemaSource {
+  variant: "jtd-schema";
+  schema: JTDSchemaType<T, D>;
+}
+interface JsonSchemaSchemaSource extends BaseSchemaSource {
   variant: "json-schema";
-  input: JsonSchema7Type;
+  schema: JsonSchemaType;
 }
-interface SchemaDefinitionStandardSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface StandardSchemaSchemaSource extends BaseSchemaSource {
   variant: "standard-schema";
-  input: StandardJSONSchemaV1;
+  schema: StandardJSONSchemaV1;
 }
-interface SchemaDefinitionZod3 extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface Zod3SchemaSource extends BaseSchemaSource {
   variant: "zod3";
-  input: z3.ZodTypeAny;
+  schema: z3.ZodTypeAny;
 }
-interface SchemaDefinitionReflection extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface ReflectionSchemaSource extends BaseSchemaSource {
   variant: "reflection";
-  input: Type;
+  schema: Type;
+}
+interface UntypedSchemaSource extends BaseSchemaSource {
+  variant: "untyped";
+  schema: UntypedInputObject | UntypedSchema;
+}
+type SchemaSource = JsonSchemaSchemaSource | JTDSchemaSchemaSource | StandardSchemaSchemaSource | Zod3SchemaSource | UntypedSchemaSource | ReflectionSchemaSource;
+interface ExtractedSchema<T = unknown, D extends Record<string, unknown> = Record<string, unknown>> extends Schema<T, D> {
+  source: SchemaSource;
 }
-type SchemaDefinition = SchemaDefinitionJsonSchema | SchemaDefinitionStandardSchema | SchemaDefinitionZod3 | SchemaDefinitionReflection;
-type SchemaDefinitionInput = SchemaDefinition | JsonSchema7Type | StandardJSONSchemaV1 | z3.ZodTypeAny | Type;
-type SchemaDefinitionParameter = SchemaDefinitionInput | TypeDefinitionParameter;
 //#endregion
-export { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 };
+export { BaseSchemaSource, ExtractedSchema, JTDSchemaSchemaSource, JsonSchemaLike, JsonSchemaSchemaSource, JtdNumberType, JtdType, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;KAwBY,uBAAA;AAAA,UAMK,oBAAA;EACf,MAAA,EAAQ,eAAA;EACR,OAAA,EAAS,uBAAA;EACT,KAAA,EAAO,qBAAA;AAAA;AAAA,UAGQ,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,eAAA;AAAA;AAAA,UAGQ,8BAAA,SAAuC,oBAAA;EACtD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,oBAAA;AAAA;AAAA,UAGQ,oBAAA,SAA6B,oBAAA;EAC5C,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,EAAA,CAAG,UAAA;AAAA;AAAA,UAGK,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,IAAA;AAAA;AAAA,KAGG,gBAAA,GACR,0BAAA,GACA,8BAAA,GACA,oBAAA,GACA,0BAAA;AAAA,KAEQ,qBAAA,GACR,gBAAA,GACA,eAAA,GACA,oBAAA,GACA,EAAA,CAAG,UAAA,GACH,IAAA;AAAA,KAEQ,yBAAA,GACR,qBAAA,GACA,uBAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;KA0BY,kBAAA,GAAqB,WAAA;AAAA,KACrB,aAAA,GAAgB,QAAA;AAD5B;;;AAAA,KAMY,aAAA;;AALZ;;KAkBY,OAAA,GAAU,aAAA;AAAA,UAEL,cAAA;EACf,IAAA;EACA,MAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA,GAAQ,cAAA,GAAiB,cAAA;EACzB,UAAA,GAAa,MAAA,SAAe,cAAA;EAC5B,iBAAA,GAAoB,MAAA,SAAe,cAAA;EACnC,oBAAA,aAAiC,cAAA;EACjC,QAAA;EACA,KAAA,GAAQ,cAAA;EACR,KAAA,GAAQ,cAAA;EACR,KAAA,GAAQ,cAAA;EACR,IAAA;EACA,WAAA;EACA,KAAA;EACA,OAAA;EACA,QAAA;EACA,OAAA;EACA,OAAA;EACA,gBAAA;EACA,gBAAA;EACA,QAAA;EACA,WAAA,GAAc,MAAA,SAAe,cAAA;EAC7B,KAAA,GAAQ,MAAA,SAAe,cAAA;EACvB,aAAA;IAAkB,YAAA;EAAA;EAAA,CACjB,GAAA;AAAA;AAAA,KAGS,mBAAA;AAAA,KAQA,kBAAA,GAAqB,mBAAA;AAAA,KAErB,iBAAA,wBAEA,MAAA,oBAA0B,MAAA,qBAElC,oBAAA,GACA,aAAA,CAAc,CAAA,EAAG,CAAA,IACjB,cAAA,GACA,EAAA,CAAG,UAAA,GACH,kBAAA,GACA,aAAA,GACA,IAAA;AAAA,KAEQ,uBAAA,GAA0B,cAAA;AAAA,KAE1B,WAAA,GAAc,iBAAA,GAAoB,MAAA,GAAS,uBAAA;AAAA,UAEtC,MAAA,wBAEL,MAAA,oBAA0B,MAAA;EAEpC,IAAA;EACA,OAAA,EAAS,kBAAA;EACT,MAAA,EAAQ,aAAA,CAAc,CAAA,EAAG,CAAA;AAAA;AAAA,UAGV,gBAAA;EACf,IAAA;EACA,OAAA,EAAS,mBAAA;EACT,MAAA,EAAQ,iBAAA;AAAA;AAAA,UAGO,qBAAA,wBAEL,MAAA,oBAA0B,MAAA,2BAC5B,gBAAA;EACR,OAAA;EACA,MAAA,EAAQ,aAAA,CAAc,CAAA,EAAG,CAAA;AAAA;AAAA,UAGV,sBAAA,SAA+B,gBAAA;EAC9C,OAAA;EACA,MAAA,EAAQ,cAAA;AAAA;AAAA,UAGO,0BAAA,SAAmC,gBAAA;EAClD,OAAA;EACA,MAAA,EAAQ,oBAAA;AAAA;AAAA,UAGO,gBAAA,SAAyB,gBAAA;EACxC,OAAA;EACA,MAAA,EAAQ,EAAA,CAAG,UAAA;AAAA;AAAA,UAGI,sBAAA,SAA+B,gBAAA;EAC9C,OAAA;EACA,MAAA,EAAQ,IAAA;AAAA;AAAA,UAGO,mBAAA,SAA4B,gBAAA;EAC3C,OAAA;EACA,MAAA,EAAQ,kBAAA,GAAqB,aAAA;AAAA;AAAA,KAGnB,YAAA,GACR,sBAAA,GACA,qBAAA,GACA,0BAAA,GACA,gBAAA,GACA,mBAAA,GACA,sBAAA;AAAA,UAEa,eAAA,wBAEL,MAAA,oBAA0B,MAAA,2BAC5B,MAAA,CAAO,CAAA,EAAG,CAAA;EAClB,MAAA,EAAQ,YAAA;AAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerlines/schema",
-  "version": "0.8.67",
+  "version": "0.9.0",
   "private": false,
   "description": "A package containing a Powerlines plugin to assist in developing other Powerlines plugins.",
   "keywords": [
@@ -58,10 +58,7 @@
       "import": "./dist/extract.mjs",
       "require": "./dist/extract.cjs"
     },
-    "./is-schema-definition": {
-      "import": "./dist/is-schema-definition.mjs",
-      "require": "./dist/is-schema-definition.cjs"
-    },
+    "./jtd": { "import": "./dist/jtd.mjs", "require": "./dist/jtd.cjs" },
     "./reflection": {
       "import": "./dist/reflection.mjs",
       "require": "./dist/reflection.cjs"
@@ -70,6 +67,10 @@
       "import": "./dist/resolve.mjs",
       "require": "./dist/resolve.cjs"
     },
+    "./type-checks": {
+      "import": "./dist/type-checks.mjs",
+      "require": "./dist/type-checks.cjs"
+    },
     "./types": { "import": "./dist/types.mjs", "require": "./dist/types.cjs" },
     "./package.json": "./package.json"
   },
@@ -79,25 +80,26 @@
   "typings": "dist/index.d.mts",
   "files": ["dist"],
   "dependencies": {
-    "@powerlines/core": "^0.8.67",
-    "@powerlines/deepkit": "^0.8.67",
-    "@powerlines/unplugin": "^0.0.12",
+    "@powerlines/core": "^0.9.0",
+    "@powerlines/deepkit": "^0.9.0",
+    "@powerlines/unplugin": "^0.0.13",
     "@standard-schema/spec": "^1.1.0",
-    "@standard-schema/utils": "^0.3.0",
-    "@stryke/fs": "^0.33.75",
-    "@stryke/helpers": "^0.10.15",
-    "@stryke/json": "^0.14.20",
-    "@stryke/path": "^0.29.2",
-    "@stryke/type-checks": "^0.6.8",
-    "@stryke/types": "^0.12.3",
-    "@stryke/zod": "^0.3.21",
+    "@stryke/hash": "^0.13.29",
+    "@stryke/helpers": "^0.10.16",
+    "@stryke/json": "^0.15.0",
+    "@stryke/path": "^0.29.3",
+    "@stryke/type-checks": "^0.6.9",
+    "@stryke/types": "^0.12.4",
+    "@stryke/zod": "^0.3.22",
+    "ajv": "^8.20.0",
     "defu": "^6.1.7",
     "esbuild": "^0.27.7",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "untyped": "^1.5.2"
   },
-  "devDependencies": { "zod": "^4.4.3", "@types/node": "^25.7.0" },
+  "devDependencies": { "@types/node": "^25.8.0", "zod": "^4.4.3" },
   "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" },
   "peerDependenciesMeta": { "zod": { "optional": true } },
   "publishConfig": { "access": "public" },
-  "gitHead": "0f124460d57d8b7396173bb00db5d73c1c32f473"
+  "gitHead": "8e3c08ac9b40e909814a16d808fae1a98d392d65"
 }