schemair 0.1.0 → 0.2.0

package/dist/index-CQynt7ft.d.cts

@@ -0,0 +1,420 @@
+import { G as OperationChannelDefinition, H as SchemaVariantSelector, L as SchemaTypeTerm, _t as SchemaStringNode, a as StandardSemanticDefinition, at as SchemaConstraint, bt as SchemaTupleNode, ct as SchemaNode, dt as SchemaNumberNode, ft as SchemaPrimitiveNode, gt as SchemaSelfRefNode, ht as SchemaRefNode, i as StandardConstraintDefinition, it as SchemaBooleanNode, lt as SchemaNullNode, mt as SchemaRecordNode, ot as SchemaLiteralNode, p as SchemaFieldSelector, pt as SchemaRecordField, q as OperationDefinition, rt as SchemaArrayNode, st as SchemaLiteralUnionNode, tt as LiteralValue, ut as SchemaNullableNode, vt as SchemaTaggedUnionNode, y as SchemaTypeExpr, yt as SchemaTaggedUnionVariant } from "./index-DDMwVy2I.cjs";
+import { f as SyncConstraintProvider, h as SyncSemanticProvider, m as SyncPayloadValidationContext } from "./index-D3mfwaSO.cjs";
+import { o as RelationContext } from "./index-CNjYUKvu.cjs";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/standard/runtime.d.ts
+type StandardSemanticResolution = 'standard' | 'extension' | 'unresolved';
+interface ClassifiedSemanticPath {
+  path: string[];
+  key: string;
+  resolution: StandardSemanticResolution;
+  definition?: StandardSemanticDefinition;
+}
+interface StandardVocabularyRegistry {
+  semanticDefinitions: Readonly<Record<string, StandardSemanticDefinition>>;
+  constraintDefinitions: Readonly<Record<string, StandardConstraintDefinition>>;
+}
+declare function pathKey(path: readonly string[]): string;
+declare const STANDARD_SEMANTIC_DEFINITION_MAP: Record<string, StandardSemanticDefinition>;
+declare const STANDARD_CONSTRAINT_DEFINITION_MAP: Record<string, StandardConstraintDefinition>;
+declare const standardVocabularyRegistry: StandardVocabularyRegistry;
+declare function isStandardSemanticNamespace(path: readonly string[] | undefined): boolean;
+declare function isExtensionSemanticPath(path: readonly string[] | undefined): boolean;
+declare function classifySemanticPath(path: readonly string[] | undefined): ClassifiedSemanticPath | undefined;
+//#endregion
+//#region src/standard/exact-rational.d.ts
+interface ExactRational {
+  readonly numerator: bigint;
+  readonly denominator: bigint;
+}
+type ExactRationalFailureReason = 'invalid_number' | 'division_by_zero' | 'max_bits_exceeded';
+type ExactRationalResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly reason: ExactRationalFailureReason;
+};
+declare const DEFAULT_EXACT_RATIONAL_MAX_BITS = 4096;
+declare function exactRationalFromFiniteNumber(value: number, maxBits?: number): ExactRationalResult<ExactRational>;
+declare function exactRationalIsIntegerMultiple(value: ExactRational, divisor: ExactRational, maxBits?: number): ExactRationalResult<boolean>;
+declare function greatestCommonDivisorRationals(values: readonly ExactRational[], maxBits?: number): ExactRationalResult<ExactRational>;
+declare function leastCommonMultipleRationals(values: readonly ExactRational[], maxBits?: number): ExactRationalResult<ExactRational>;
+declare function formatExactRational(value: ExactRational): string;
+//#endregion
+//#region src/standard/constraint-profile.d.ts
+type StandardConstraintOwner = SchemaStringNode | SchemaNumberNode | SchemaArrayNode | SchemaRecordNode;
+interface StandardConstraintBound {
+  readonly value: number;
+  readonly inclusive: boolean;
+}
+interface StandardConstraintInterval {
+  readonly domain: 'continuous' | 'integer';
+  readonly lower?: StandardConstraintBound;
+  readonly upper?: StandardConstraintBound;
+}
+type StandardConstraintSatisfiability = 'satisfiable' | 'empty' | 'unknown';
+interface StandardConstraintProfile {
+  readonly interval?: StandardConstraintInterval;
+  readonly multipleOf: readonly ExactRational[];
+  readonly uniqueItems?: boolean;
+  readonly patterns: readonly string[];
+  readonly unhandled: readonly SchemaConstraint[];
+  readonly invalid: readonly SchemaConstraint[];
+  readonly budgetExceeded: boolean;
+  readonly satisfiability: StandardConstraintSatisfiability;
+}
+interface BuildStandardConstraintProfileOptions {
+  readonly maxRationalBits?: number;
+}
+declare function isStandardConstraintOwner(node: SchemaNode): node is StandardConstraintOwner;
+declare function buildStandardConstraintProfile(node: StandardConstraintOwner, options?: BuildStandardConstraintProfileOptions): StandardConstraintProfile;
+//#endregion
+//#region src/standard/payload.d.ts
+declare const standardSemanticProvider: SyncSemanticProvider;
+declare function standardConstraintTarget(node: SchemaNode): string;
+declare const standardConstraintProvider: SyncConstraintProvider;
+declare const standardSemanticRegistry: Readonly<Record<string, SyncSemanticProvider>>;
+declare const standardConstraintRegistry: Readonly<Record<string, SyncConstraintProvider>>;
+/** Opt in explicitly; core validation never silently installs vocabulary policy. */
+declare const standardPayloadContext: SyncPayloadValidationContext;
+//#endregion
+//#region src/standard/operations.d.ts
+type StandardSchemaOperationResult = {
+  status: 'resolved';
+  schema: SchemaNode;
+} | {
+  status: 'emptySet';
+} | {
+  status: 'unknown' | 'unsupported';
+  message: string;
+};
+declare function standardSchemaSatisfiability(node: SchemaNode): 'inhabited' | 'emptySet' | 'unknown';
+declare function refineStandardSchema(node: SchemaNode, addConstraints: readonly SchemaConstraint[]): StandardSchemaOperationResult;
+declare function intersectStandardSchemas(left: SchemaNode, right: SchemaNode): StandardSchemaOperationResult;
+//#endregion
+//#region src/standard/relations.d.ts
+interface StandardProviderContext {
+  readonly semanticIdentityPolicy?: 'ignore' | 'hierarchical' | 'exact';
+}
+/** Accepted-set policy; unknown implication is never treated as compatibility. */
+declare function createStandardRelationContext(options?: StandardProviderContext): RelationContext;
+declare const standardRelationContext: RelationContext;
+declare const standardVocabularyProvider: Readonly<{
+  payload: SyncPayloadValidationContext;
+  relation: RelationContext;
+  refine: typeof refineStandardSchema;
+  intersect: typeof intersectStandardSchemas;
+  satisfiability: typeof standardSchemaSatisfiability;
+}>;
+//#endregion
+//#region src/authoring/infer.d.ts
+/** Project a statically known SchemaNode into its TypeScript payload carrier. */
+type Infer<Schema$1, Registry = never> = InferNode<Schema$1, Schema$1, Registry>;
+/** Reasons a statically authored schema cannot be projected precisely. */
+type InferFailureReason = 'unsupported-schema' | 'unresolved-ref' | 'dynamic-ref-path' | 'cyclic-ref' | 'ambiguous-ref' | 'unsupported-additional-fields' | 'depth-limit';
+type InferResult<Schema$1, Registry = never> = Reasons<Schema$1, Schema$1, Registry> extends infer Reason ? [Reason] extends [never] ? {
+  readonly ok: true;
+  readonly type: Infer<Schema$1, Registry>;
+} : {
+  readonly ok: false;
+  readonly reason: Reason;
+} : never;
+interface StaticSchemaRegistryEntry {
+  readonly refPath: readonly string[];
+  readonly name: string;
+  readonly schema: SchemaNode;
+}
+type StaticSchemaRegistry = readonly StaticSchemaRegistryEntry[];
+type SamePath<Left, Right> = Left extends readonly [infer LH extends string, ...infer LT] ? Right extends readonly [infer RH extends string, ...infer RT] ? [LH, RH] extends [RH, LH] ? SamePath<LT, RT> : false : false : Left extends readonly [] ? Right extends readonly [] ? true : false : false;
+type Matches<Registry, Path$1, Found extends readonly unknown[] = []> = Registry extends readonly [infer Head, ...infer Tail] ? Head extends {
+  readonly refPath: infer P;
+  readonly schema: infer S;
+} ? Matches<Tail, Path$1, SamePath<P, Path$1> extends true ? [...Found, S] : Found> : Matches<Tail, Path$1, Found> : Found;
+type ResolvedRegistryTarget<Registry, Path$1 extends readonly string[]> = [Registry] extends [never] ? never : number extends Path$1['length'] ? never : string extends Path$1[number] ? never : Registry extends readonly unknown[] ? number extends Registry['length'] ? never : Matches<Registry, Path$1> extends readonly [infer Target] ? Target : never : never;
+type SeenReference<Seen extends readonly (readonly string[])[], Path$1 extends readonly string[]> = Seen[number] extends infer Previous ? Previous extends readonly string[] ? SamePath<Previous, Path$1> extends true ? true : never : never : never;
+/** Project a statically registered reference into its TypeScript payload type. */
+type InferRef<Registry, Path$1 extends readonly string[]> = string extends Path$1[number] ? unknown : [ResolvedRegistryTarget<Registry, Path$1>] extends [never] ? unknown : InferNode<ResolvedRegistryTarget<Registry, Path$1>, ResolvedRegistryTarget<Registry, Path$1>, Registry, [Path$1]>;
+type InferNode<Schema$1, Root, Registry, Seen extends readonly (readonly string[])[] = []> = IsAny<Schema$1> extends true ? unknown : [Schema$1] extends [never] ? unknown : SchemaNode extends Schema$1 ? unknown : Schema$1 extends {
+  readonly kind: 'primitive';
+  readonly name: infer Name;
+} ? Name extends 'string' ? string : Name extends 'number' ? number : Name extends 'boolean' ? boolean : Name extends 'null' ? null : unknown : Schema$1 extends {
+  readonly kind: 'literal';
+  readonly literal: infer Value;
+} ? Value extends LiteralValue ? Value : unknown : Schema$1 extends {
+  readonly kind: 'literalUnion';
+  readonly values: infer Values extends readonly unknown[];
+} ? Values[number] extends LiteralValue ? Values[number] : unknown : Schema$1 extends {
+  readonly kind: 'nullable';
+  readonly value: infer Value;
+} ? InferNode<Value, Root, Registry, Seen> | null : Schema$1 extends {
+  readonly kind: 'array';
+  readonly elementSchema: infer Element;
+} ? InferNode<Element, Root, Registry, Seen>[] : Schema$1 extends {
+  readonly kind: 'tuple';
+  readonly elementSchemas: infer Elements extends readonly unknown[];
+} ? number extends Elements['length'] ? unknown : { -readonly [Index in keyof Elements]: InferNode<Elements[Index], Root, Registry, Seen> } : Schema$1 extends {
+  readonly kind: 'record';
+  readonly fields: infer Fields extends readonly unknown[];
+} ? InferRecord<Fields, Schema$1, Root, Registry, Seen> : Schema$1 extends {
+  readonly kind: 'taggedUnion';
+  readonly variants: infer Variants extends readonly unknown[];
+} ? InferVariants<Variants, Root, Registry, Seen> : Schema$1 extends {
+  readonly kind: 'selfRef';
+} ? ProductiveRoot<Root> extends true ? InferNode<Root, Root, Registry, Seen> : unknown : Schema$1 extends {
+  readonly kind: 'ref';
+  readonly refPath: infer Path extends readonly string[];
+} ? true extends SeenReference<Seen, Path> ? unknown : [ResolvedRegistryTarget<Registry, Path>] extends [never] ? unknown : InferNode<ResolvedRegistryTarget<Registry, Path>, Root, Registry, [...Seen, Path]> : Schema$1 extends SchemaNode ? unknown : unknown;
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type ProductiveRoot<Root> = Root extends {
+  readonly kind: 'record' | 'array' | 'tuple' | 'taggedUnion';
+} ? true : false;
+type Reasons<S$1, Root, R, Seen extends readonly (readonly string[])[] = [], Depth extends readonly unknown[] = []> = IsAny<S$1> extends true ? 'unsupported-schema' : [S$1] extends [never] ? 'unsupported-schema' : SchemaNode extends S$1 ? 'unsupported-schema' : Depth['length'] extends 32 ? 'depth-limit' : S$1 extends {
+  readonly kind: 'primitive';
+  readonly name: 'string' | 'number' | 'boolean' | 'null';
+} ? never : S$1 extends {
+  readonly kind: 'literal';
+  readonly literal: LiteralValue;
+} ? never : S$1 extends {
+  readonly kind: 'literalUnion';
+  readonly values: readonly LiteralValue[];
+} ? never : S$1 extends {
+  readonly kind: 'nullable';
+  readonly value: infer V;
+} ? Reasons<V, Root, R, Seen, [...Depth, 0]> : S$1 extends {
+  readonly kind: 'array';
+  readonly elementSchema: infer V;
+} ? Reasons<V, Root, R, Seen, [...Depth, 0]> : S$1 extends {
+  readonly kind: 'tuple';
+  readonly elementSchemas: infer E extends readonly unknown[];
+} ? number extends E['length'] ? 'unsupported-schema' : Children<E[number], Root, R, Seen, [...Depth, 0]> : S$1 extends {
+  readonly kind: 'record';
+  readonly fields: infer F extends readonly unknown[];
+} ? number extends F['length'] ? 'unsupported-schema' : FieldReasons<F[number], Root, R, Seen, [...Depth, 0]> | AdditionalReasons<S$1, F, Root, R, Seen, [...Depth, 0]> : S$1 extends {
+  readonly kind: 'taggedUnion';
+  readonly variants: infer V extends readonly unknown[];
+} ? number extends V['length'] ? 'unsupported-schema' : VariantReasons<V[number], Root, R, Seen, [...Depth, 0]> : S$1 extends {
+  readonly kind: 'selfRef';
+} ? ProductiveRoot<Root> extends true ? never : 'unsupported-schema' : S$1 extends {
+  readonly kind: 'ref';
+  readonly refPath: infer P extends readonly string[];
+} ? number extends P['length'] ? 'dynamic-ref-path' : string extends P[number] ? 'dynamic-ref-path' : true extends SeenReference<Seen, P> ? 'cyclic-ref' : [R] extends [never] ? 'unresolved-ref' : R extends readonly unknown[] ? number extends R['length'] ? 'unresolved-ref' : Matches<R, P> extends readonly [] ? 'unresolved-ref' : Matches<R, P> extends readonly [infer Target] ? Reasons<Target, Root, R, [...Seen, P], [...Depth, 0]> : 'ambiguous-ref' : 'unresolved-ref' : 'unsupported-schema';
+type Children<S$1, Root, R, Seen extends readonly (readonly string[])[], D extends readonly unknown[]> = S$1 extends unknown ? Reasons<S$1, Root, R, Seen, D> : never;
+type FieldReasons<F$1, Root, R, Seen extends readonly (readonly string[])[], D extends readonly unknown[]> = F$1 extends {
+  readonly key: infer K extends string;
+  readonly schema: infer S;
+} ? string extends K ? 'unsupported-schema' : Reasons<S, Root, R, Seen, D> : 'unsupported-schema';
+type VariantReasons<V$1, Root, R, Seen extends readonly (readonly string[])[], D extends readonly unknown[]> = V$1 extends {
+  readonly schema: infer S;
+} ? Reasons<S, Root, R, Seen, D> : 'unsupported-schema';
+type AdditionalReasons<S$1, F$1 extends readonly unknown[], Root, R, Seen extends readonly (readonly string[])[], D extends readonly unknown[]> = 'additionalFields' extends keyof S$1 ? S$1 extends {
+  readonly additionalFields?: infer A;
+} ? Exclude<A, undefined> extends true ? never : F$1 extends readonly [] ? Reasons<Exclude<A, undefined>, Root, R, Seen, D> : 'unsupported-additional-fields' : never : never;
+type InferRecord<Fields$1 extends readonly unknown[], Schema$1, Root, Registry, Seen extends readonly (readonly string[])[]> = number extends Fields$1['length'] ? unknown : string extends (Fields$1[number] extends {
+  readonly key: infer K;
+} ? K : never) ? unknown : Schema$1 extends {
+  readonly additionalFields: infer Additional;
+} ? Additional extends true ? InferDeclaredFields<Fields$1, Root, Registry, Seen> & Record<string, unknown> : Additional extends SchemaNode ? Fields$1 extends readonly [] ? Record<string, InferNode<Additional, Root, Registry, Seen>> : unknown : InferDeclaredFields<Fields$1, Root, Registry, Seen> : InferDeclaredFields<Fields$1, Root, Registry, Seen>;
+type InferDeclaredFields<Fields$1 extends readonly unknown[], Root, Registry, Seen extends readonly (readonly string[])[]> = { [Field in Fields$1[number] as Field extends {
+  readonly key: infer Key extends string;
+} ? Field extends {
+  readonly required: true;
+} ? Key : never : never]-?: Field extends {
+  readonly schema: infer FieldSchema;
+} ? InferNode<FieldSchema, Root, Registry, Seen> : unknown } & { [Field in Fields$1[number] as Field extends {
+  readonly key: infer Key extends string;
+} ? Field extends {
+  readonly required: true;
+} ? never : Key : never]?: Field extends {
+  readonly schema: infer FieldSchema;
+} ? InferNode<FieldSchema, Root, Registry, Seen> : unknown };
+type InferVariants<Variants$1 extends readonly unknown[], Root, Registry, Seen extends readonly (readonly string[])[]> = Variants$1[number] extends infer Variant ? number extends Variants$1['length'] ? unknown : Variant extends {
+  readonly schema: infer VariantSchema;
+} ? InferNode<VariantSchema, Root, Registry, Seen> : unknown : never;
+declare namespace schema_d_exports {
+  export { ArrayOptions, FieldOptions, PrimitiveMetadata, RecordOptions, StaticSchemaRegistry, StaticSchemaRegistryEntry, VariantOptions, array, boolean, defineSchemaRegistry, field, literal, literalUnion, nullValue, nullable, number, optionalField, primitive, record, ref, requiredField, selfRef, string, taggedUnion, tuple, variant };
+}
+interface PrimitiveMetadata {
+  semanticPath?: string[];
+  constraints?: SchemaConstraint[];
+}
+interface RecordOptions {
+  additionalFields?: true | SchemaNode;
+  constraints?: SchemaConstraint[];
+}
+interface ArrayOptions {
+  constraints?: SchemaConstraint[];
+}
+interface FieldOptions {
+  required?: boolean;
+  description?: string;
+}
+interface VariantOptions {
+  description?: string;
+}
+type FieldResult<Key extends string, Node extends SchemaNode, Options> = Omit<SchemaRecordField, 'key' | 'schema' | 'required'> & {
+  key: Key;
+  schema: Node;
+} & (Options extends {
+  required: true;
+} ? {
+  required: true;
+} : {});
+type DiscriminatorLiteral<Schema$1, Key extends string> = Schema$1 extends {
+  readonly fields: infer Fields extends readonly unknown[];
+} ? Fields[number] extends infer Field ? Field extends {
+  readonly key: Key;
+  readonly required: true;
+  readonly schema: {
+    readonly kind: 'literal';
+    readonly literal: infer Value;
+  };
+} ? Value : never : never : never;
+type ValidTaggedVariants<Discriminator extends string, Variants$1 extends readonly SchemaTaggedUnionVariant[]> = Variants$1[number] extends infer Variant ? Variant extends {
+  readonly key: infer Key extends string;
+  readonly schema: infer Schema;
+} ? DiscriminatorLiteral<Schema, Discriminator> extends Key ? Variant : never : never : never;
+/** Construct a primitive SchemaNode. This does not validate metadata. */
+declare function primitive<const Name$1 extends 'string' | 'number'>(name: Name$1, metadata?: PrimitiveMetadata): Extract<SchemaPrimitiveNode, {
+  name: Name$1;
+}>;
+declare function primitive<const Name$1 extends 'boolean' | 'null'>(name: Name$1): Extract<SchemaPrimitiveNode, {
+  name: Name$1;
+}>;
+declare const string: (metadata?: PrimitiveMetadata) => SchemaStringNode;
+declare const number: (metadata?: PrimitiveMetadata) => SchemaNumberNode;
+declare const boolean: () => SchemaBooleanNode;
+declare const nullValue: () => SchemaNullNode;
+declare function literal<const Value$1 extends LiteralValue>(value: Value$1): Omit<SchemaLiteralNode, 'literal'> & {
+  literal: Value$1;
+};
+declare function field<const Key extends string, const Node extends SchemaNode, const Options extends FieldOptions | undefined = undefined>(key: Key, schema: Node, options?: Options): FieldResult<Key, Node, Options>;
+declare function requiredField<const Key extends string, const Node extends SchemaNode>(key: Key, schema: Node, description?: string): Omit<SchemaRecordField, 'key' | 'schema' | 'required'> & {
+  key: Key;
+  schema: Node;
+  required: true;
+};
+declare function optionalField<const Key extends string, const Node extends SchemaNode>(key: Key, schema: Node, description?: string): Omit<SchemaRecordField, 'key' | 'schema' | 'required'> & {
+  key: Key;
+  schema: Node;
+};
+declare function record<const Fields$1 extends readonly SchemaRecordField[]>(fields: Fields$1): {
+  kind: 'record';
+  fields: [...Fields$1];
+};
+declare function record<const Fields$1 extends readonly SchemaRecordField[], const Options extends RecordOptions>(fields: Fields$1, options: Options): {
+  kind: 'record';
+  fields: [...Fields$1];
+} & Options;
+declare function array<const Element$1 extends SchemaNode>(elementSchema: Element$1, options?: ArrayOptions): Omit<SchemaArrayNode, 'elementSchema'> & {
+  elementSchema: Element$1;
+};
+declare function tuple<const Elements$1 extends SchemaNode[]>(elementSchemas: Elements$1): Omit<SchemaTupleNode, 'elementSchemas'> & {
+  elementSchemas: Elements$1;
+};
+declare function literalUnion<const Values$1 extends [LiteralValue, LiteralValue, ...LiteralValue[]]>(values: Values$1): Omit<SchemaLiteralUnionNode, 'values'> & {
+  values: Values$1;
+};
+declare function nullable<const Value$1 extends SchemaNode>(value: Value$1): Omit<SchemaNullableNode, 'value'> & {
+  value: Value$1;
+};
+declare function variant<const Key extends string, const Schema$1 extends SchemaRecordNode>(key: Key, schema: Schema$1, options?: VariantOptions): Omit<SchemaTaggedUnionVariant, 'key' | 'schema'> & {
+  key: Key;
+  schema: Schema$1;
+};
+declare function taggedUnion<const Discriminator extends string, const Variants$1 extends SchemaTaggedUnionVariant[]>(discriminator: Discriminator, variants: Variants$1 & (Variants$1[number] extends ValidTaggedVariants<Discriminator, Variants$1> ? unknown : never)): Omit<SchemaTaggedUnionNode, 'discriminator' | 'variants'> & {
+  discriminator: Discriminator;
+  variants: Variants$1;
+};
+declare function ref<const Path$1 extends string[]>(refPath: Path$1): Omit<SchemaRefNode, 'refPath'> & {
+  refPath: Path$1;
+};
+declare function selfRef(): SchemaSelfRefNode;
+/** Preserve a statically authored registry as ordinary declaration data. */
+declare function defineSchemaRegistry<const Entries extends readonly {
+  readonly refPath: readonly string[];
+  readonly name: string;
+  readonly schema: SchemaNode;
+}[]>(entries: Entries): Entries;
+declare namespace expression_d_exports {
+  export { absent, allFields, arrayOf, elementAt, elementOf, excludeVariants, extractVariants, fieldOf, fieldsOf, intersect, keyOf, maybeAbsent, mergeRecords, never, nullableOf, omitFields, opaqueHostType, partialFields, pickFields, recordOf, refine, requiredFields, selectKeys, taggedUnionOf, tupleOf, typeVar, unknown, valueOf };
+}
+declare function typeVar(name: string, upperBound?: SchemaTypeTerm): SchemaTypeExpr;
+declare function opaqueHostType(hostPath: string[]): SchemaTypeExpr;
+declare function absent(): SchemaTypeExpr;
+declare function never(): SchemaTypeExpr;
+declare function unknown(): SchemaTypeExpr;
+declare function maybeAbsent(value: SchemaTypeTerm): SchemaTypeExpr;
+declare function arrayOf(element: SchemaTypeTerm, constraints?: SchemaConstraint[]): SchemaTypeExpr;
+declare function tupleOf(elements: SchemaTypeTerm[]): SchemaTypeExpr;
+declare function recordOf(fields: {
+  key: string;
+  value: SchemaTypeTerm;
+  required?: boolean;
+  description?: string;
+}[], options?: {
+  additionalFields?: true | SchemaTypeTerm;
+  constraints?: SchemaConstraint[];
+}): SchemaTypeExpr;
+declare function nullableOf(value: SchemaTypeTerm): SchemaTypeExpr;
+declare function taggedUnionOf(discriminator: string, variants: {
+  key: string;
+  value: SchemaTypeTerm;
+  description?: string;
+}[]): SchemaTypeExpr;
+declare function elementOf(source: SchemaTypeTerm): SchemaTypeExpr;
+declare function valueOf(source: SchemaTypeTerm): SchemaTypeExpr;
+declare function elementAt(source: SchemaTypeTerm, index: number): SchemaTypeExpr;
+declare function fieldOf(source: SchemaTypeTerm, key: string): SchemaTypeExpr;
+declare function keyOf(source: SchemaTypeTerm): SchemaTypeExpr;
+declare function allFields(): SchemaFieldSelector;
+declare function selectKeys(keys: string[], onMissing?: 'error' | 'ignore'): SchemaFieldSelector;
+declare function fieldsOf(source: SchemaTypeTerm, fields: SchemaFieldSelector): SchemaTypeExpr;
+declare function pickFields(source: SchemaTypeTerm, fields: SchemaFieldSelector): SchemaTypeExpr;
+declare function omitFields(source: SchemaTypeTerm, fields: SchemaFieldSelector): SchemaTypeExpr;
+declare function partialFields(source: SchemaTypeTerm, fields: SchemaFieldSelector): SchemaTypeExpr;
+declare function requiredFields(source: SchemaTypeTerm, fields: SchemaFieldSelector): SchemaTypeExpr;
+declare function mergeRecords(sources: SchemaTypeTerm[], conflict: 'leftWins' | 'rightWins' | 'error'): SchemaTypeExpr;
+declare function intersect(sources: SchemaTypeTerm[]): SchemaTypeExpr;
+declare function refine(source: SchemaTypeTerm, fields: {
+  key: string;
+  require?: true;
+  intersectWith?: SchemaTypeTerm;
+  addConstraints?: SchemaConstraint[];
+}[]): SchemaTypeExpr;
+declare function excludeVariants(source: SchemaTypeTerm, variants: SchemaVariantSelector): SchemaTypeExpr;
+declare function extractVariants(source: SchemaTypeTerm, variants: SchemaVariantSelector): SchemaTypeExpr;
+//#endregion
+//#region src/authoring/operation-infer.d.ts
+type Property<T, K extends PropertyKey> = K extends keyof T ? T[K] : undefined;
+/** Map a portable payload to a host-selected TypeScript carrier. */
+type InferOperationPayload<Payload, Registry = never, Binary = unknown> = [Payload] extends [never] ? undefined : Payload extends {
+  readonly kind: 'structured';
+  readonly schema: infer Schema;
+} ? Infer<Schema, Registry> : Payload extends {
+  readonly kind: 'binary';
+} ? Binary : undefined;
+type InferOperationInput<Operation, Registry = never, Binary = unknown> = InferOperationPayload<Property<Operation, 'input'>, Registry, Binary>;
+type InferOperationOutput<Operation, Registry = never, Binary = unknown> = InferOperationPayload<Property<Operation, 'output'>, Registry, Binary>;
+type InferErrorData<Data, Registry> = Data extends undefined ? undefined : Infer<Data, Registry>;
+type InferError<Error, Registry> = InferErrorData<Property<Error, 'data'>, Registry>;
+type InferOperationErrors<Operation, Registry = never> = InferErrors<Property<Operation, 'errors'>, Registry>;
+type InferErrors<Errors, Registry> = Errors extends undefined ? undefined : Errors extends object ? { [Code in keyof Errors]: InferError<Errors[Code], Registry> } : unknown;
+type InferChannel<Channel, Registry, Binary> = Channel extends OperationChannelDefinition ? {
+  readonly data: InferOperationPayload<Property<Channel, 'data'>, Registry, Binary>;
+  readonly errors: InferOperationErrors<Channel, Registry>;
+} : never;
+type InferOperationEmits<Operation, Registry = never, Binary = unknown> = InferEmits<Property<Operation, 'emits'>, Registry, Binary>;
+type InferEmits<Emits, Registry, Binary> = Emits extends undefined ? undefined : Emits extends Record<string, OperationChannelDefinition> ? { [Name in keyof Emits]: InferChannel<Emits[Name], Registry, Binary> } : unknown;
+/** Convenience projection of all operation channels. */
+type InferOperation<Operation extends OperationDefinition, Registry = never, Binary = unknown> = {
+  readonly input: InferOperationInput<Operation, Registry, Binary>;
+  readonly output: InferOperationOutput<Operation, Registry, Binary>;
+  readonly errors: InferOperationErrors<Operation, Registry>;
+  readonly emits: InferOperationEmits<Operation, Registry, Binary>;
+};
+type OperationRegistry = StaticSchemaRegistry;
+//#endregion
+export { isExtensionSemanticPath as $, BuildStandardConstraintProfileOptions as A, ExactRationalFailureReason as B, standardSchemaSatisfiability as C, standardPayloadContext as D, standardConstraintTarget as E, StandardConstraintSatisfiability as F, greatestCommonDivisorRationals as G, exactRationalFromFiniteNumber as H, buildStandardConstraintProfile as I, STANDARD_CONSTRAINT_DEFINITION_MAP as J, leastCommonMultipleRationals as K, isStandardConstraintOwner as L, StandardConstraintInterval as M, StandardConstraintOwner as N, standardSemanticProvider as O, StandardConstraintProfile as P, classifySemanticPath as Q, DEFAULT_EXACT_RATIONAL_MAX_BITS as R, refineStandardSchema as S, standardConstraintRegistry as T, exactRationalIsIntegerMultiple as U, ExactRationalResult as V, formatExactRational as W, StandardSemanticResolution as X, STANDARD_SEMANTIC_DEFINITION_MAP as Y, StandardVocabularyRegistry as Z, createStandardRelationContext as _, InferOperationOutput as a, StandardSchemaOperationResult as b, expression_d_exports as c, InferFailureReason as d, isStandardSemanticNamespace as et, InferRef as f, StandardProviderContext as g, StaticSchemaRegistryEntry as h, InferOperationInput as i, StandardConstraintBound as j, standardSemanticRegistry as k, schema_d_exports as l, StaticSchemaRegistry as m, InferOperationEmits as n, standardVocabularyRegistry as nt, InferOperationPayload as o, InferResult as p, ClassifiedSemanticPath as q, InferOperationErrors as r, OperationRegistry as s, InferOperation as t, pathKey as tt, Infer as u, standardRelationContext as v, standardConstraintProvider as w, intersectStandardSchemas as x, standardVocabularyProvider as y, ExactRational as z };

package/dist/index-D3mfwaSO.d.cts

@@ -0,0 +1,56 @@
+import { ct as SchemaNode } from "./index-DDMwVy2I.cjs";
+
+//#region src/payload/validator.d.ts
+type PayloadPath = readonly (string | number)[];
+interface PayloadValidationDiagnostic {
+  readonly code: string;
+  readonly path: PayloadPath;
+  readonly message: string;
+}
+type PayloadValidationResult = {
+  readonly status: 'accepted';
+  readonly issues: readonly [];
+} | {
+  readonly status: 'rejected' | 'unknown';
+  readonly issues: readonly PayloadValidationDiagnostic[];
+};
+type PayloadProviderDecision = boolean | {
+  readonly status: 'accepted' | 'rejected' | 'unknown' | 'unsupported';
+  readonly message?: string;
+};
+interface PayloadProviderContext {
+  readonly path: PayloadPath;
+  readonly schema: SchemaNode;
+  readonly rootSchema: SchemaNode;
+}
+interface PayloadResolutionContext extends PayloadProviderContext {
+  readonly refPath: readonly string[];
+}
+type PayloadResolution = SchemaNode | {
+  readonly status: 'resolved';
+  readonly schema: SchemaNode;
+} | {
+  readonly status: 'unknown' | 'unsupported';
+  readonly message?: string;
+} | undefined;
+type SemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
+type ConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
+type SyncSemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
+type SyncConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
+type SyncPayloadResolution = PayloadResolution;
+interface SyncPayloadValidationContext {
+  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => SyncPayloadResolution;
+  readonly semanticProvider?: SyncSemanticProvider;
+  readonly constraintProvider?: SyncConstraintProvider;
+}
+interface PayloadValidationContext {
+  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => PayloadResolution | Promise<PayloadResolution>;
+  readonly semanticProvider?: SemanticProvider;
+  readonly constraintProvider?: ConstraintProvider;
+}
+/** Context accepted by the asynchronous payload validation entry point. */
+type AsyncPayloadValidationContext = PayloadValidationContext;
+declare function validatePayload(value: unknown, schema: SchemaNode, context?: SyncPayloadValidationContext): PayloadValidationResult;
+declare function validatePayloadAsync(value: unknown, schema: SchemaNode, context?: AsyncPayloadValidationContext): Promise<PayloadValidationResult>;
+//#endregion
+export { validatePayloadAsync as _, PayloadProviderDecision as a, PayloadValidationContext as c, SemanticProvider as d, SyncConstraintProvider as f, validatePayload as g, SyncSemanticProvider as h, PayloadProviderContext as i, PayloadValidationDiagnostic as l, SyncPayloadValidationContext as m, ConstraintProvider as n, PayloadResolution as o, SyncPayloadResolution as p, PayloadPath as r, PayloadResolutionContext as s, AsyncPayloadValidationContext as t, PayloadValidationResult as u };