schemair 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { $ as SchemaRecordField, A as SchemaValueTypeTerm, B as JsonValue, C as SchemaValueMaybeAbsentExpr, D as SchemaValueTaggedUnionExpr, E as SchemaValueRecordExpr, F as OperationChannelDefinition, G as SchemaConstraint, H as PrimitiveName, I as OperationContainerDefinition, J as SchemaNode, K as SchemaLiteralNode, L as OperationDefinition, M as SchemaVariantSelector, N as Operation, O as SchemaValueTupleExpr, P as OperationBinaryMetadata, Q as SchemaPrimitiveNode, R as OperationErrorDefinition, S as SchemaValueArrayExpr, T as SchemaValueNullableExpr, U as SchemaArrayNode, V as LiteralValue, W as SchemaBooleanNode, X as SchemaNullableNode, Y as SchemaNullNode, Z as SchemaNumberNode, _ as SchemaTypeRefineExpr, a as SchemaTypeElementAtExpr, at as SchemaTaggedUnionVariant, b as SchemaTypeVariableExpr, c as SchemaTypeExtractVariantsExpr, d as SchemaTypeIntersectExpr, et as SchemaRecordNode, f as SchemaTypeKeyOfExpr, g as SchemaTypePickFieldsExpr, h as SchemaTypePartialFieldsExpr, i as SchemaFieldSelector, it as SchemaTaggedUnionNode, j as SchemaValueUnknownExpr, k as SchemaValueTypeExpr, l as SchemaTypeFieldOfExpr, m as SchemaTypeOmitFieldsExpr, n as ExpressionArgument, nt as SchemaSelfRefNode, o as SchemaTypeElementOfExpr, ot as SchemaTupleNode, p as SchemaTypeMergeRecordsExpr, q as SchemaLiteralUnionNode, r as OpaqueHostTypeExpr, rt as SchemaStringNode, s as SchemaTypeExcludeVariantsExpr, t as Expression, tt as SchemaRefNode, u as SchemaTypeFieldsOfExpr, v as SchemaTypeRequiredFieldsExpr, w as SchemaValueNeverExpr, x as SchemaValueAbsentExpr, y as SchemaTypeValueOfExpr, z as OperationPayloadDefinition } from "./index-CEzHfht2.js";
-import { ArrayOptions, FieldOptions, PrimitiveMetadata, RecordOptions, VariantOptions, absent, allFields, array, arrayOf, boolean, elementAt, elementOf, excludeVariants, extractVariants, field, fieldOf, fieldsOf, intersect, keyOf, literal, literalUnion, maybeAbsent, mergeRecords, never, nullValue, nullable, nullableOf, number, omitFields, opaqueHostType, optionalField, partialFields, pickFields, primitive, record, recordOf, ref, refine, requiredField, requiredFields, selectKeys, selfRef, string, taggedUnion, taggedUnionOf, tuple, tupleOf, typeVar, unknown, valueOf, variant } from "./authoring/index.js";
-import { SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, validateSchemaNodeDefinition } from "./definition/index.js";
-import { AsyncPayloadValidationContext, ConstraintProvider, PayloadPath, PayloadProviderContext, PayloadProviderDecision, PayloadResolution, PayloadResolutionContext, PayloadValidationContext, PayloadValidationDiagnostic, PayloadValidationResult, SemanticProvider, SyncConstraintProvider, SyncPayloadResolution, SyncPayloadValidationContext, SyncSemanticProvider, validatePayload, validatePayloadAsync } from "./payload/index.js";
-import { a as RelationProviderContext, c as RelationResolutionContext, d as RelationStatus, f as checkSchemaAssignability, h as checkSchemaRelationAsync, i as RelationPath, l as RelationResult, m as checkSchemaRelation, n as RelationContext, o as RelationProviderDecision, p as checkSchemaAssignabilityAsync, r as RelationDiagnostic, s as RelationResolution, t as AsyncRelationContext, u as RelationSide } from "./index-eK2Xgrwp.js";
-import { AsyncTypeInterpreterContext, AsyncTypeInterpreterRefResolution, AsyncTypeTermRelationContext, AsyncTypeVariableSolverContext, EvaluatedTypeTerm, HostTypeRelationDecision, TypeInterpreterContext, TypeInterpreterDiagnostic, TypeInterpreterPath, TypeInterpreterRefResolution, TypeInterpreterResult, TypeInterpreterStatus, TypeTermRelationContext, TypeVariableConstraint, TypeVariableSolverContext, TypeVariableSolverInput, TypeVariableSolverIssue, TypeVariableSolverResult, checkTypeTermRelation, checkTypeTermRelationAsync, evaluateExpression, evaluateExpressionAsync, evaluateSchemaValueTypeTerm, evaluateSchemaValueTypeTermAsync, solveTypeVariables, solveTypeVariablesAsync } from "./type-interpreter/index.js";
-export { ArrayOptions, AsyncPayloadValidationContext, AsyncRelationContext, AsyncTypeInterpreterContext, AsyncTypeInterpreterRefResolution, AsyncTypeTermRelationContext, AsyncTypeVariableSolverContext, ConstraintProvider, EvaluatedTypeTerm, Expression, ExpressionArgument, FieldOptions, HostTypeRelationDecision, JsonValue, LiteralValue, OpaqueHostTypeExpr, Operation, OperationBinaryMetadata, OperationChannelDefinition, OperationContainerDefinition, OperationDefinition, OperationErrorDefinition, OperationPayloadDefinition, PayloadPath, PayloadProviderContext, PayloadProviderDecision, PayloadResolution, PayloadResolutionContext, PayloadValidationContext, PayloadValidationDiagnostic, PayloadValidationResult, PrimitiveMetadata, PrimitiveName, RecordOptions, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, SchemaArrayNode, SchemaBooleanNode, SchemaConstraint, SchemaFieldSelector, SchemaLiteralNode, SchemaLiteralUnionNode, SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, SchemaNullNode, SchemaNullableNode, SchemaNumberNode, SchemaPrimitiveNode, SchemaRecordField, SchemaRecordNode, SchemaRefNode, SchemaSelfRefNode, SchemaStringNode, SchemaTaggedUnionNode, SchemaTaggedUnionVariant, SchemaTupleNode, SchemaTypeElementAtExpr, SchemaTypeElementOfExpr, SchemaTypeExcludeVariantsExpr, SchemaTypeExtractVariantsExpr, SchemaTypeFieldOfExpr, SchemaTypeFieldsOfExpr, SchemaTypeIntersectExpr, SchemaTypeKeyOfExpr, SchemaTypeMergeRecordsExpr, SchemaTypeOmitFieldsExpr, SchemaTypePartialFieldsExpr, SchemaTypePickFieldsExpr, SchemaTypeRefineExpr, SchemaTypeRequiredFieldsExpr, SchemaTypeValueOfExpr, SchemaTypeVariableExpr, SchemaValueAbsentExpr, SchemaValueArrayExpr, SchemaValueMaybeAbsentExpr, SchemaValueNeverExpr, SchemaValueNullableExpr, SchemaValueRecordExpr, SchemaValueTaggedUnionExpr, SchemaValueTupleExpr, SchemaValueTypeExpr, SchemaValueTypeTerm, SchemaValueUnknownExpr, SchemaVariantSelector, SemanticProvider, SyncConstraintProvider, SyncPayloadResolution, SyncPayloadValidationContext, SyncSemanticProvider, TypeInterpreterContext, TypeInterpreterDiagnostic, TypeInterpreterPath, TypeInterpreterRefResolution, TypeInterpreterResult, TypeInterpreterStatus, TypeTermRelationContext, TypeVariableConstraint, TypeVariableSolverContext, TypeVariableSolverInput, TypeVariableSolverIssue, TypeVariableSolverResult, VariantOptions, absent, allFields, array, arrayOf, boolean, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync, checkTypeTermRelation, checkTypeTermRelationAsync, elementAt, elementOf, evaluateExpression, evaluateExpressionAsync, evaluateSchemaValueTypeTerm, evaluateSchemaValueTypeTermAsync, excludeVariants, extractVariants, field, fieldOf, fieldsOf, intersect, keyOf, literal, literalUnion, maybeAbsent, mergeRecords, never, nullValue, nullable, nullableOf, number, omitFields, opaqueHostType, optionalField, partialFields, pickFields, primitive, record, recordOf, ref, refine, requiredField, requiredFields, selectKeys, selfRef, solveTypeVariables, solveTypeVariablesAsync, string, taggedUnion, taggedUnionOf, tuple, tupleOf, typeVar, unknown, validatePayload, validatePayloadAsync, validateSchemaNodeDefinition, valueOf, variant };
+import { $ as StructuredOperationPayloadDefinition, A as SchemaTypeOpaqueHostExpr, B as SchemaTypeValueOfExpr, C as SchemaTypeIntersectExpr, D as SchemaTypeNeverExpr, E as SchemaTypeMergeRecordsExpr, F as SchemaTypeRequiredFieldsExpr, G as OperationChannelDefinition, H as SchemaVariantSelector, I as SchemaTypeTaggedUnionExpr, J as OperationErrorDefinition, K as OperationContainerDefinition, L as SchemaTypeTerm, M as SchemaTypePickFieldsExpr, N as SchemaTypeRecordExpr, O as SchemaTypeNullableExpr, P as SchemaTypeRefineExpr, Q as StructuredOperationDefinition, R as SchemaTypeTupleExpr, S as SchemaTypeFieldsOfExpr, T as SchemaTypeMaybeAbsentExpr, U as Operation, V as SchemaTypeVariableExpr, W as OperationBinaryMetadata, X as StructuredOperationChannelDefinition, Y as OperationPayloadDefinition, Z as StructuredOperationContainerDefinition, _ as SchemaTypeElementOfExpr, _t as SchemaStringNode, a as StandardSemanticDefinition, at as SchemaConstraint, b as SchemaTypeExtractVariantsExpr, bt as SchemaTupleNode, c as STANDARD_CONSTRAINT_PATH_LIST, ct as SchemaNode, d as Expression, dt as SchemaNumberNode, et as JsonValue, f as ExpressionArgument, ft as SchemaPrimitiveNode, g as SchemaTypeElementAtExpr, gt as SchemaSelfRefNode, h as SchemaTypeArrayExpr, ht as SchemaRefNode, i as StandardConstraintDefinition, it as SchemaBooleanNode, j as SchemaTypePartialFieldsExpr, k as SchemaTypeOmitFieldsExpr, l as STANDARD_SEMANTIC_PATHS, lt as SchemaNullNode, m as SchemaTypeAbsentExpr, mt as SchemaRecordNode, n as STANDARD_SEMANTIC_DEFINITIONS, nt as PrimitiveName, o as StandardSemanticRelation, ot as SchemaLiteralNode, p as SchemaFieldSelector, pt as SchemaRecordField, q as OperationDefinition, r as STANDARD_SEMANTIC_RELATIONS, rt as SchemaArrayNode, s as STANDARD_CONSTRAINT_PATHS, st as SchemaLiteralUnionNode, t as STANDARD_CONSTRAINT_DEFINITIONS, tt as LiteralValue, u as STANDARD_SEMANTIC_PATH_LIST, ut as SchemaNullableNode, v as SchemaTypeExcludeVariantsExpr, vt as SchemaTaggedUnionNode, w as SchemaTypeKeyOfExpr, x as SchemaTypeFieldOfExpr, y as SchemaTypeExpr, yt as SchemaTaggedUnionVariant, z as SchemaTypeUnknownExpr } from "./index-4aMF0cTE.js";
+import { _ as validateStructuredOperationDefinition, a as validateSchemaTypeTermDefinition, b as SchemaNodeDefinitionValidationResult, c as OperationDefinitionPath, d as StructuredOperationDefinitionValidationResult, f as isStructuredOperationContainerDefinition, g as validateStructuredOperationContainerDefinition, h as validateOperationDefinition, i as validateSchemaTypeExprDefinition, l as OperationDefinitionValidationResult, m as validateOperationContainerDefinition, n as SchemaTypeExprDefinitionValidationResult, o as OperationContainerDefinitionValidationResult, p as isStructuredOperationDefinition, r as SchemaTypeTermDefinitionValidationResult, s as OperationDefinitionDiagnostic, t as SchemaTypeDefinitionDiagnostic, u as StructuredOperationContainerDefinitionValidationResult, v as SchemaNodeDefinitionDiagnostic, x as validateSchemaNodeDefinition, y as SchemaNodeDefinitionPath } from "./index-DXWoNYFB.js";
+import { _ as validatePayloadAsync, a as PayloadProviderDecision, c as PayloadValidationContext, d as SemanticProvider, f as SyncConstraintProvider, g as validatePayload, h as SyncSemanticProvider, i as PayloadProviderContext, l as PayloadValidationDiagnostic, m as SyncPayloadValidationContext, n as ConstraintProvider, o as PayloadResolution, p as SyncPayloadResolution, r as PayloadPath, s as PayloadResolutionContext, t as AsyncPayloadValidationContext, u as PayloadValidationResult } from "./index-BqfGAU1K.js";
+import { _ as checkSchemaAssignabilityAsync, a as AsyncRelationContext, c as RelationPath, d as RelationResolution, f as RelationResolutionContext, g as checkSchemaAssignability, h as RelationStatus, i as checkOperationRelationAsync, l as RelationProviderContext, m as RelationSide, n as OperationRelationDirection, o as RelationContext, p as RelationResult, r as checkOperationRelation, s as RelationDiagnostic, t as OperationRelationComponent, u as RelationProviderDecision, v as checkSchemaRelation, y as checkSchemaRelationAsync } from "./index-CBbd4hXJ.js";
+import { C as evaluateExpression, E as evaluateSchemaTypeTermAsync, S as TypeInterpreterStatus, T as evaluateSchemaTypeTerm, _ as TypeInterpreterContext, a as TypeVariableSolverIssue, b as TypeInterpreterRefResolution, c as solveTypeVariablesAsync, d as TypeTermRelationContext, f as checkTypeTermRelation, g as EvaluatedTypeTerm, h as AsyncTypeInterpreterRefResolution, i as TypeVariableSolverInput, l as AsyncTypeTermRelationContext, m as AsyncTypeInterpreterContext, n as TypeVariableConstraint, o as TypeVariableSolverResult, p as checkTypeTermRelationAsync, r as TypeVariableSolverContext, s as solveTypeVariables, t as AsyncTypeVariableSolverContext, u as HostTypeRelationDecision, v as TypeInterpreterDiagnostic, w as evaluateExpressionAsync, x as TypeInterpreterResult, y as TypeInterpreterPath } from "./index-DM5DSLLL.js";
+import { $ as isExtensionSemanticPath, A as BuildStandardConstraintProfileOptions, B as ExactRationalFailureReason, C as standardSchemaSatisfiability, D as standardPayloadContext, E as standardConstraintTarget, F as StandardConstraintSatisfiability, G as greatestCommonDivisorRationals, H as exactRationalFromFiniteNumber, I as buildStandardConstraintProfile, J as STANDARD_CONSTRAINT_DEFINITION_MAP, K as leastCommonMultipleRationals, L as isStandardConstraintOwner, M as StandardConstraintInterval, N as StandardConstraintOwner, O as standardSemanticProvider, P as StandardConstraintProfile, Q as classifySemanticPath, R as DEFAULT_EXACT_RATIONAL_MAX_BITS, S as refineStandardSchema, T as standardConstraintRegistry, U as exactRationalIsIntegerMultiple, V as ExactRationalResult, W as formatExactRational, X as StandardSemanticResolution, Y as STANDARD_SEMANTIC_DEFINITION_MAP, Z as StandardVocabularyRegistry, _ as createStandardRelationContext, a as InferOperationOutput, b as StandardSchemaOperationResult, c as expression_d_exports, d as InferFailureReason, et as isStandardSemanticNamespace, f as InferRef, g as StandardProviderContext, h as StaticSchemaRegistryEntry, i as InferOperationInput, j as StandardConstraintBound, k as standardSemanticRegistry, l as schema_d_exports, m as StaticSchemaRegistry, n as InferOperationEmits, nt as standardVocabularyRegistry, o as InferOperationPayload, p as InferResult, q as ClassifiedSemanticPath, r as InferOperationErrors, s as OperationRegistry, t as InferOperation, tt as pathKey, u as Infer, v as standardRelationContext, w as standardConstraintProvider, x as intersectStandardSchemas, y as standardVocabularyProvider, z as ExactRational } from "./index-bQy-C-1l.js";
+export { AsyncPayloadValidationContext, AsyncRelationContext, AsyncTypeInterpreterContext, AsyncTypeInterpreterRefResolution, AsyncTypeTermRelationContext, AsyncTypeVariableSolverContext, BuildStandardConstraintProfileOptions, ClassifiedSemanticPath, ConstraintProvider, DEFAULT_EXACT_RATIONAL_MAX_BITS, EvaluatedTypeTerm, ExactRational, ExactRationalFailureReason, ExactRationalResult, Expression, ExpressionArgument, HostTypeRelationDecision, Infer, InferFailureReason, InferOperation, InferOperationEmits, InferOperationErrors, InferOperationInput, InferOperationOutput, InferOperationPayload, InferRef, InferResult, JsonValue, LiteralValue, Operation, OperationBinaryMetadata, OperationChannelDefinition, OperationContainerDefinition, OperationContainerDefinitionValidationResult, OperationDefinition, OperationDefinitionDiagnostic, OperationDefinitionPath, OperationDefinitionValidationResult, OperationErrorDefinition, OperationPayloadDefinition, OperationRegistry, OperationRelationComponent, OperationRelationDirection, PayloadPath, PayloadProviderContext, PayloadProviderDecision, PayloadResolution, PayloadResolutionContext, PayloadValidationContext, PayloadValidationDiagnostic, PayloadValidationResult, PrimitiveName, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, STANDARD_CONSTRAINT_DEFINITIONS, STANDARD_CONSTRAINT_DEFINITION_MAP, STANDARD_CONSTRAINT_PATHS, STANDARD_CONSTRAINT_PATH_LIST, STANDARD_SEMANTIC_DEFINITIONS, STANDARD_SEMANTIC_DEFINITION_MAP, STANDARD_SEMANTIC_PATHS, STANDARD_SEMANTIC_PATH_LIST, STANDARD_SEMANTIC_RELATIONS, SchemaArrayNode, SchemaBooleanNode, SchemaConstraint, SchemaFieldSelector, SchemaLiteralNode, SchemaLiteralUnionNode, SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, SchemaNullNode, SchemaNullableNode, SchemaNumberNode, SchemaPrimitiveNode, SchemaRecordField, SchemaRecordNode, SchemaRefNode, SchemaSelfRefNode, SchemaStringNode, SchemaTaggedUnionNode, SchemaTaggedUnionVariant, SchemaTupleNode, SchemaTypeAbsentExpr, SchemaTypeArrayExpr, SchemaTypeDefinitionDiagnostic, SchemaTypeElementAtExpr, SchemaTypeElementOfExpr, SchemaTypeExcludeVariantsExpr, SchemaTypeExpr, SchemaTypeExprDefinitionValidationResult, SchemaTypeExtractVariantsExpr, SchemaTypeFieldOfExpr, SchemaTypeFieldsOfExpr, SchemaTypeIntersectExpr, SchemaTypeKeyOfExpr, SchemaTypeMaybeAbsentExpr, SchemaTypeMergeRecordsExpr, SchemaTypeNeverExpr, SchemaTypeNullableExpr, SchemaTypeOmitFieldsExpr, SchemaTypeOpaqueHostExpr, SchemaTypePartialFieldsExpr, SchemaTypePickFieldsExpr, SchemaTypeRecordExpr, SchemaTypeRefineExpr, SchemaTypeRequiredFieldsExpr, SchemaTypeTaggedUnionExpr, SchemaTypeTerm, SchemaTypeTermDefinitionValidationResult, SchemaTypeTupleExpr, SchemaTypeUnknownExpr, SchemaTypeValueOfExpr, SchemaTypeVariableExpr, SchemaVariantSelector, SemanticProvider, StandardConstraintBound, StandardConstraintDefinition, StandardConstraintInterval, StandardConstraintOwner, StandardConstraintProfile, StandardConstraintSatisfiability, StandardProviderContext, StandardSchemaOperationResult, StandardSemanticDefinition, StandardSemanticRelation, StandardSemanticResolution, StandardVocabularyRegistry, StaticSchemaRegistry, StaticSchemaRegistryEntry, StructuredOperationChannelDefinition, StructuredOperationContainerDefinition, StructuredOperationContainerDefinitionValidationResult, StructuredOperationDefinition, StructuredOperationDefinitionValidationResult, StructuredOperationPayloadDefinition, SyncConstraintProvider, SyncPayloadResolution, SyncPayloadValidationContext, SyncSemanticProvider, TypeInterpreterContext, TypeInterpreterDiagnostic, TypeInterpreterPath, TypeInterpreterRefResolution, TypeInterpreterResult, TypeInterpreterStatus, TypeTermRelationContext, TypeVariableConstraint, TypeVariableSolverContext, TypeVariableSolverInput, TypeVariableSolverIssue, TypeVariableSolverResult, buildStandardConstraintProfile, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync, checkTypeTermRelation, checkTypeTermRelationAsync, classifySemanticPath, createStandardRelationContext, evaluateExpression, evaluateExpressionAsync, evaluateSchemaTypeTerm, evaluateSchemaTypeTermAsync, exactRationalFromFiniteNumber, exactRationalIsIntegerMultiple, expression_d_exports as expression, formatExactRational, greatestCommonDivisorRationals, intersectStandardSchemas, isExtensionSemanticPath, isStandardConstraintOwner, isStandardSemanticNamespace, isStructuredOperationContainerDefinition, isStructuredOperationDefinition, leastCommonMultipleRationals, pathKey, refineStandardSchema, schema_d_exports as schema, solveTypeVariables, solveTypeVariablesAsync, standardConstraintProvider, standardConstraintRegistry, standardConstraintTarget, standardPayloadContext, standardRelationContext, standardSchemaSatisfiability, standardSemanticProvider, standardSemanticRegistry, standardVocabularyProvider, standardVocabularyRegistry, validateOperationContainerDefinition, validateOperationDefinition, validatePayload, validatePayloadAsync, validateSchemaNodeDefinition, validateSchemaTypeExprDefinition, validateSchemaTypeTermDefinition, validateStructuredOperationContainerDefinition, validateStructuredOperationDefinition };

package/dist/index.js

@@ -1,8 +1,10 @@
+import { a as STANDARD_CONSTRAINT_PATH_LIST, i as STANDARD_CONSTRAINT_PATHS, n as STANDARD_SEMANTIC_DEFINITIONS, o as STANDARD_SEMANTIC_PATHS, r as STANDARD_SEMANTIC_RELATIONS, s as STANDARD_SEMANTIC_PATH_LIST, t as STANDARD_CONSTRAINT_DEFINITIONS } from "./standard-DhKsxu9U.js";
 import "./spec/index.js";
-import { t as validateSchemaNodeDefinition } from "./definition-BXj3T94L.js";
+import { c as validateOperationContainerDefinition, d as validateStructuredOperationDefinition, f as validateSchemaNodeDefinition, l as validateOperationDefinition, n as validateSchemaTypeTermDefinition, o as isStructuredOperationContainerDefinition, s as isStructuredOperationDefinition, t as validateSchemaTypeExprDefinition, u as validateStructuredOperationContainerDefinition } from "./definition-DmYnDmQO.js";
 import { validatePayload, validatePayloadAsync } from "./payload/index.js";
-import { i as checkSchemaRelationAsync, n as checkSchemaAssignabilityAsync, r as checkSchemaRelation, t as checkSchemaAssignability } from "./relations-By0bK3UK.js";
-import { a as evaluateSchemaValueTypeTerm, c as checkTypeTermRelationAsync, i as evaluateExpressionAsync, n as solveTypeVariablesAsync, o as evaluateSchemaValueTypeTermAsync, r as evaluateExpression, s as checkTypeTermRelation, t as solveTypeVariables } from "./type-interpreter-Ck0VDhzn.js";
-import { absent, allFields, array, arrayOf, boolean, elementAt, elementOf, excludeVariants, extractVariants, field, fieldOf, fieldsOf, intersect, keyOf, literal, literalUnion, maybeAbsent, mergeRecords, never, nullValue, nullable, nullableOf, number, omitFields, opaqueHostType, optionalField, partialFields, pickFields, primitive, record, recordOf, ref, refine, requiredField, requiredFields, selectKeys, selfRef, string, taggedUnion, taggedUnionOf, tuple, tupleOf, typeVar, unknown, valueOf, variant } from "./authoring/index.js";
+import { a as checkSchemaRelation, i as checkSchemaAssignabilityAsync, n as checkOperationRelationAsync, o as checkSchemaRelationAsync, r as checkSchemaAssignability, t as checkOperationRelation } from "./relations-ysXDmi-Z.js";
+import { a as evaluateSchemaTypeTerm, c as checkTypeTermRelationAsync, i as evaluateExpressionAsync, n as solveTypeVariablesAsync, o as evaluateSchemaTypeTermAsync, r as evaluateExpression, s as checkTypeTermRelation, t as solveTypeVariables } from "./type-interpreter-DnrId8aM.js";
+import { n as schema_exports, t as expression_exports } from "./authoring-D3V0iyTe.js";
+import { DEFAULT_EXACT_RATIONAL_MAX_BITS, STANDARD_CONSTRAINT_DEFINITION_MAP, STANDARD_SEMANTIC_DEFINITION_MAP, buildStandardConstraintProfile, classifySemanticPath, createStandardRelationContext, exactRationalFromFiniteNumber, exactRationalIsIntegerMultiple, formatExactRational, greatestCommonDivisorRationals, intersectStandardSchemas, isExtensionSemanticPath, isStandardConstraintOwner, isStandardSemanticNamespace, leastCommonMultipleRationals, pathKey, refineStandardSchema, standardConstraintProvider, standardConstraintRegistry, standardConstraintTarget, standardPayloadContext, standardRelationContext, standardSchemaSatisfiability, standardSemanticProvider, standardSemanticRegistry, standardVocabularyProvider, standardVocabularyRegistry } from "./standard/index.js";
 
-export { absent, allFields, array, arrayOf, boolean, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync, checkTypeTermRelation, checkTypeTermRelationAsync, elementAt, elementOf, evaluateExpression, evaluateExpressionAsync, evaluateSchemaValueTypeTerm, evaluateSchemaValueTypeTermAsync, excludeVariants, extractVariants, field, fieldOf, fieldsOf, intersect, keyOf, literal, literalUnion, maybeAbsent, mergeRecords, never, nullValue, nullable, nullableOf, number, omitFields, opaqueHostType, optionalField, partialFields, pickFields, primitive, record, recordOf, ref, refine, requiredField, requiredFields, selectKeys, selfRef, solveTypeVariables, solveTypeVariablesAsync, string, taggedUnion, taggedUnionOf, tuple, tupleOf, typeVar, unknown, validatePayload, validatePayloadAsync, validateSchemaNodeDefinition, valueOf, variant };
+export { DEFAULT_EXACT_RATIONAL_MAX_BITS, STANDARD_CONSTRAINT_DEFINITIONS, STANDARD_CONSTRAINT_DEFINITION_MAP, STANDARD_CONSTRAINT_PATHS, STANDARD_CONSTRAINT_PATH_LIST, STANDARD_SEMANTIC_DEFINITIONS, STANDARD_SEMANTIC_DEFINITION_MAP, STANDARD_SEMANTIC_PATHS, STANDARD_SEMANTIC_PATH_LIST, STANDARD_SEMANTIC_RELATIONS, buildStandardConstraintProfile, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync, checkTypeTermRelation, checkTypeTermRelationAsync, classifySemanticPath, createStandardRelationContext, evaluateExpression, evaluateExpressionAsync, evaluateSchemaTypeTerm, evaluateSchemaTypeTermAsync, exactRationalFromFiniteNumber, exactRationalIsIntegerMultiple, expression_exports as expression, formatExactRational, greatestCommonDivisorRationals, intersectStandardSchemas, isExtensionSemanticPath, isStandardConstraintOwner, isStandardSemanticNamespace, isStructuredOperationContainerDefinition, isStructuredOperationDefinition, leastCommonMultipleRationals, pathKey, refineStandardSchema, schema_exports as schema, solveTypeVariables, solveTypeVariablesAsync, standardConstraintProvider, standardConstraintRegistry, standardConstraintTarget, standardPayloadContext, standardRelationContext, standardSchemaSatisfiability, standardSemanticProvider, standardSemanticRegistry, standardVocabularyProvider, standardVocabularyRegistry, validateOperationContainerDefinition, validateOperationDefinition, validatePayload, validatePayloadAsync, validateSchemaNodeDefinition, validateSchemaTypeExprDefinition, validateSchemaTypeTermDefinition, validateStructuredOperationContainerDefinition, validateStructuredOperationDefinition };

package/dist/integrations/json-schema/index.cjs

@@ -0,0 +1,328 @@
+const require_standard = require('../../standard-etPFZDJI.cjs');
+const require_standard_index = require('../../standard/index.cjs');
+
+//#region src/integrations/json-schema/index.ts
+function diagnostic(context, code, message, path, severity = "warning") {
+	context.diagnostics.push({
+		code,
+		message,
+		path,
+		severity
+	});
+}
+function mergeKeyword(target, source) {
+	if (source) Object.assign(target, source);
+}
+function extension(target, value) {
+	const existing = target["x-schemair"];
+	target["x-schemair"] = {
+		...existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {},
+		...value,
+		version: 1
+	};
+}
+function standardSemantic(path, node) {
+	const key = require_standard_index.pathKey(path);
+	const stringFormats = {
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.date)]: "date",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.datetime)]: "date-time",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.datetimeIso)]: "date-time",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.email)]: "email",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.url)]: "uri",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.ipV4)]: "ipv4",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.ipV6)]: "ipv6",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.uuid)]: "uuid",
+		[require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.string.uuidV4)]: "uuid"
+	};
+	if (node.name === "string" && stringFormats[key]) return { format: stringFormats[key] };
+	if (node.name === "number" && key === require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.number.integer)) return { type: "integer" };
+	if (node.name === "number" && key === require_standard_index.pathKey(require_standard.STANDARD_SEMANTIC_PATHS.number.safeInteger)) return {
+		type: "integer",
+		minimum: -9007199254740991,
+		maximum: 9007199254740991
+	};
+}
+function standardConstraint(constraint, target) {
+	const key = require_standard_index.pathKey(constraint.constraintPath);
+	const value = constraint.args;
+	switch (key) {
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.string.minLength): return typeof value === "number" ? { minLength: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.string.maxLength): return typeof value === "number" ? { maxLength: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.string.pattern): return typeof value === "string" ? { pattern: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.number.minimum): return typeof value === "number" ? { minimum: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.number.maximum): return typeof value === "number" ? { maximum: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.number.exclusiveMinimum): return typeof value === "number" ? target === "draft-2020-12" ? { exclusiveMinimum: value } : {
+			minimum: value,
+			exclusiveMinimum: true
+		} : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.number.exclusiveMaximum): return typeof value === "number" ? target === "draft-2020-12" ? { exclusiveMaximum: value } : {
+			maximum: value,
+			exclusiveMaximum: true
+		} : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.number.multipleOf): return typeof value === "number" ? { multipleOf: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.array.minItems): return typeof value === "number" ? { minItems: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.array.maxItems): return typeof value === "number" ? { maxItems: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.array.uniqueItems): return typeof value === "boolean" ? { uniqueItems: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.record.minProperties): return typeof value === "number" ? { minProperties: value } : void 0;
+		case require_standard_index.pathKey(require_standard.STANDARD_CONSTRAINT_PATHS.record.maxProperties): return typeof value === "number" ? { maxProperties: value } : void 0;
+		default: return;
+	}
+}
+function applyMetadata(target, node, context, path) {
+	if ("semanticPath" in node && node.semanticPath) {
+		const custom = context.options.semanticMapper?.(node.semanticPath, node);
+		const mapped = custom ?? standardSemantic(node.semanticPath, node);
+		if (mapped) {
+			mergeKeyword(target, mapped);
+			extension(target, { semanticPath: node.semanticPath });
+			if (custom === void 0) diagnostic(context, "semantic.lossy", `Semantic path ${node.semanticPath.join("/")} is approximated by JSON Schema keywords`, path);
+		} else {
+			extension(target, { semanticPath: node.semanticPath });
+			diagnostic(context, "semantic.unmapped", `Semantic path ${node.semanticPath.join("/")} has no lossless JSON Schema mapping`, path);
+		}
+	}
+	if ("constraints" in node && node.constraints) for (const constraint of node.constraints) {
+		const mapped = context.options.constraintMapper?.(constraint, node) ?? standardConstraint(constraint, context.target);
+		if (mapped) mergeKeyword(target, mapped);
+		else {
+			const prior = target["x-schemair"];
+			const meta = prior && typeof prior === "object" && !Array.isArray(prior) ? prior : {};
+			extension(target, { constraints: [...Array.isArray(meta.constraints) ? meta.constraints : [], {
+				constraintPath: [...constraint.constraintPath],
+				...constraint.args === void 0 ? {} : { args: constraint.args }
+			}] });
+			diagnostic(context, "constraint.unmapped", `Constraint ${constraint.constraintPath.join("/")} has no lossless JSON Schema mapping`, path);
+		}
+	}
+}
+function project(node, context, path) {
+	if (context.stack.includes(node)) {
+		diagnostic(context, "schema.cycle", "Cyclic schema graph requires an explicit ref strategy", path, "error");
+		const cycle = {};
+		extension(cycle, { selfRef: true });
+		return cycle;
+	}
+	context.stack.push(node);
+	let result;
+	switch (node.kind) {
+		case "primitive":
+			if (context.target === "openapi-3.0" && node.name === "null") {
+				result = {};
+				extension(result, { original: {
+					kind: "primitive",
+					name: "null"
+				} });
+				diagnostic(context, "openapi.null.unsupported", "OpenAPI 3.0 Schema Objects cannot represent a standalone null type", path, "error");
+			} else result = { type: node.name === "null" ? "null" : node.name };
+			applyMetadata(result, node, context, path);
+			break;
+		case "literal":
+			if (context.target === "openapi-3.0") {
+				result = { enum: [node.literal] };
+				extension(result, { literal: node.literal });
+				diagnostic(context, "openapi.literal.lossy", "OpenAPI 3.0 has no const keyword; the literal is projected as a single-value enum", path);
+			} else result = { const: node.literal };
+			break;
+		case "literalUnion":
+			result = { enum: [...node.values] };
+			extension(result, { union: {
+				kind: "literalUnion",
+				values: [...node.values]
+			} });
+			break;
+		case "nullable": {
+			const inner = project(node.value, context, [...path, "value"]);
+			if (context.target === "openapi-3.0") {
+				result = {
+					...inner,
+					nullable: true
+				};
+				extension(result, { union: {
+					kind: "nullable",
+					value: true
+				} });
+				diagnostic(context, "openapi.nullable.lossy", "OpenAPI 3.0 nullable is preserved as an extension because it is not equivalent to JSON Schema null union semantics", path);
+			} else result = { anyOf: [inner, { type: "null" }] };
+			break;
+		}
+		case "array":
+			result = {
+				type: "array",
+				items: project(node.elementSchema, context, [...path, "elementSchema"])
+			};
+			applyMetadata(result, node, context, path);
+			break;
+		case "tuple":
+			if (context.target === "draft-07") result = {
+				type: "array",
+				items: node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				])),
+				additionalItems: false,
+				minItems: node.elementSchemas.length,
+				maxItems: node.elementSchemas.length
+			};
+			else if (context.target === "openapi-3.0") {
+				const elements = node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				]));
+				result = {
+					type: "array",
+					items: {}
+				};
+				extension(result, { union: {
+					kind: "tuple",
+					length: node.elementSchemas.length,
+					elementSchemas: elements
+				} });
+				diagnostic(context, "openapi.tuple.lossy", "OpenAPI 3.0 has no tuple form; tuple position schemas are retained only in x-schemair", path);
+			} else result = {
+				type: "array",
+				prefixItems: node.elementSchemas.map((item, index) => project(item, context, [
+					...path,
+					"elementSchemas",
+					index
+				])),
+				items: false,
+				minItems: node.elementSchemas.length,
+				maxItems: node.elementSchemas.length
+			};
+			break;
+		case "record": {
+			const properties = {};
+			const required = [];
+			for (const field of node.fields) {
+				properties[field.key] = project(field.schema, context, [
+					...path,
+					"fields",
+					field.key
+				]);
+				if (field.required) required.push(field.key);
+			}
+			result = {
+				type: "object",
+				properties
+			};
+			if (required.length) result.required = required;
+			if (node.additionalFields === void 0) result.additionalProperties = false;
+			else if (node.additionalFields === true) result.additionalProperties = true;
+			else result.additionalProperties = project(node.additionalFields, context, [...path, "additionalFields"]);
+			applyMetadata(result, node, context, path);
+			break;
+		}
+		case "taggedUnion":
+			result = { oneOf: node.variants.map((variant, index) => project(variant.schema, context, [
+				...path,
+				"variants",
+				index
+			])) };
+			extension(result, { union: {
+				kind: "taggedUnion",
+				discriminator: node.discriminator,
+				variants: node.variants.map((variant) => ({
+					key: variant.key,
+					description: variant.description ?? null
+				}))
+			} });
+			diagnostic(context, "union.tagged.lossy", "SchemaIR tagged-union keys are not JSON Schema validation semantics", path);
+			break;
+		case "ref": {
+			const reference = context.options.refStrategy?.(node.refPath);
+			result = reference ? { $ref: reference } : {};
+			if (!reference) {
+				extension(result, { refPath: node.refPath });
+				diagnostic(context, "ref.unresolved", `No JSON Schema ref strategy resolved ${node.refPath.join("/")}`, path, "error");
+			}
+			break;
+		}
+		case "selfRef":
+			result = {};
+			extension(result, { selfRef: true });
+			diagnostic(context, "ref.self", "selfRef needs a caller-owned JSON Schema anchor strategy", path, "error");
+			break;
+	}
+	context.stack.pop();
+	return result;
+}
+function fidelity(diagnostics) {
+	if (diagnostics.some((item) => item.severity === "error")) return "unsupported";
+	if (diagnostics.length) return "lossy";
+	return "exact";
+}
+/** Project a SchemaNode into JSON Schema Draft 2020-12 without hiding loss. */
+function schemaNodeToJsonSchema(node, options = {}) {
+	const target = options.target ?? "draft-2020-12";
+	if (target === "openapi-3.0") return schemaNodeToOpenApiSchema(node, options);
+	const context = {
+		options,
+		target,
+		diagnostics: [],
+		stack: []
+	};
+	return {
+		schema: project(node, context, []),
+		fidelity: fidelity(context.diagnostics),
+		diagnostics: context.diagnostics
+	};
+}
+/** Project a SchemaNode to an OpenAPI 3.0 Schema Object. */
+function schemaNodeToOpenApiSchema(node, options = {}) {
+	const context = {
+		options,
+		target: "openapi-3.0",
+		diagnostics: [],
+		stack: []
+	};
+	return {
+		schema: project(node, context, []),
+		fidelity: fidelity(context.diagnostics),
+		diagnostics: context.diagnostics
+	};
+}
+/** Alias emphasizing that this is a diagnostic-bearing projection operation. */
+const schemaNodeToJsonSchemaWithDiagnostics = schemaNodeToJsonSchema;
+/**
+* Expose a runtime SchemaIR declaration through Standard JSON Schema V1.
+*
+* SchemaIR declarations do not perform input/output transformations, so both
+* converter methods project the same contract. Lossy projections are allowed
+* because their preserved metadata remains in `x-schemair`; unsupported
+* projections throw as required by the Standard JSON Schema protocol.
+*/
+function schemaIRToStandardJsonSchema(node, options = {}) {
+	const convert = (target) => {
+		const { target: _ignoredTarget, ...projectionOptions } = options;
+		const projectionTarget = target === "openapi-3.0" || target === "draft-2020-12" || target === "draft-07" ? target : void 0;
+		const result = projectionTarget === "openapi-3.0" ? schemaNodeToOpenApiSchema(node, projectionOptions) : projectionTarget ? schemaNodeToJsonSchema(node, {
+			...projectionOptions,
+			target: projectionTarget
+		}) : void 0;
+		if (!result) throw new Error(`SchemaIR Standard JSON Schema adapter does not support target ${target}`);
+		if (result.fidelity === "unsupported") {
+			const details = result.diagnostics.map((item) => item.message).join("; ");
+			throw new Error(`SchemaIR cannot be represented as JSON Schema: ${details}`);
+		}
+		return result.schema;
+	};
+	return { "~standard": {
+		version: 1,
+		vendor: "schemair",
+		jsonSchema: {
+			input: ({ target }) => convert(target),
+			output: ({ target }) => convert(target)
+		}
+	} };
+}
+/** Uppercase acronym alias matching the protocol name. */
+const schemaIRToStandardJSONSchema = schemaIRToStandardJsonSchema;
+
+//#endregion
+exports.schemaIRToStandardJSONSchema = schemaIRToStandardJSONSchema;
+exports.schemaIRToStandardJsonSchema = schemaIRToStandardJsonSchema;
+exports.schemaNodeToJsonSchema = schemaNodeToJsonSchema;
+exports.schemaNodeToJsonSchemaWithDiagnostics = schemaNodeToJsonSchemaWithDiagnostics;
+exports.schemaNodeToOpenApiSchema = schemaNodeToOpenApiSchema;

package/dist/integrations/json-schema/index.d.cts

@@ -0,0 +1,53 @@
+import { _t as SchemaStringNode, at as SchemaConstraint, ct as SchemaNode, dt as SchemaNumberNode, et as JsonValue } from "../../index-DDMwVy2I.cjs";
+import { StandardJSONSchemaV1, StandardJSONSchemaV1 as StandardJSONSchemaV1$1 } from "@standard-schema/spec";
+
+//#region src/integrations/json-schema/index.d.ts
+/** Supported projection dialects. OpenAPI is a Schema Object, not a full JSON Schema dialect. */
+type JsonSchemaTarget = 'draft-2020-12' | 'draft-07' | 'openapi-3.0';
+/** JSON-compatible values accepted by the exporter. */
+type JsonSchema = {
+  [key: string]: JsonSchema | JsonSchema[] | JsonValue | undefined;
+};
+type JsonSchemaProjectionFidelity = 'exact' | 'lossy' | 'unsupported' | 'incomplete';
+interface JsonSchemaProjectionDiagnostic {
+  code: string;
+  message: string;
+  path: readonly (string | number)[];
+  severity: 'warning' | 'error';
+}
+interface JsonSchemaProjectionResult {
+  schema: JsonSchema;
+  fidelity: JsonSchemaProjectionFidelity;
+  diagnostics: readonly JsonSchemaProjectionDiagnostic[];
+}
+interface JsonSchemaProjectionOptions {
+  /** Projection target. Defaults to JSON Schema Draft 2020-12. */
+  target?: JsonSchemaTarget;
+  /** Resolve SchemaIR refs to JSON Schema $ref values. Unhandled refs are diagnosed. */
+  refStrategy?: (path: readonly string[]) => string | undefined;
+  /** Map a semantic path to native JSON Schema keywords when equivalence is known. */
+  semanticMapper?: (path: readonly string[], node: SchemaStringNode | SchemaNumberNode) => JsonSchema | undefined;
+  /** Map a constraint to native JSON Schema keywords when equivalence is known. */
+  constraintMapper?: (constraint: SchemaConstraint, target: SchemaNode) => JsonSchema | undefined;
+}
+/** Options accepted by the Standard JSON Schema adapter. */
+type StandardJsonSchemaAdapterOptions = JsonSchemaProjectionOptions;
+/** Project a SchemaNode into JSON Schema Draft 2020-12 without hiding loss. */
+declare function schemaNodeToJsonSchema(node: SchemaNode, options?: JsonSchemaProjectionOptions): JsonSchemaProjectionResult;
+/** Project a SchemaNode to an OpenAPI 3.0 Schema Object. */
+declare function schemaNodeToOpenApiSchema(node: SchemaNode, options?: Omit<JsonSchemaProjectionOptions, 'target'>): JsonSchemaProjectionResult;
+/** Alias emphasizing that this is a diagnostic-bearing projection operation. */
+declare const schemaNodeToJsonSchemaWithDiagnostics: typeof schemaNodeToJsonSchema;
+/**
+ * Expose a runtime SchemaIR declaration through Standard JSON Schema V1.
+ *
+ * SchemaIR declarations do not perform input/output transformations, so both
+ * converter methods project the same contract. Lossy projections are allowed
+ * because their preserved metadata remains in `x-schemair`; unsupported
+ * projections throw as required by the Standard JSON Schema protocol.
+ */
+declare function schemaIRToStandardJsonSchema(node: SchemaNode, options?: StandardJsonSchemaAdapterOptions): StandardJSONSchemaV1$1;
+/** Uppercase acronym alias matching the protocol name. */
+declare const schemaIRToStandardJSONSchema: typeof schemaIRToStandardJsonSchema;
+//#endregion
+export { JsonSchema, JsonSchemaProjectionDiagnostic, JsonSchemaProjectionFidelity, JsonSchemaProjectionOptions, JsonSchemaProjectionResult, JsonSchemaTarget, type JsonValue, type SchemaConstraint, type SchemaNode, type StandardJSONSchemaV1, StandardJsonSchemaAdapterOptions, schemaIRToStandardJSONSchema, schemaIRToStandardJsonSchema, schemaNodeToJsonSchema, schemaNodeToJsonSchemaWithDiagnostics, schemaNodeToOpenApiSchema };

package/dist/integrations/json-schema/index.d.ts

@@ -0,0 +1,53 @@
+import { _t as SchemaStringNode, at as SchemaConstraint, ct as SchemaNode, dt as SchemaNumberNode, et as JsonValue } from "../../index-4aMF0cTE.js";
+import { StandardJSONSchemaV1, StandardJSONSchemaV1 as StandardJSONSchemaV1$1 } from "@standard-schema/spec";
+
+//#region src/integrations/json-schema/index.d.ts
+/** Supported projection dialects. OpenAPI is a Schema Object, not a full JSON Schema dialect. */
+type JsonSchemaTarget = 'draft-2020-12' | 'draft-07' | 'openapi-3.0';
+/** JSON-compatible values accepted by the exporter. */
+type JsonSchema = {
+  [key: string]: JsonSchema | JsonSchema[] | JsonValue | undefined;
+};
+type JsonSchemaProjectionFidelity = 'exact' | 'lossy' | 'unsupported' | 'incomplete';
+interface JsonSchemaProjectionDiagnostic {
+  code: string;
+  message: string;
+  path: readonly (string | number)[];
+  severity: 'warning' | 'error';
+}
+interface JsonSchemaProjectionResult {
+  schema: JsonSchema;
+  fidelity: JsonSchemaProjectionFidelity;
+  diagnostics: readonly JsonSchemaProjectionDiagnostic[];
+}
+interface JsonSchemaProjectionOptions {
+  /** Projection target. Defaults to JSON Schema Draft 2020-12. */
+  target?: JsonSchemaTarget;
+  /** Resolve SchemaIR refs to JSON Schema $ref values. Unhandled refs are diagnosed. */
+  refStrategy?: (path: readonly string[]) => string | undefined;
+  /** Map a semantic path to native JSON Schema keywords when equivalence is known. */
+  semanticMapper?: (path: readonly string[], node: SchemaStringNode | SchemaNumberNode) => JsonSchema | undefined;
+  /** Map a constraint to native JSON Schema keywords when equivalence is known. */
+  constraintMapper?: (constraint: SchemaConstraint, target: SchemaNode) => JsonSchema | undefined;
+}
+/** Options accepted by the Standard JSON Schema adapter. */
+type StandardJsonSchemaAdapterOptions = JsonSchemaProjectionOptions;
+/** Project a SchemaNode into JSON Schema Draft 2020-12 without hiding loss. */
+declare function schemaNodeToJsonSchema(node: SchemaNode, options?: JsonSchemaProjectionOptions): JsonSchemaProjectionResult;
+/** Project a SchemaNode to an OpenAPI 3.0 Schema Object. */
+declare function schemaNodeToOpenApiSchema(node: SchemaNode, options?: Omit<JsonSchemaProjectionOptions, 'target'>): JsonSchemaProjectionResult;
+/** Alias emphasizing that this is a diagnostic-bearing projection operation. */
+declare const schemaNodeToJsonSchemaWithDiagnostics: typeof schemaNodeToJsonSchema;
+/**
+ * Expose a runtime SchemaIR declaration through Standard JSON Schema V1.
+ *
+ * SchemaIR declarations do not perform input/output transformations, so both
+ * converter methods project the same contract. Lossy projections are allowed
+ * because their preserved metadata remains in `x-schemair`; unsupported
+ * projections throw as required by the Standard JSON Schema protocol.
+ */
+declare function schemaIRToStandardJsonSchema(node: SchemaNode, options?: StandardJsonSchemaAdapterOptions): StandardJSONSchemaV1$1;
+/** Uppercase acronym alias matching the protocol name. */
+declare const schemaIRToStandardJSONSchema: typeof schemaIRToStandardJsonSchema;
+//#endregion
+export { JsonSchema, JsonSchemaProjectionDiagnostic, JsonSchemaProjectionFidelity, JsonSchemaProjectionOptions, JsonSchemaProjectionResult, JsonSchemaTarget, type JsonValue, type SchemaConstraint, type SchemaNode, type StandardJSONSchemaV1, StandardJsonSchemaAdapterOptions, schemaIRToStandardJSONSchema, schemaIRToStandardJsonSchema, schemaNodeToJsonSchema, schemaNodeToJsonSchemaWithDiagnostics, schemaNodeToOpenApiSchema };