typebox 0.0.1 → 1.0.0

package/build/value/equal/equal.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+/** Returns true if left and right values are structurally equal */
+export function Equal(left, right) {
+    return Guard.IsDeepEqual(left, right);
+}

package/build/value/equal/index.d.mts

@@ -0,0 +1 @@
+export * from './equal.mjs';

package/build/value/equal/index.mjs

@@ -0,0 +1 @@
+export * from './equal.mjs';

package/build/value/errors/errors.d.mts

@@ -0,0 +1,16 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+import type { TLocalizedValidationError } from '../../error/index.mjs';
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurance of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurance of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export declare function Errors<Context extends TProperties, Type extends TSchema>(context: Context, type: Type, value: unknown): TLocalizedValidationError[];

package/build/value/errors/errors.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Errors as SchemaErrors, } from '../../schema/index.mjs';
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurance of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export function Errors(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const [_, errors] = SchemaErrors(context, type, value);
+    return errors;
+}

package/build/value/errors/index.d.mts

@@ -0,0 +1 @@
+export * from './errors.mjs';

package/build/value/errors/index.mjs

@@ -0,0 +1 @@
+export * from './errors.mjs';

package/build/value/hash/hash.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Computes a unique 64-bit hash of the specified value and returns the hex string representation. This
+ * function internally uses a non-cryptographic FNV1A64 algorithm for hashing. Hashing is implemented
+ * via structural traversal of the value.
+ */
+export declare function Hash(value: unknown): string;

package/build/value/hash/hash.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { Hashing } from '../../system/hashing/index.mjs';
+/**
+ * Computes a unique 64-bit hash of the specified value and returns the hex string representation. This
+ * function internally uses a non-cryptographic FNV1A64 algorithm for hashing. Hashing is implemented
+ * via structural traversal of the value.
+ */
+export function Hash(value) {
+    return Hashing.Hash(value);
+}

package/build/value/hash/index.d.mts

@@ -0,0 +1 @@
+export * from './hash.mjs';

package/build/value/hash/index.mjs

@@ -0,0 +1 @@
+export * from './hash.mjs';

package/build/value/index.d.mts

@@ -0,0 +1,20 @@
+export * from './assert/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './codec/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './errors/index.mjs';
+export * from './default/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
+export * from './delta/index.mjs';
+export * from './pipeline/index.mjs';
+export * from './pointer/index.mjs';
+export * from './repair/index.mjs';
+import * as Value from './value.mjs';
+export * as Value from './value.mjs';
+export default Value;

package/build/value/index.mjs

@@ -0,0 +1,26 @@
+// ------------------------------------------------------------------
+// Functions
+// ------------------------------------------------------------------
+export * from './assert/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './codec/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './errors/index.mjs';
+export * from './default/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
+export * from './delta/index.mjs';
+export * from './pipeline/index.mjs';
+export * from './pointer/index.mjs';
+export * from './repair/index.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import * as Value from './value.mjs';
+export * as Value from './value.mjs';
+export default Value;

package/build/value/mutate/error.d.mts

@@ -0,0 +1,3 @@
+export declare class MutateError extends Error {
+    constructor(message: string);
+}

package/build/value/mutate/error.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+export class MutateError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

package/build/value/mutate/from-array.d.mts

@@ -0,0 +1,2 @@
+import { type TMutable } from './mutate.mjs';
+export declare function FromArray(root: TMutable, path: string, current: unknown, next: unknown[]): void;

package/build/value/mutate/from-array.mjs

@@ -0,0 +1,16 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import { FromValue } from './from-value.mjs';
+export function FromArray(root, path, current, next) {
+    if (!Guard.IsArray(current)) {
+        Pointer.Set(root, path, Clone(next));
+    }
+    else {
+        for (let index = 0; index < next.length; index++) {
+            FromValue(root, `${path}/${index}`, current[index], next[index]);
+        }
+        current.splice(next.length);
+    }
+}

package/build/value/mutate/from-object.d.mts

@@ -0,0 +1,2 @@
+import { type TMutable } from './mutate.mjs';
+export declare function FromObject(root: TMutable, path: string, current: unknown, next: Record<string, unknown>): void;

package/build/value/mutate/from-object.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { FromValue } from './from-value.mjs';
+export function FromObject(root, path, current, next) {
+    if (!Guard.IsObjectNotArray(current)) {
+        Pointer.Set(root, path, Clone(next));
+    }
+    else {
+        const currentKeys = Guard.Keys(current);
+        const nextKeys = Guard.Keys(next);
+        for (const currentKey of currentKeys) {
+            if (!nextKeys.includes(currentKey)) {
+                delete current[currentKey];
+            }
+        }
+        for (const nextKey of nextKeys) {
+            if (!currentKeys.includes(nextKey)) {
+                current[nextKey] = next[nextKey];
+            }
+        }
+        for (const nextKey of nextKeys) {
+            FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+        }
+    }
+}

package/build/value/mutate/from-unknown.d.mts

@@ -0,0 +1,2 @@
+import { type TMutable } from './mutate.mjs';
+export declare function FromUnknown(root: TMutable, path: string, current: unknown, next: unknown): void;

package/build/value/mutate/from-unknown.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { Pointer } from '../pointer/index.mjs';
+export function FromUnknown(root, path, current, next) {
+    if (current === next)
+        return;
+    Pointer.Set(root, path, next);
+}

package/build/value/mutate/from-value.d.mts

@@ -0,0 +1,2 @@
+import { type TMutable } from './mutate.mjs';
+export declare function FromValue(root: TMutable, path: string, current: unknown, next: unknown): void;

package/build/value/mutate/from-value.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromArray } from './from-array.mjs';
+import { FromObject } from './from-object.mjs';
+import { FromUnknown } from './from-unknown.mjs';
+export function FromValue(root, path, current, next) {
+    if (Guard.IsArray(next))
+        return FromArray(root, path, current, next);
+    if (Guard.IsObject(next))
+        return FromObject(root, path, current, next);
+    return FromUnknown(root, path, current, next);
+}

package/build/value/mutate/index.d.mts

@@ -0,0 +1 @@
+export * from './mutate.mjs';

package/build/value/mutate/index.mjs

@@ -0,0 +1 @@
+export * from './mutate.mjs';

package/build/value/mutate/mutate.d.mts

@@ -0,0 +1,9 @@
+export type TMutable = {
+    [key: string]: unknown;
+} | unknown[];
+/**
+ * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
+ * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
+ * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
+ */
+export declare function Mutate(current: TMutable, next: TMutable): void;

package/build/value/mutate/mutate.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import { MutateError } from './error.mjs';
+import { FromValue } from './from-value.mjs';
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
+function IsNonMutableValue(value) {
+    return GlobalsGuard.IsTypeArray(value)
+        || GlobalsGuard.IsDate(value)
+        || GlobalsGuard.IsMap(value)
+        || GlobalsGuard.IsSet(value)
+        || Guard.IsNumber(value)
+        || Guard.IsString(value)
+        || Guard.IsBoolean(value)
+        || Guard.IsSymbol(value);
+}
+// ------------------------------------------------------------------
+// IsTrueObject
+// ------------------------------------------------------------------
+function IsMismatchedValue(left, right) {
+    return ((Guard.IsObjectNotArray(left) && Guard.IsArray(right)) ||
+        (Guard.IsArray(left) && Guard.IsObjectNotArray(right)));
+}
+// ------------------------------------------------------------------
+// Mutate
+// ------------------------------------------------------------------
+/**
+ * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
+ * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
+ * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
+ */
+export function Mutate(current, next) {
+    if (IsNonMutableValue(current) || IsNonMutableValue(next))
+        throw new MutateError('Only object and array types can be mutated at the root level');
+    if (IsMismatchedValue(current, next))
+        throw new MutateError('Cannot assign due type mismatch of assignable values');
+    FromValue(current, '', current, next);
+}

package/build/value/parse/index.d.mts

@@ -0,0 +1 @@
+export * from './parse.mjs';

package/build/value/parse/index.mjs

@@ -0,0 +1 @@
+export * from './parse.mjs';

package/build/value/parse/parse.d.mts

@@ -0,0 +1,20 @@
+import { type TProperties, type TSchema, type StaticParse } from '../../type/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+export declare class ParseError extends AssertError {
+    constructor(value: unknown, errors: object[]);
+}
+export declare const Parser: import("../pipeline/pipeline.mjs").PipelineInterface;
+/**
+ * Parses a value with the given type. The function will Check the value and return
+ * early if it matches the provided type. If the value does not match, it is processed
+ * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
+ * A `ParseError` is thrown if the value fails to match after the processing sequence.
+ */
+export declare function Parse<const Type extends TSchema, Result extends unknown = StaticParse<Type>>(type: Type, value: unknown): Result;
+/**
+ * Parses a value with the given type. The function will Check the value and return
+ * early if it matches the provided type. If the value does not match, it is processed
+ * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
+ * A `ParseError` is thrown if the value fails to match after the processing sequence.
+ */
+export declare function Parse<Context extends TProperties, const Type extends TSchema, Result extends unknown = StaticParse<Type, Context>>(context: Context, type: Type, value: unknown): Result;

package/build/value/parse/parse.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../errors/index.mjs';
+import { Clean } from '../clean/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Pipeline } from '../pipeline/index.mjs';
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+export class ParseError extends AssertError {
+    constructor(value, errors) {
+        super('Parse', value, errors);
+    }
+}
+function Assert(context, type, value) {
+    if (!Check(context, type, value))
+        throw new ParseError(value, Errors(context, type, value));
+    return value;
+}
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+export const Parser = Pipeline([
+    (_context, _type, value) => Clone(value),
+    (context, type, value) => Default(context, type, value),
+    (context, type, value) => Convert(context, type, value),
+    (context, type, value) => Clean(context, type, value),
+    (context, type, value) => Assert(context, type, value)
+]);
+/**
+ * Parses a value with the given type. The function will Check the value and return
+ * early if it matches the provided type. If the value does not match, it is processed
+ * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
+ * A `ParseError` is thrown if the value fails to match after the processing sequence.
+ */
+export function Parse(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const result = Check(context, type, value) ? value : Parser(context, type, value);
+    return result;
+}

package/build/value/pipeline/index.d.mts

@@ -0,0 +1 @@
+export * from './pipeline.mjs';

package/build/value/pipeline/index.mjs

@@ -0,0 +1 @@
+export * from './pipeline.mjs';

package/build/value/pipeline/pipeline.d.mts

@@ -0,0 +1,10 @@
+import { type TProperties, type TSchema } from '../../type/index.mjs';
+export interface PipelineFunction {
+    (context: TProperties, schema: TSchema, value: unknown): unknown;
+}
+export interface PipelineInterface {
+    (schema: TSchema, value: unknown): unknown;
+    (context: TProperties, schema: TSchema, value: unknown): unknown;
+}
+/** Creates a value processing pipeline. */
+export declare function Pipeline(pipeline: PipelineFunction[]): PipelineInterface;

package/build/value/pipeline/pipeline.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+// ------------------------------------------------------------------
+// Pipeline
+// ------------------------------------------------------------------
+/** Creates a value processing pipeline. */
+export function Pipeline(pipeline) {
+    return (...args) => {
+        const [context, type, value] = Arguments.Match(args, {
+            3: (context, type, value) => [context, type, value],
+            2: (type, value) => [{}, type, value],
+        });
+        return pipeline.reduce((result, func) => func(context, type, result), value);
+    };
+}

package/build/value/pointer/index.d.mts

@@ -0,0 +1 @@
+export * as Pointer from './pointer.mjs';

package/build/value/pointer/index.mjs

@@ -0,0 +1 @@
+export * as Pointer from './pointer.mjs';

package/build/value/pointer/pointer.d.mts

@@ -0,0 +1,17 @@
+type ObjectLike = Record<PropertyKey, any>;
+/** Transforms a pointer into navigable key components */
+export declare function Format(pointer: string): IterableIterator<string>;
+/**
+ * Sets the value at the given pointer and returns the updated value. If the pointer
+ * path does not exist, the path will be created.
+ */
+export declare function Set(value: ObjectLike, pointer: string, update: unknown): ObjectLike;
+/**
+ * Deletes a value at the given pointer and returns the updated value.
+ */
+export declare function Delete(value: ObjectLike, pointer: string): ObjectLike;
+/** Returns true if a property or element exists at the given pointer */
+export declare function Has(value: ObjectLike, pointer: string): boolean;
+/** Gets the value at the given pointer or undefined if not exists. */
+export declare function Get(value: ObjectLike, pointer: string): unknown | undefined;
+export {};

package/build/value/pointer/pointer.mjs

@@ -0,0 +1,137 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class ValuePointerRootSetError extends Error {
+    constructor(value, path, update) {
+        super('Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+class ValuePointerRootDeleteError extends Error {
+    constructor(value, path) {
+        super('Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+// ------------------------------------------------------------------
+// ValuePointer
+// ------------------------------------------------------------------
+/** Provides functionality to update values through RFC6901 string pointers */
+function Escape(component) {
+    const decoded = decodeURIComponent(component);
+    return decoded.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+// ------------------------------------------------------------------
+// Format
+// ------------------------------------------------------------------
+/** Transforms a pointer into navigable key components */
+export function* Format(pointer) {
+    if (pointer === '')
+        return;
+    let [start, end] = [0, 0];
+    for (let i = 0; i < pointer.length; i++) {
+        const char = pointer.charAt(i);
+        if (char === '/') {
+            if (i === 0) {
+                start = i + 1;
+            }
+            else {
+                end = i;
+                yield Escape(pointer.slice(start, end));
+                start = i + 1;
+            }
+        }
+        else {
+            end = i;
+        }
+    }
+    yield Escape(pointer.slice(start));
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/**
+ * Sets the value at the given pointer and returns the updated value. If the pointer
+ * path does not exist, the path will be created.
+ */
+export function Set(value, pointer, update) {
+    if (pointer === '')
+        throw new ValuePointerRootSetError(value, pointer, update);
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (Guard.IsUndefined(next[component]))
+            next[component] = {};
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    if (Guard.IsObject(owner)) {
+        owner[key] = update;
+    }
+    return value;
+}
+// ------------------------------------------------------------------
+// Delete
+// ------------------------------------------------------------------
+/**
+ * Deletes a value at the given pointer and returns the updated value.
+ */
+export function Delete(value, pointer) {
+    if (pointer === '')
+        throw new ValuePointerRootDeleteError(value, pointer);
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (Guard.IsUndefined(next[component]) || Guard.IsNull(next[component])) {
+            return value;
+        }
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    if (Guard.IsArray(owner)) {
+        const index = parseInt(key);
+        owner.splice(index, 1);
+    }
+    else if (Guard.IsObject(owner)) {
+        delete owner[key];
+    }
+    return value;
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if a property or element exists at the given pointer */
+export function Has(value, pointer) {
+    if (pointer === '')
+        return true;
+    let [owner, next, key] = [null, value, ''];
+    for (const component of Format(pointer)) {
+        if (Guard.IsUndefined(next[component]) || Guard.IsNull(next[component])) {
+            return false;
+        }
+        owner = next;
+        next = next[component];
+        key = component;
+    }
+    return Object.getOwnPropertyNames(owner).includes(key);
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets the value at the given pointer or undefined if not exists. */
+export function Get(value, pointer) {
+    if (pointer === '')
+        return value;
+    let current = value;
+    for (const component of Format(pointer)) {
+        if (current[component] === undefined)
+            return undefined;
+        current = current[component];
+    }
+    return current;
+}

package/build/value/repair/error.d.mts

@@ -0,0 +1,7 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+export declare class RepairError extends Error {
+    readonly context: TProperties;
+    readonly type: TSchema;
+    readonly value: unknown;
+    constructor(context: TProperties, type: TSchema, value: unknown, message: string);
+}

package/build/value/repair/error.mjs

@@ -0,0 +1,8 @@
+export class RepairError extends Error {
+    constructor(context, type, value, message) {
+        super(message);
+        this.context = context;
+        this.type = type;
+        this.value = value;
+    }
+}

package/build/value/repair/from-array.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TArray } from '../../type/index.mjs';
+export declare function FromArray(context: TProperties, type: TArray, value: unknown): unknown;

package/build/value/repair/from-array.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import { IsMaxItems, IsMinItems, IsUniqueItems } from '../../schema/types/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Hash } from '../hash/index.mjs';
+import { FromType } from './from-type.mjs';
+import { RepairError } from './error.mjs';
+// ------------------------------------------------------------------
+// MakeUnique
+// ------------------------------------------------------------------
+function MakeUnique(values) {
+    const [hashes, result] = [new Set(), []];
+    for (const value of values) {
+        const hash = Hash(value);
+        if (hashes.has(hash))
+            continue;
+        hashes.add(hash);
+        result.push(value);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+export function FromArray(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    const created = Guard.IsArray(value) ? value : Create(context, type);
+    const minimum = IsMinItems(type) && created.length < type.minItems ? [...created, ...Array.from({ length: type.minItems - created.length }, () => Create(context, type))] : created;
+    const maximum = IsMaxItems(type) && minimum.length > type.maxItems ? minimum.slice(0, type.maxItems) : minimum;
+    const repaired = maximum.map((value) => FromType(context, type.items, value));
+    if (!IsUniqueItems(type) || (IsUniqueItems(type) && !Guard.IsEqual(type.uniqueItems, true)))
+        return repaired;
+    const unique = MakeUnique(repaired);
+    if (!Check(context, type, unique))
+        throw new RepairError(context, type, value, 'Failed to repair Array due to uniqueItems constraint');
+    return unique;
+}

package/build/value/repair/from-enum.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TEnum } from '../../type/index.mjs';
+export declare function FromEnum(context: TProperties, type: TEnum, value: unknown): unknown;

package/build/value/repair/from-enum.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { EnumToUnion } from '../../type/engine/enum/index.mjs';
+import { FromType } from './from-type.mjs';
+export function FromEnum(context, type, value) {
+    const union = EnumToUnion(type);
+    return FromType(context, union, value);
+}

package/build/value/repair/from-intersect.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TIntersect } from '../../type/index.mjs';
+export declare function FromIntersect(context: TProperties, type: TIntersect, value: unknown): unknown;