@powerlines/schema 0.11.1 → 0.11.2

package/dist/resolve.d.mts

@@ -1,7 +1,7 @@
 import { BundleOptions } from "./bundle.mjs";
-import { PluginContext } from "@powerlines/core";
+import { TypeDefinitionReference } from "./types.mjs";
+import { PluginContext, UnresolvedContext } from "@powerlines/core";
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { TypeDefinitionParameter } from "@stryke/types/configuration";
 
 //#region src/resolve.d.ts
 /**
@@ -12,7 +12,7 @@ import { TypeDefinitionParameter } from "@stryke/types/configuration";
  * @param overrides - Optional overrides for the ESBuild configuration.
  * @returns A promise that resolves to the compiled module.
  */
-declare function resolveModule<TResult, TContext extends PluginContext = PluginContext>(context: TContext, type: TypeDefinitionParameter, overrides?: BundleOptions): Promise<TResult>;
+declare function resolveModule<TResult, TContext extends UnresolvedContext = UnresolvedContext>(context: TContext, type: TypeDefinitionReference, overrides?: BundleOptions): Promise<TResult>;
 /**
  * Compiles a type definition to a module and returns the specified export from the module.
  *
@@ -21,7 +21,7 @@ declare function resolveModule<TResult, TContext extends PluginContext = PluginC
  * @param options - Optional overrides for the ESBuild configuration.
  * @returns A promise that resolves to the compiled module.
  */
-declare function resolve<TResult, TContext extends PluginContext = PluginContext>(context: TContext, input: TypeDefinitionParameter, options?: BundleOptions): Promise<TResult>;
+declare function resolve<TResult, TContext extends UnresolvedContext = UnresolvedContext>(context: TContext, input: TypeDefinitionReference, options?: BundleOptions): Promise<TResult>;
 /**
  * Resolves a type definition to a Deepkit Type reflection. This function compiles the provided type definition to a module, evaluates the module to get the specified export, and then reflects the export to get its Deepkit Type reflection.
  *
@@ -30,7 +30,7 @@ declare function resolve<TResult, TContext extends PluginContext = PluginContext
  * @param options - Optional overrides for the ESBuild configuration.
  * @returns A promise that resolves to the Deepkit Type reflection.
  */
-declare function resolveReflection<TContext extends PluginContext = PluginContext>(context: TContext, input: TypeDefinitionParameter, options?: BundleOptions): Promise<Type>;
+declare function resolveReflection<TContext extends PluginContext = PluginContext>(context: TContext, input: TypeDefinitionReference, options?: BundleOptions): Promise<Type>;
 //#endregion
 export { resolve, resolveModule, resolveReflection };
 //# sourceMappingURL=resolve.d.mts.map

package/dist/resolve.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.mts","names":[],"sources":["../src/resolve.ts"],"mappings":";;;;;;;;AAuCA;;;;;;iBAAsB,aAAA,2BAEH,aAAA,GAAgB,aAAA,CAAA,CAEjC,OAAA,EAAS,QAAA,EACT,IAAA,EAAM,uBAAA,EACN,SAAA,GAAY,aAAA,GACX,OAAA,CAAQ,OAAA;;;;;;;;;iBAyEW,OAAA,2BAEH,aAAA,GAAgB,aAAA,CAAA,CAEjC,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,aAAA,GACT,OAAA,CAAQ,OAAA;;;;;;;;;iBAiDW,iBAAA,kBACH,aAAA,GAAgB,aAAA,CAAA,CAEjC,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,aAAA,GACT,OAAA,CAAQ,IAAA"}
+{"version":3,"file":"resolve.d.mts","names":[],"sources":["../src/resolve.ts"],"mappings":";;;;;;;;AAqCA;;;;;;iBAAsB,aAAA,2BAEH,iBAAA,GAAoB,iBAAA,CAAA,CAErC,OAAA,EAAS,QAAA,EACT,IAAA,EAAM,uBAAA,EACN,SAAA,GAAY,aAAA,GACX,OAAA,CAAQ,OAAA;;;;;;;;;iBAyEW,OAAA,2BAEH,iBAAA,GAAoB,iBAAA,CAAA,CAErC,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,aAAA,GACT,OAAA,CAAQ,OAAA;;;;;;;;;iBAiDW,iBAAA,kBACH,aAAA,GAAgB,aAAA,CAAA,CAEjC,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,aAAA,GACT,OAAA,CAAQ,IAAA"}

package/dist/resolve.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.mjs","names":[],"sources":["../src/resolve.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 { PluginContext } from \"@powerlines/core\";\nimport { esbuildPlugin } from \"@powerlines/deepkit/esbuild-plugin\";\nimport { reflect, Type } from \"@powerlines/deepkit/vendor/type\";\nimport { parseTypeDefinition } from \"@stryke/convert/parse-type-definition\";\nimport { findFileDotExtension } from \"@stryke/path/find\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport {\n  TypeDefinition,\n  TypeDefinitionParameter\n} from \"@stryke/types/configuration\";\nimport defu from \"defu\";\nimport { bundle, BundleOptions } from \"./bundle\";\n\n/**\n * Compiles a type definition to a module and returns the module.\n *\n * @param context - The context object containing the environment paths.\n * @param type - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param overrides - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the compiled module.\n */\nexport async function resolveModule<\n  TResult,\n  TContext extends PluginContext = PluginContext\n>(\n  context: TContext,\n  type: TypeDefinitionParameter,\n  overrides?: BundleOptions\n): Promise<TResult> {\n  let typeDefinition!: TypeDefinition;\n  if (isSetString(type)) {\n    typeDefinition = parseTypeDefinition(type) as TypeDefinition;\n  } else {\n    typeDefinition = type;\n  }\n\n  const result = await bundle<TContext>(\n    context,\n    typeDefinition.file,\n    overrides\n  );\n\n  let resolved: any;\n  try {\n    resolved = await context.resolver.evalModule(result.text, {\n      filename: result.path,\n      ext: findFileDotExtension(result.path)\n    });\n  } catch (error) {\n    if (\n      isSetString((error as Error).message) &&\n      new RegExp(\n        `Cannot find module '${context.config.framework?.name || \"powerlines\"}:.*'`\n      ).test((error as Error).message)\n    ) {\n      const moduleName = (error as Error).message.match(\n        new RegExp(\n          `Cannot find module '(${context.config.framework?.name || \"powerlines\"}:.*)'`\n        )\n      )?.[1];\n      throw new Error(\n        `The module \"${moduleName}\" could not be resolved while evaluating \"${\n          typeDefinition.file\n        }\". It is possible the required built-in modules have not yet been generated. Please check the order of your plugins. ${\n          context.config.logLevel.general === \"debug\" ||\n          context.config.logLevel.general === \"trace\"\n            ? `\n\nBundle output for module:\n${result.text}`\n            : \"\"\n        }`\n      );\n    }\n\n    throw new Error(\n      `Failed to evaluate the bundled module for \"${\n        typeDefinition.file\n      }\". Error: ${(error as Error).message}${\n        context.config.logLevel.general === \"debug\" ||\n        context.config.logLevel.general === \"trace\"\n          ? `\n\nBundle output for module:\n${result.text}`\n          : \"\"\n      }`\n    );\n  }\n\n  return resolved;\n}\n\n/**\n * Compiles a type definition to a module and returns the specified export from the module.\n *\n * @param context - The context object containing the environment paths.\n * @param input - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the compiled module.\n */\nexport async function resolve<\n  TResult,\n  TContext extends PluginContext = PluginContext\n>(\n  context: TContext,\n  input: TypeDefinitionParameter,\n  options?: BundleOptions\n): Promise<TResult> {\n  let typeDefinition!: TypeDefinition;\n  if (isSetString(input)) {\n    typeDefinition = parseTypeDefinition(input) as TypeDefinition;\n  } else {\n    typeDefinition = input;\n  }\n\n  const resolved = await resolveModule<Record<string, any>, TContext>(\n    context,\n    typeDefinition,\n    options\n  );\n\n  let exportName = typeDefinition.name;\n  if (!exportName) {\n    exportName = \"default\";\n  }\n\n  const resolvedExport = resolved[exportName] ?? resolved[`__Ω${exportName}`];\n  if (resolvedExport === undefined) {\n    throw new Error(\n      `The export \"${exportName}\" could not be resolved in the \"${\n        typeDefinition.file\n      }\" module. ${\n        Object.keys(resolved).length === 0\n          ? `After bundling, no exports were found in the module. Please ensure that the \"${\n              typeDefinition.file\n            }\" module has a \"${exportName}\" export with the desired value.`\n          : `After bundling, the available exports were: ${Object.keys(\n              resolved\n            ).join(\n              \", \"\n            )}. Please ensure that the export exists and is correctly named.`\n      }`\n    );\n  }\n\n  return resolvedExport;\n}\n\n/**\n * Resolves a type definition to a Deepkit Type reflection. This function compiles the provided type definition to a module, evaluates the module to get the specified export, and then reflects the export to get its Deepkit Type reflection.\n *\n * @param context - The context object containing the environment paths.\n * @param input - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the Deepkit Type reflection.\n */\nexport async function resolveReflection<\n  TContext extends PluginContext = PluginContext\n>(\n  context: TContext,\n  input: TypeDefinitionParameter,\n  options?: BundleOptions\n): Promise<Type> {\n  return reflect(\n    await resolve<Type>(\n      context,\n      input,\n      defu(options, {\n        plugins: [\n          esbuildPlugin(context, {\n            reflection: \"default\",\n            level: \"all\"\n          })\n        ]\n      })\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAuCA,eAAsB,cAIpB,SACA,MACA,WACkB;CAClB,IAAI;AACJ,KAAI,YAAY,KAAK,CACnB,kBAAiB,oBAAoB,KAAK;KAE1C,kBAAiB;CAGnB,MAAM,SAAS,MAAM,OACnB,SACA,eAAe,MACf,UACD;CAED,IAAI;AACJ,KAAI;AACF,aAAW,MAAM,QAAQ,SAAS,WAAW,OAAO,MAAM;GACxD,UAAU,OAAO;GACjB,KAAK,qBAAqB,OAAO,KAAK;GACvC,CAAC;UACK,OAAO;AACd,MACE,YAAa,MAAgB,QAAQ,IACrC,IAAI,OACF,uBAAuB,QAAQ,OAAO,WAAW,QAAQ,aAAa,MACvE,CAAC,KAAM,MAAgB,QAAQ,EAChC;GACA,MAAM,aAAc,MAAgB,QAAQ,MAC1C,IAAI,OACF,wBAAwB,QAAQ,OAAO,WAAW,QAAQ,aAAa,OACxE,CACF,GAAG;AACJ,SAAM,IAAI,MACR,eAAe,WAAW,4CACxB,eAAe,KAChB,uHACC,QAAQ,OAAO,SAAS,YAAY,WACpC,QAAQ,OAAO,SAAS,YAAY,UAChC;;;EAGZ,OAAO,SACK,KAEP;;AAGH,QAAM,IAAI,MACR,8CACE,eAAe,KAChB,YAAa,MAAgB,UAC5B,QAAQ,OAAO,SAAS,YAAY,WACpC,QAAQ,OAAO,SAAS,YAAY,UAChC;;;EAGV,OAAO,SACG,KAEP;;AAGH,QAAO;;;;;;;;;;AAWT,eAAsB,QAIpB,SACA,OACA,SACkB;CAClB,IAAI;AACJ,KAAI,YAAY,MAAM,CACpB,kBAAiB,oBAAoB,MAAM;KAE3C,kBAAiB;CAGnB,MAAM,WAAW,MAAM,cACrB,SACA,gBACA,QACD;CAED,IAAI,aAAa,eAAe;AAChC,KAAI,CAAC,WACH,cAAa;CAGf,MAAM,iBAAiB,SAAS,eAAe,SAAS,MAAM;AAC9D,KAAI,mBAAmB,OACrB,OAAM,IAAI,MACR,eAAe,WAAW,kCACxB,eAAe,KAChB,YACC,OAAO,KAAK,SAAS,CAAC,WAAW,IAC7B,gFACE,eAAe,KAChB,kBAAkB,WAAW,oCAC9B,+CAA+C,OAAO,KACpD,SACD,CAAC,KACA,KACD,CAAC,kEAET;AAGH,QAAO;;;;;;;;;;AAWT,eAAsB,kBAGpB,SACA,OACA,SACe;AACf,QAAO,QACL,MAAM,QACJ,SACA,OACA,KAAK,SAAS,EACZ,SAAS,CACP,cAAc,SAAS;EACrB,YAAY;EACZ,OAAO;EACR,CAAC,CACH,EACF,CAAC,CACH,CACF"}
+{"version":3,"file":"resolve.mjs","names":[],"sources":["../src/resolve.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 { PluginContext, UnresolvedContext } from \"@powerlines/core\";\nimport { esbuildPlugin } from \"@powerlines/deepkit/esbuild-plugin\";\nimport { reflect, Type } from \"@powerlines/deepkit/vendor/type\";\nimport { parseTypeDefinition } from \"@stryke/convert/parse-type-definition\";\nimport { findFileDotExtension } from \"@stryke/path/find\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport { TypeDefinition } from \"@stryke/types/configuration\";\nimport defu from \"defu\";\nimport { bundle, BundleOptions } from \"./bundle\";\nimport { TypeDefinitionReference } from \"./types\";\n\n/**\n * Compiles a type definition to a module and returns the module.\n *\n * @param context - The context object containing the environment paths.\n * @param type - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param overrides - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the compiled module.\n */\nexport async function resolveModule<\n  TResult,\n  TContext extends UnresolvedContext = UnresolvedContext\n>(\n  context: TContext,\n  type: TypeDefinitionReference,\n  overrides?: BundleOptions\n): Promise<TResult> {\n  let typeDefinition!: TypeDefinition;\n  if (isSetString(type)) {\n    typeDefinition = parseTypeDefinition(type) as TypeDefinition;\n  } else {\n    typeDefinition = type;\n  }\n\n  const result = await bundle<TContext>(\n    context,\n    typeDefinition.file,\n    overrides\n  );\n\n  let resolved: any;\n  try {\n    resolved = await context.resolver.evalModule(result.text, {\n      filename: result.path,\n      ext: findFileDotExtension(result.path)\n    });\n  } catch (error) {\n    if (\n      isSetString((error as Error).message) &&\n      new RegExp(\n        `Cannot find module '${context.config.framework?.name || \"powerlines\"}:.*'`\n      ).test((error as Error).message)\n    ) {\n      const moduleName = (error as Error).message.match(\n        new RegExp(\n          `Cannot find module '(${context.config.framework?.name || \"powerlines\"}:.*)'`\n        )\n      )?.[1];\n      throw new Error(\n        `The module \"${moduleName}\" could not be resolved while evaluating \"${\n          typeDefinition.file\n        }\". It is possible the required built-in modules have not yet been generated. Please check the order of your plugins. ${\n          context.config.logLevel.general === \"debug\" ||\n          context.config.logLevel.general === \"trace\"\n            ? `\n\nBundle output for module:\n${result.text}`\n            : \"\"\n        }`\n      );\n    }\n\n    throw new Error(\n      `Failed to evaluate the bundled module for \"${\n        typeDefinition.file\n      }\". Error: ${(error as Error).message}${\n        context.config.logLevel.general === \"debug\" ||\n        context.config.logLevel.general === \"trace\"\n          ? `\n\nBundle output for module:\n${result.text}`\n          : \"\"\n      }`\n    );\n  }\n\n  return resolved;\n}\n\n/**\n * Compiles a type definition to a module and returns the specified export from the module.\n *\n * @param context - The context object containing the environment paths.\n * @param input - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the compiled module.\n */\nexport async function resolve<\n  TResult,\n  TContext extends UnresolvedContext = UnresolvedContext\n>(\n  context: TContext,\n  input: TypeDefinitionReference,\n  options?: BundleOptions\n): Promise<TResult> {\n  let typeDefinition!: TypeDefinition;\n  if (isSetString(input)) {\n    typeDefinition = parseTypeDefinition(input) as TypeDefinition;\n  } else {\n    typeDefinition = input;\n  }\n\n  const resolved = await resolveModule<Record<string, any>, TContext>(\n    context,\n    typeDefinition,\n    options\n  );\n\n  let exportName = typeDefinition.name;\n  if (!exportName) {\n    exportName = \"default\";\n  }\n\n  const resolvedExport = resolved[exportName] ?? resolved[`__Ω${exportName}`];\n  if (resolvedExport === undefined) {\n    throw new Error(\n      `The export \"${exportName}\" could not be resolved in the \"${\n        typeDefinition.file\n      }\" module. ${\n        Object.keys(resolved).length === 0\n          ? `After bundling, no exports were found in the module. Please ensure that the \"${\n              typeDefinition.file\n            }\" module has a \"${exportName}\" export with the desired value.`\n          : `After bundling, the available exports were: ${Object.keys(\n              resolved\n            ).join(\n              \", \"\n            )}. Please ensure that the export exists and is correctly named.`\n      }`\n    );\n  }\n\n  return resolvedExport;\n}\n\n/**\n * Resolves a type definition to a Deepkit Type reflection. This function compiles the provided type definition to a module, evaluates the module to get the specified export, and then reflects the export to get its Deepkit Type reflection.\n *\n * @param context - The context object containing the environment paths.\n * @param input - The type definition to compile. This can be either a string or a {@link TypeDefinition} object.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the Deepkit Type reflection.\n */\nexport async function resolveReflection<\n  TContext extends PluginContext = PluginContext\n>(\n  context: TContext,\n  input: TypeDefinitionReference,\n  options?: BundleOptions\n): Promise<Type> {\n  return reflect(\n    await resolve<Type>(\n      context,\n      input,\n      defu(options, {\n        plugins: [\n          esbuildPlugin(context, {\n            reflection: \"default\",\n            level: \"all\"\n          })\n        ]\n      })\n    )\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqCA,eAAsB,cAIpB,SACA,MACA,WACkB;CAClB,IAAI;AACJ,KAAI,YAAY,KAAK,CACnB,kBAAiB,oBAAoB,KAAK;KAE1C,kBAAiB;CAGnB,MAAM,SAAS,MAAM,OACnB,SACA,eAAe,MACf,UACD;CAED,IAAI;AACJ,KAAI;AACF,aAAW,MAAM,QAAQ,SAAS,WAAW,OAAO,MAAM;GACxD,UAAU,OAAO;GACjB,KAAK,qBAAqB,OAAO,KAAK;GACvC,CAAC;UACK,OAAO;AACd,MACE,YAAa,MAAgB,QAAQ,IACrC,IAAI,OACF,uBAAuB,QAAQ,OAAO,WAAW,QAAQ,aAAa,MACvE,CAAC,KAAM,MAAgB,QAAQ,EAChC;GACA,MAAM,aAAc,MAAgB,QAAQ,MAC1C,IAAI,OACF,wBAAwB,QAAQ,OAAO,WAAW,QAAQ,aAAa,OACxE,CACF,GAAG;AACJ,SAAM,IAAI,MACR,eAAe,WAAW,4CACxB,eAAe,KAChB,uHACC,QAAQ,OAAO,SAAS,YAAY,WACpC,QAAQ,OAAO,SAAS,YAAY,UAChC;;;EAGZ,OAAO,SACK,KAEP;;AAGH,QAAM,IAAI,MACR,8CACE,eAAe,KAChB,YAAa,MAAgB,UAC5B,QAAQ,OAAO,SAAS,YAAY,WACpC,QAAQ,OAAO,SAAS,YAAY,UAChC;;;EAGV,OAAO,SACG,KAEP;;AAGH,QAAO;;;;;;;;;;AAWT,eAAsB,QAIpB,SACA,OACA,SACkB;CAClB,IAAI;AACJ,KAAI,YAAY,MAAM,CACpB,kBAAiB,oBAAoB,MAAM;KAE3C,kBAAiB;CAGnB,MAAM,WAAW,MAAM,cACrB,SACA,gBACA,QACD;CAED,IAAI,aAAa,eAAe;AAChC,KAAI,CAAC,WACH,cAAa;CAGf,MAAM,iBAAiB,SAAS,eAAe,SAAS,MAAM;AAC9D,KAAI,mBAAmB,OACrB,OAAM,IAAI,MACR,eAAe,WAAW,kCACxB,eAAe,KAChB,YACC,OAAO,KAAK,SAAS,CAAC,WAAW,IAC7B,gFACE,eAAe,KAChB,kBAAkB,WAAW,oCAC9B,+CAA+C,OAAO,KACpD,SACD,CAAC,KACA,KACD,CAAC,kEAET;AAGH,QAAO;;;;;;;;;;AAWT,eAAsB,kBAGpB,SACA,OACA,SACe;AACf,QAAO,QACL,MAAM,QACJ,SACA,OACA,KAAK,SAAS,EACZ,SAAS,CACP,cAAc,SAAS;EACrB,YAAY;EACZ,OAAO;EACR,CAAC,CACH,EACF,CAAC,CACH,CACF"}

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, SchemaMetadata } from "./types.cjs";
+import { InputObject, Schema } from "untyped";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
+
+//#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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is JTDSchemaType<TMetadata>;
+/**
+ * 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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is Schema$1<TMetadata>;
+/**
+ * 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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is ExtractedSchema<TMetadata>;
+//#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,mBAA8B,cAAA,GAAiB,cAAA,CAAA,CAC7D,KAAA,YACC,KAAA,IAAS,aAAA,CAAc,SAAA;;;;;;;iBAUV,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAA;;;;;;;iBAwD1C,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAA;;;;;;;iBAsBzC,QAAA,mBAA2B,cAAA,GAAiB,cAAA,CAAA,CAC1D,KAAA,YACC,KAAA,IAAS,QAAA,CAAO,SAAA;;AAxBnB;;;;;iBA0CgB,iBAAA,mBACI,cAAA,GAAiB,cAAA,CAAA,CACnC,KAAA,YAAiB,KAAA,IAAS,eAAA,CAAgB,SAAA"}

package/dist/type-checks.d.mts

@@ -0,0 +1,43 @@
+import { ExtractedSchema, Schema as Schema$1, SchemaMetadata } from "./types.mjs";
+import { InputObject, Schema } from "untyped";
+import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
+
+//#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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is JTDSchemaType<TMetadata>;
+/**
+ * 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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is Schema$1<TMetadata>;
+/**
+ * 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<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is ExtractedSchema<TMetadata>;
+//#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,mBAA8B,cAAA,GAAiB,cAAA,CAAA,CAC7D,KAAA,YACC,KAAA,IAAS,aAAA,CAAc,SAAA;;;;;;;iBAUV,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAA;;;;;;;iBAwD1C,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAA;;;;;;;iBAsBzC,QAAA,mBAA2B,cAAA,GAAiB,cAAA,CAAA,CAC1D,KAAA,YACC,KAAA,IAAS,QAAA,CAAO,SAAA;;AAxBnB;;;;;iBA0CgB,iBAAA,mBACI,cAAA,GAAiB,cAAA,CAAA,CACnC,KAAA,YAAiB,KAAA,IAAS,eAAA,CAAgB,SAAA"}

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, SchemaMetadata } 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<TMetadata extends SchemaMetadata = SchemaMetadata>(\n  input: unknown\n): input is JTDSchemaType<TMetadata> {\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<TMetadata extends SchemaMetadata = SchemaMetadata>(\n  input: unknown\n): input is Schema<TMetadata> {\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  TMetadata extends SchemaMetadata = SchemaMetadata\n>(input: unknown): input is ExtractedSchema<TMetadata> {\n  return (\n    isSchema<TMetadata>(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,YACd,OACmC;AACnC,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,SACd,OAC4B;AAC5B,QACE,YAAY,MAAM,IAClB,YAAY,SACZ,YAAY,MAAM,OAAO,IACzB,WAAW,SACX,YAAY,MAAM,MAAM,IACxB,aAAa,SACb,YAAY,MAAM,QAAQ;;;;;;;;AAU9B,SAAgB,kBAEd,OAAqD;AACrD,QACE,SAAoB,MAAM,IAC1B,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,181 @@
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
 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 string `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JTDStringType = "string" | "timestamp";
+/**
+ * The set of `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JTDType = JTDNumberType | JTDStringType | "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;
+}
+interface SchemaMetadata {
+  /**
+   * A title for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  title?: string;
+  /**
+   * A description for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable explanation or summary of the schema's purpose and usage. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  description?: string;
+  /**
+   * A default value for the schema, which can be used by validation libraries or other tools that support this feature. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  default?: unknown;
+  /**
+   * An array of example values that conform to the schema. This property can be used to provide sample data for documentation purposes or to assist developers in understanding the expected structure and content of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  examples?: unknown[];
+  /**
+   * A table name for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  table?: string;
+  /**
+   * An indicator specifying if the field should be marked as hidden or not.
+   */
+  isHidden?: boolean;
+  /**
+   * An indicator specifying if the field should be ignored or not.
+   */
+  isIgnored?: boolean;
+  /**
+   * An indicator specifying if the field is internal or not.
+   *
+   * @internal
+   */
+  isInternal?: boolean;
+  /**
+   * An indicator specifying if the field should only be populated at runtime or not.
+   */
+  isRuntime?: boolean;
+  /**
+   * An indicator specifying if the field is read-only or not. This property can be used to indicate that a field should not be modified after it has been set, which can be useful for documentation purposes or to assist developers in understanding the expected behavior of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  isReadonly?: boolean;
+  /**
+   * An indicator specifying if the field is a primary key or not. This property can be used to indicate that a field serves as a unique identifier for records in a dataset, which can be useful for documentation purposes or to assist developers in understanding the expected structure and behavior of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  isPrimaryKey?: boolean;
+  /**
+   * An array of strings or an alias reference to indicate that the field is an alias for one or more other fields. This property can be used to provide alternative names or references for a field, which can be useful for documentation purposes or to assist developers in understanding the expected structure and content of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  alias?: string[];
+  /**
+   * Schemas that are unioned together to form a single schema. This property can be used to represent complex data structures that can conform to multiple different schemas. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  union?: JsonSchemaLike[];
+  [key: string]: unknown | undefined;
+}
+type JTDSchemaType<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> = ({
+  ref: string;
+} | {
+  type: JTDType;
+} | {
+  enum: string[];
+} | {
+  elements: JTDSchemaType<TMetadata>;
+} | {
+  values: JTDSchemaType<TMetadata>;
+} | {
+  properties: Record<string, JTDSchemaType<TMetadata>>;
+  optionalProperties?: Record<string, JTDSchemaType<TMetadata>>;
+  additionalProperties?: boolean;
+} | {
+  properties?: Record<string, JTDSchemaType<TMetadata>>;
+  optionalProperties: Record<string, JTDSchemaType<TMetadata>>;
+  additionalProperties?: boolean;
+} | {
+  discriminator: string;
+  mapping: Record<string, JTDSchemaType<TMetadata>>;
+} | {}) & {
+  nullable?: boolean;
+  metadata?: TMetadata;
+  definitions?: Record<string, JTDSchemaType<TMetadata>>;
+};
+type SchemaSourceVariant = "standard-schema" | "jtd-schema" | "json-schema" | "zod3" | "untyped" | "reflection";
+type SchemaInputVariant = SchemaSourceVariant | "type-definition";
+type SchemaSourceInput<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> = StandardJSONSchemaV1 | JTDSchemaType<TMetadata> | JsonSchemaType | z3.ZodTypeAny | UntypedInputObject | UntypedSchema | Type;
+type TypeDefinitionReference = TypeDefinition | string;
+type SchemaInput = SchemaSourceInput | Schema | TypeDefinitionReference;
+interface Schema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> {
+  hash: string;
+  variant: SchemaInputVariant;
+  schema: JTDSchemaType<TMetadata>;
+}
+interface BaseSchemaSource {
+  hash: string;
+  variant: SchemaSourceVariant;
+  schema: SchemaSourceInput;
+}
+interface JTDSchemaSchemaSource<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> extends BaseSchemaSource {
+  variant: "jtd-schema";
+  schema: JTDSchemaType<TMetadata>;
+}
+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<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> extends Schema<TMetadata> {
+  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, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, 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":";;;;;;;;KAyBY,kBAAA,GAAqB,WAAA;AAAA,KACrB,aAAA,GAAgB,QAAA;AAD5B;;;AAAA,KAMY,aAAA;;AALZ;;KAkBY,aAAA;;;AAbZ;KAkBY,OAAA,GAAU,aAAA,GAAgB,aAAA;AAAA,UAErB,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,UAGc,cAAA;EALD;;;EASd,KAAA;EA7BA;;;EAkCA,WAAA;EAhCA;;;EAqCA,OAAA;EApCoB;;;EAyCpB,QAAA;EAvCA;;;EA4CA,KAAA;EA1CQ;;;EA+CR,QAAA;EA5CA;;;EAiDA,SAAA;EA7CA;;;;;EAoDA,UAAA;EA/Cc;;;EAoDd,SAAA;EAnDuB;;;EAwDvB,UAAA;EAtDY;;AAGd;EAwDE,YAAA;;;;EAKA,KAAA;EA/CA;;;EAoDA,KAAA,GAAQ,cAAA;EAAA,CAEP,GAAA;AAAA;AAAA,KAGS,aAAA,mBACQ,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA;EAGhD,GAAA;AAAA;EAGA,IAAA,EAAM,OAAA;AAAA;EAGN,IAAA;AAAA;EAGA,QAAA,EAAU,aAAA,CAAc,SAAA;AAAA;EAGxB,MAAA,EAAQ,aAAA,CAAc,SAAA;AAAA;EAGtB,UAAA,EAAY,MAAA,SAAe,aAAA,CAAc,SAAA;EACzC,kBAAA,GAAqB,MAAA,SAAe,aAAA,CAAc,SAAA;EAClD,oBAAA;AAAA;EAGA,UAAA,GAAa,MAAA,SAAe,aAAA,CAAc,SAAA;EAC1C,kBAAA,EAAoB,MAAA,SAAe,aAAA,CAAc,SAAA;EACjD,oBAAA;AAAA;EAGA,aAAA;EACA,OAAA,EAAS,MAAA,SAAe,aAAA,CAAc,SAAA;AAAA;EAK1C,QAAA;EACA,QAAA,GAAW,SAAA;EACX,WAAA,GAAc,MAAA,SAAe,aAAA,CAAc,SAAA;AAAA;AAAA,KAGjC,mBAAA;AAAA,KAQA,kBAAA,GAAqB,mBAAA;AAAA,KAErB,iBAAA,mBACQ,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAElD,oBAAA,GACA,aAAA,CAAc,SAAA,IACd,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,mBACG,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA;EAEpD,IAAA;EACA,OAAA,EAAS,kBAAA;EACT,MAAA,EAAQ,aAAA,CAAc,SAAA;AAAA;AAAA,UAGP,gBAAA;EACf,IAAA;EACA,OAAA,EAAS,mBAAA;EACT,MAAA,EAAQ,iBAAA;AAAA;AAAA,UAGO,qBAAA,mBACG,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,WAC5C,gBAAA;EACR,OAAA;EACA,MAAA,EAAQ,aAAA,CAAc,SAAA;AAAA;AAAA,UAGP,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,mBACG,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,WAC5C,MAAA,CAAO,SAAA;EACf,MAAA,EAAQ,YAAA;AAAA"}