pi-proactive 0.2.0-beta.2 → 0.2.0-beta.4

package/node_modules/typebox/build/system/memory/deep.mjs

@@ -1,108 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// ClassInstance
-//
-// TypeBox does not clone arbitrary class instances. Class instances
-// cannot be safely cloned without potentially breaking private
-// members of the instance.
-//
-// ------------------------------------------------------------------
-function FromClassInstance(value) {
-    return value; // atomic
-}
-// ------------------------------------------------------------------
-// SchemaObject
-//
-// Schema objects have non-enumerable properties that MUST be preserved 
-// on Clone. The following is the optimal path these objects.
-// ------------------------------------------------------------------
-function IsSchemaObject(value) {
-    return (Guard.HasPropertyKey(value, '~kind') ||
-        Guard.HasPropertyKey(value, '~unsafe'));
-}
-function FromSchemaObject(value) {
-    const result = {};
-    for (const key of Guard.Keys(value)) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
-        const descriptor = Object.getOwnPropertyDescriptor(value, key); // safe-name!
-        descriptor.value = FromValue(descriptor.value);
-        if (Guard.IsEqual(descriptor.enumerable, true)) {
-            result[key] = descriptor.value;
-        }
-        else {
-            Object.defineProperty(result, key, descriptor);
-        }
-    }
-    return result;
-}
-// ------------------------------------------------------------------
-// PlainObject
-// ------------------------------------------------------------------
-function FromPlainObject(value) {
-    const result = {};
-    for (const key of Guard.Keys(value)) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
-        result[key] = FromValue(value[key]);
-    }
-    for (const key of Guard.Symbols(value)) {
-        result[key] = FromValue(value[key]);
-    }
-    return result;
-}
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
-    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
-        IsSchemaObject(value) ? FromSchemaObject(value) :
-            FromPlainObject(value));
-}
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((element) => FromValue(element));
-}
-// ------------------------------------------------------------------
-// TypeArray
-// ------------------------------------------------------------------
-function FromTypedArray(value) {
-    return value.slice();
-}
-// ------------------------------------------------------------------
-// RegExp
-// ------------------------------------------------------------------
-function FromRegExp(value) {
-    return new RegExp(value.source, value.flags);
-}
-// ------------------------------------------------------------------
-// Map
-// ------------------------------------------------------------------
-function FromMap(value) {
-    return new Map(FromValue([...value.entries()]));
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-function FromSet(value) {
-    return new Set(FromValue([...value.values()]));
-}
-function FromValue(value) {
-    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
-        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
-            GlobalsGuard.IsMap(value) ? FromMap(value) :
-                GlobalsGuard.IsSet(value) ? FromSet(value) :
-                    Guard.IsArray(value) ? FromArray(value) :
-                        Guard.IsObject(value) ? FromObject(value) :
-                            value);
-}
-// ------------------------------------------------------------------
-// Deep
-// ------------------------------------------------------------------
-/** Returns a deep Clone of the given value. This function is similar to structuredClone() but also supports deep cloning instances of Map, Set and TypeArray. */
-export function Deep(value) {
-    return FromValue(value);
-}

package/node_modules/typebox/build/system/memory/discard.d.mts

@@ -1,4 +0,0 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Discards property keys from the given object. */
-export declare function Discard(value: ObjectLike, propertyKeys: PropertyKey[]): ObjectLike;
-export {};

package/node_modules/typebox/build/system/memory/discard.mjs

@@ -1,19 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import { Metrics } from './metrics.mjs';
-import { Finalize } from './finalize.mjs';
-import { Keys } from './keys.mjs';
-// ------------------------------------------------------------------
-// Discard
-// ------------------------------------------------------------------
-/** Discards property keys from the given object. */
-export function Discard(value, propertyKeys) {
-    Metrics.discard += 1;
-    const result = {};
-    for (const key of Keys(value)) {
-        if (propertyKeys.includes(key))
-            continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        Object.defineProperty(result, key, descriptor);
-    }
-    return Finalize(result);
-}

package/node_modules/typebox/build/system/memory/finalize.d.mts

@@ -1,4 +0,0 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Finalizes a type. Will recursively freeze if `immutableTypes` is true, otherwise no action. */
-export declare function Finalize(value: ObjectLike): ObjectLike;
-export {};

package/node_modules/typebox/build/system/memory/finalize.mjs

@@ -1,30 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import { Guard } from '../../guard/index.mjs';
-import { Settings } from '../settings/index.mjs';
-import { Keys } from './keys.mjs';
-// ------------------------------------------------------------------
-// Freeze
-// ------------------------------------------------------------------
-function Freeze(value, seen) {
-    if (seen.has(value))
-        return;
-    seen.add(value);
-    for (const key of Keys(value)) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (!descriptor || !('value' in descriptor))
-            continue;
-        if (Guard.IsObject(descriptor.value))
-            Freeze(descriptor.value, seen);
-    }
-    Object.freeze(value);
-}
-// ------------------------------------------------------------------
-// Finalize
-// ------------------------------------------------------------------
-/** Finalizes a type. Will recursively freeze if `immutableTypes` is true, otherwise no action. */
-export function Finalize(value) {
-    if (!Settings.Get().immutableTypes)
-        return value;
-    Freeze(value, new WeakSet());
-    return value;
-}

package/node_modules/typebox/build/system/memory/index.d.mts

@@ -1 +0,0 @@
-export * as Memory from './memory.mjs';

package/node_modules/typebox/build/system/memory/index.mjs

@@ -1 +0,0 @@
-export * as Memory from './memory.mjs';

package/node_modules/typebox/build/system/memory/keys.d.mts

@@ -1,2 +0,0 @@
-/** Returns the own string and symbol keys of the given object. */
-export declare function Keys(value: Record<PropertyKey, unknown>): PropertyKey[];

package/node_modules/typebox/build/system/memory/keys.mjs

@@ -1,8 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Keys (alternatively, Reflect.ownKeys(...))
-// ------------------------------------------------------------------
-/** Returns the own string and symbol keys of the given object. */
-export function Keys(value) {
-    return [...Guard.Keys(value), ...Guard.Symbols(value)];
-}

package/node_modules/typebox/build/system/memory/memory.d.mts

@@ -1,6 +0,0 @@
-export * from './assign.mjs';
-export * from './clone.mjs';
-export * from './create.mjs';
-export * from './discard.mjs';
-export * from './metrics.mjs';
-export * from './update.mjs';

package/node_modules/typebox/build/system/memory/memory.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-export * from './assign.mjs';
-export * from './clone.mjs';
-export * from './create.mjs';
-export * from './discard.mjs';
-export * from './metrics.mjs';
-export * from './update.mjs';

package/node_modules/typebox/build/system/memory/metrics.d.mts

@@ -1,14 +0,0 @@
-export interface TMetrics {
-    /** The number of times Assign() was called */
-    assign: number;
-    /** The number of times Create() was called */
-    create: number;
-    /** The number of times Clone() was called */
-    clone: number;
-    /** The number of times Discard() was called */
-    discard: number;
-    /** The number of times Update() was called */
-    update: number;
-}
-/** TypeBox instantiation metrics */
-export declare const Metrics: TMetrics;

package/node_modules/typebox/build/system/memory/metrics.mjs

@@ -1,8 +0,0 @@
-/** TypeBox instantiation metrics */
-export const Metrics = {
-    assign: 0,
-    create: 0,
-    clone: 0,
-    discard: 0,
-    update: 0
-};

package/node_modules/typebox/build/system/memory/update.d.mts

@@ -1,4 +0,0 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
-export declare function Update(current: ObjectLike, hidden: ObjectLike, enumerable: ObjectLike): ObjectLike;
-export {};

package/node_modules/typebox/build/system/memory/update.mjs

@@ -1,60 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import { Guard } from '../../guard/index.mjs';
-import { Settings } from '../settings/index.mjs';
-import { Metrics } from './metrics.mjs';
-import { Finalize } from './finalize.mjs';
-import { Keys } from './keys.mjs';
-// ------------------------------------------------------------------
-// WithCurrent
-// ------------------------------------------------------------------
-function WithCurrent(current, hiddenKeys, enumerableKeys, result) {
-    for (const key of Keys(current)) {
-        if (Guard.IsUnsafePropertyKey(key) || hiddenKeys.includes(key) || enumerableKeys.includes(key))
-            continue; // (ignore: prototype-pollution)
-        const descriptor = Object.getOwnPropertyDescriptor(current, key); // safe-name!
-        Object.defineProperty(result, key, descriptor);
-    }
-}
-// ------------------------------------------------------------------
-// WithHidden
-// ------------------------------------------------------------------
-function WithHidden(hidden, keys, result) {
-    const enumerableKind = Settings.Get().enumerableKind;
-    for (const key of keys) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
-        Object.defineProperty(result, key, {
-            configurable: true,
-            writable: true,
-            enumerable: enumerableKind,
-            value: hidden[key]
-        });
-    }
-}
-// ------------------------------------------------------------------
-// WithEnumerable
-// ------------------------------------------------------------------
-function WithEnumerable(enumerable, keys, result) {
-    for (const key of keys) {
-        if (Guard.IsUnsafePropertyKey(key))
-            continue; // (ignore: prototype-pollution)
-        Object.defineProperty(result, key, {
-            configurable: true,
-            enumerable: true,
-            writable: true,
-            value: enumerable[key]
-        });
-    }
-}
-// ------------------------------------------------------------------
-// Update
-// ------------------------------------------------------------------
-/** Updates an existing type with additional hidden and enumerable properties while preserving property configuration. */
-export function Update(current, hidden, enumerable) {
-    Metrics.update += 1;
-    const result = {}, hiddenKeys = Keys(hidden), enumerableKeys = Keys(enumerable);
-    WithCurrent(current, hiddenKeys, enumerableKeys, result);
-    WithHidden(hidden, hiddenKeys, result);
-    WithEnumerable(enumerable, enumerableKeys, result);
-    return Finalize(result);
-}

package/node_modules/typebox/build/system/settings/index.d.mts

@@ -1 +0,0 @@
-export * as Settings from './settings.mjs';

package/node_modules/typebox/build/system/settings/index.mjs

@@ -1 +0,0 @@
-export * as Settings from './settings.mjs';

package/node_modules/typebox/build/system/settings/internal.d.mts

@@ -1,2 +0,0 @@
-export declare function EnableParseErrors(): void;
-export declare function DisableParseErrors(): void;

package/node_modules/typebox/build/system/settings/internal.mjs

@@ -1,20 +0,0 @@
-import { Get } from './settings.mjs';
-// ------------------------------------------------------------------
-// TempMaxErrors
-// ------------------------------------------------------------------
-let TempMaxErrors = 0;
-// ------------------------------------------------------------------
-// [Internal] EnableParseErrors
-// ------------------------------------------------------------------
-export function EnableParseErrors() {
-    const settings = Get();
-    TempMaxErrors = settings.maxErrors;
-    settings.maxErrors = settings.maxParseErrors;
-}
-// ------------------------------------------------------------------
-// [Internal] DisableParseErrors
-// ------------------------------------------------------------------
-export function DisableParseErrors() {
-    const settings = Get();
-    settings.maxErrors = TempMaxErrors;
-}

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -1,91 +0,0 @@
-export interface TSettings {
-    /**
-     * Determines whether types should be instantiated as immutable using `Object.freeze(...)`.
-     * This helps prevent unintended schema mutation. Enabling this option introduces a slight
-     * performance overhead during instantiation.
-     *
-     * @default false
-     */
-    immutableTypes: boolean;
-    /**
-     * Specifies the maximum number of errors to buffer during diagnostics collection. TypeBox
-     * performs exhaustive checks to gather diagnostics for invalid values, which can result in
-     * excessive buffering for large or complex types. This setting limits the number of buffered
-     * errors and acts as a safeguard against potential denial-of-service (DoS) attacks.
-     *
-     * @default 8
-     */
-    maxErrors: number;
-    /**
-     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
-     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
-     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
-     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
-     * errors are needed. The default setting of 1 will terminate on the first error, while a
-     * setting of 0 will skip error gathering entirely.
-     *
-     * @default 1
-     */
-    maxParseErrors: number;
-    /**
-     * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
-     * context. This setting can be used to bound generic calls to a fixed count, which can be useful if
-     * evaluating string-encoded types originating from untrusted sources. Setting this value to 0 will
-     * disallow generics entirely, ensuring type instantiation runs linear.
-     *
-     * @default 128
-     */
-    maxInstantiationCount: number;
-    /**
-     * Enables or disables the use of runtime code evaluation to accelerate validation. By default,
-     * TypeBox checks for `unsafe-eval` support in the environment before attempting to evaluate
-     * generated code. If evaluation is not permitted, it falls back to dynamic checking. Setting
-     * this to `false` disables evaluation entirely, which may be desirable in applications that
-     * restrict runtime code evaluation, regardless of Content Security Policy (CSP).
-     *
-     * @default true
-     */
-    useAcceleration: boolean;
-    /**
-     * Enables or disables 'exactOptionalPropertyTypes' check semantics. By default, TypeScript
-     * allows optional properties to be assigned 'undefined'. While this behavior differs from the
-     * common interpretation of 'optional' as meaning 'key may be absent', TypeBox adopts the default
-     * TypeScript semantics to remain consistent with the language. This option is provided to align
-     * runtime check semantics with projects that configure 'exactOptionalPropertyTypes: true' in
-     * tsconfig.json.
-     *
-     * @default false
-     */
-    exactOptionalPropertyTypes: boolean;
-    /**
-     * Controls whether internal compositor properties (`~kind`, `~readonly`, `~optional`) are enumerable.
-     *
-     * @default false
-     */
-    enumerableKind: boolean;
-    /**
-     * Controls whether TypeBox uses corrective Parse. When enabled, TypeBox will attempt to recover invalid
-     * values during Parse by running a sequence of `Value.*` operations to `Convert`, `Default`, and `Clean`
-     * the value, followed by a subsequent `Assert`. Enabling this option may incur significant performance
-     * overhead for invalid values. It is recommended to keep this disabled in performance-sensitive
-     * applications.
-     *
-     * @default false
-     */
-    correctiveParse: boolean;
-    /**
-     * Controls whether TypeBox sorts Union variants by specificity (narrowest first) for operations
-     * that require deterministic value matching, such as Clean, Decode, and Encode. When enabled,
-     * more specific types (e.g. Literal) always take precedence over broader types (e.g. String),
-     * regardless of the order variants are declared.
-     *
-     * @default true
-     */
-    unionPrioritySort: boolean;
-}
-/** Resets system settings to defaults */
-export declare function Reset(): void;
-/** Sets system settings */
-export declare function Set(options: Partial<TSettings>): void;
-/** Gets current system settings */
-export declare function Get(): Readonly<TSettings>;

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,50 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-// -------------------------------------------------------------------
-// State
-// -------------------------------------------------------------------
-// Internal mutable state
-const settings = {
-    immutableTypes: false,
-    maxErrors: 8,
-    maxParseErrors: 1,
-    maxInstantiationCount: 128,
-    useAcceleration: true,
-    exactOptionalPropertyTypes: false,
-    enumerableKind: false,
-    correctiveParse: false,
-    unionPrioritySort: true
-};
-// -------------------------------------------------------------------
-// Reset
-// -------------------------------------------------------------------
-/** Resets system settings to defaults */
-export function Reset() {
-    settings.immutableTypes = false;
-    settings.maxErrors = 8;
-    settings.maxParseErrors = 1;
-    settings.maxInstantiationCount = 128;
-    settings.useAcceleration = true;
-    settings.exactOptionalPropertyTypes = false;
-    settings.enumerableKind = false;
-    settings.correctiveParse = false;
-    settings.unionPrioritySort = true;
-}
-// -------------------------------------------------------------------
-// Set
-// -------------------------------------------------------------------
-/** Sets system settings */
-export function Set(options) {
-    for (const key of Guard.Keys(options)) {
-        const value = options[key];
-        if (value !== undefined) {
-            Object.defineProperty(settings, key, { value });
-        }
-    }
-}
-// -------------------------------------------------------------------
-// Get
-// -------------------------------------------------------------------
-/** Gets current system settings */
-export function Get() {
-    return settings;
-}

package/node_modules/typebox/build/system/system.d.mts

@@ -1,6 +0,0 @@
-export * from './arguments/index.mjs';
-export * from './environment/index.mjs';
-export * from './hashing/index.mjs';
-export * from './locale/index.mjs';
-export * from './memory/index.mjs';
-export * from './settings/index.mjs';

package/node_modules/typebox/build/system/system.mjs

@@ -1,6 +0,0 @@
-export * from './arguments/index.mjs';
-export * from './environment/index.mjs';
-export * from './hashing/index.mjs';
-export * from './locale/index.mjs';
-export * from './memory/index.mjs';
-export * from './settings/index.mjs';

package/node_modules/typebox/build/system/unreachable/index.d.mts

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

package/node_modules/typebox/build/system/unreachable/index.mjs

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

package/node_modules/typebox/build/system/unreachable/unreachable.d.mts

@@ -1,3 +0,0 @@
-export type TUnreachable = never;
-/** Used for unreachable logic */
-export declare function Unreachable(): TUnreachable;

package/node_modules/typebox/build/system/unreachable/unreachable.mjs

@@ -1,6 +0,0 @@
-// deno-coverage-ignore-start - unreachable by definition
-/** Used for unreachable logic */
-export function Unreachable() {
-    throw new Error('Unreachable');
-}
-// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/action/_add_immutable.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TAddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
-/** Creates a deferred AddImmutable action. */
-export type TAddImmutableDeferred<Type extends TSchema> = (TDeferred<'AddImmutable', [Type]>);
-/** Creates a deferred AddImmutable action. */
-export declare function AddImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutableDeferred<Type>;
-/** Applies an AddImmutable action to a type. */
-export type TAddImmutable<Type extends TSchema> = (TAddImmutableAction<Type>);
-/** Applies an AddImmutable action to a type. */
-export declare function AddImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddImmutable<Type>;

package/node_modules/typebox/build/type/action/_add_immutable.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { AddImmutableAction } from '../engine/immutable/instantiate_add.mjs';
-/** Creates a deferred AddImmutable action. */
-export function AddImmutableDeferred(type, options = {}) {
-    return Deferred('AddImmutable', [type], options);
-}
-/** Applies an AddImmutable action to a type. */
-export function AddImmutable(type, options = {}) {
-    return AddImmutableAction(type, options);
-}

package/node_modules/typebox/build/type/action/_add_optional.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TAddOptionalAction } from '../engine/optional/instantiate_add.mjs';
-/** Creates a deferred AddOptional action. */
-export type TAddOptionalDeferred<Type extends TSchema> = (TDeferred<'AddOptional', [Type]>);
-/** Creates a deferred AddOptional action. */
-export declare function AddOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptionalDeferred<Type>;
-/** Applies an AddOptional action to a type. */
-export type TAddOptional<Type extends TSchema> = (TAddOptionalAction<Type>);
-/** Applies an AddOptional action to a type. */
-export declare function AddOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddOptional<Type>;

package/node_modules/typebox/build/type/action/_add_optional.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { AddOptionalAction } from '../engine/optional/instantiate_add.mjs';
-/** Creates a deferred AddOptional action. */
-export function AddOptionalDeferred(type, options = {}) {
-    return Deferred('AddOptional', [type], options);
-}
-/** Applies an AddOptional action to a type. */
-export function AddOptional(type, options = {}) {
-    return AddOptionalAction(type, options);
-}

package/node_modules/typebox/build/type/action/_add_readonly.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TAddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
-/** Creates a deferred AddReadonly action. */
-export type TAddReadonlyDeferred<Type extends TSchema> = (TDeferred<'AddReadonly', [Type]>);
-/** Creates a deferred AddReadonly action. */
-export declare function AddReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonlyDeferred<Type>;
-/** Applies an AddReadonly action to a type. */
-export type TAddReadonly<Type extends TSchema> = (TAddReadonlyAction<Type>);
-/** Applies an AddReadonly action to a type. */
-export declare function AddReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAddReadonly<Type>;

package/node_modules/typebox/build/type/action/_add_readonly.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { AddReadonlyAction } from '../engine/readonly/instantiate_add.mjs';
-/** Creates a deferred AddReadonly action. */
-export function AddReadonlyDeferred(type, options = {}) {
-    return Deferred('AddReadonly', [type], options);
-}
-/** Applies an AddReadonly action to a type. */
-export function AddReadonly(type, options = {}) {
-    return AddReadonlyAction(type, options);
-}

package/node_modules/typebox/build/type/action/_remove_immutable.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TRemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
-/** Creates a deferred RemoveImmutable action. */
-export type TRemoveImmutableDeferred<Type extends TSchema> = (TDeferred<'RemoveImmutable', [Type]>);
-/** Creates a deferred RemoveImmutable action. */
-export declare function RemoveImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutableDeferred<Type>;
-/** Applies an RemoveImmutable action to a type. */
-export type TRemoveImmutable<Type extends TSchema> = (TRemoveImmutableAction<Type>);
-/** Applies an RemoveImmutable action to a type. */
-export declare function RemoveImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutable<Type>;

package/node_modules/typebox/build/type/action/_remove_immutable.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { RemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
-/** Creates a deferred RemoveImmutable action. */
-export function RemoveImmutableDeferred(type, options = {}) {
-    return Deferred('RemoveImmutable', [type], options);
-}
-/** Applies an RemoveImmutable action to a type. */
-export function RemoveImmutable(type, options = {}) {
-    return RemoveImmutableAction(type, options);
-}

package/node_modules/typebox/build/type/action/_remove_optional.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
-import { type TDeferred } from '../types/deferred.mjs';
-import { type TRemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
-/** Creates a deferred RemoveOptional action. */
-export type TRemoveOptionalDeferred<Type extends TSchema> = (TDeferred<'RemoveOptional', [Type]>);
-/** Creates a deferred RemoveOptional action. */
-export declare function RemoveOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptionalDeferred<Type>;
-/** Applies an RemoveOptional action to a type. */
-export type TRemoveOptional<Type extends TSchema> = (TRemoveOptionalAction<Type>);
-/** Applies an RemoveOptional action to a type. */
-export declare function RemoveOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptional<Type>;

package/node_modules/typebox/build/type/action/_remove_optional.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { Deferred } from '../types/deferred.mjs';
-import { RemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
-/** Creates a deferred RemoveOptional action. */
-export function RemoveOptionalDeferred(type, options = {}) {
-    return Deferred('RemoveOptional', [type], options);
-}
-/** Applies an RemoveOptional action to a type. */
-export function RemoveOptional(type, options = {}) {
-    return RemoveOptionalAction(type, options);
-}