@astrofoundry/pi-astro 0.17.1 → 0.18.1

package/node_modules/typebox/build/type/types/integer.mjs

@@ -1,21 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Pattern
-// ------------------------------------------------------------------
-export const IntegerPattern = '-?(?:0|[1-9][0-9]*)';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Integer type. */
-export function Integer(options) {
-    return Memory.Create({ '~kind': 'Integer' }, { type: 'integer' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TInteger. */
-export function IsInteger(value) {
-    return IsKind(value, 'Integer');
-}

package/node_modules/typebox/build/type/types/intersect.d.mts

@@ -1,15 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TIntersectOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticIntersect<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Stack, Direction, Context, This, Right, Result & StaticType<Stack, Direction, Context, This, Left>> : Result);
-/** Represents a logical Intersect type. */
-export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
-    '~kind': 'Intersect';
-    allOf: Types;
-}
-/** Creates a Intersect type. */
-export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
-/** Returns true if the given value is TIntersect. */
-export declare function IsIntersect(value: unknown): value is TIntersect;
-/** Extracts options from a TIntersect. */
-export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

package/node_modules/typebox/build/type/types/intersect.mjs

@@ -1,24 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Intersect type. */
-export function Intersect(types, options = {}) {
-    return Memory.Create({ '~kind': 'Intersect' }, { allOf: types }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TIntersect. */
-export function IsIntersect(value) {
-    return IsKind(value, 'Intersect');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TIntersect. */
-export function IntersectOptions(type) {
-    return Memory.Discard(type, ['~kind', 'allOf']);
-}

package/node_modules/typebox/build/type/types/iterator.d.mts

@@ -1,20 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = IterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents an Iterator. */
-export interface TIterator<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Iterator';
-    type: 'iterator';
-    iteratorItems: Type;
-}
-/**
- * Creates a Iterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export declare function Iterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TIterator<Type>;
-/** Returns true if the given value is TIterator. */
-export declare function IsIterator(value: unknown): value is TIterator;
-/** Extracts options from a TIterator. */
-export declare function IteratorOptions(type: TIterator): TSchemaOptions;

package/node_modules/typebox/build/type/types/iterator.mjs

@@ -1,28 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/**
- * Creates a Iterator type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export function Iterator(iteratorItems, options) {
-    return Memory.Create({ '~kind': 'Iterator' }, { type: 'iterator', iteratorItems }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TIterator. */
-export function IsIterator(value) {
-    return IsKind(value, 'Iterator');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TIterator. */
-export function IteratorOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
-}

package/node_modules/typebox/build/type/types/literal.d.mts

@@ -1,31 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-export declare class InvalidLiteralValue extends Error {
-    readonly cause: {
-        value: unknown;
-    };
-    constructor(value: unknown);
-}
-export type StaticLiteral<Value extends TLiteralValue> = (Value);
-export type TLiteralTypeName<Value extends TLiteralValue> = (Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends number ? 'number' : Value extends string ? 'string' : never);
-export declare function LiteralTypeName<Value extends TLiteralValue>(value: Value): TLiteralTypeName<Value>;
-export type TLiteralValue = string | number | boolean | bigint;
-/** Represents a Literal type. */
-export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
-    '~kind': 'Literal';
-    type: TLiteralTypeName<Value>;
-    const: Value;
-}
-/** Creates a Literal type. */
-export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
-/** Returns true if the given value is a TLiteralValue. */
-export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
-/** Returns true if the given value is TLiteral<bigint>. */
-export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
-/** Returns true if the given value is TLiteral<boolean>. */
-export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
-/** Returns true if the given value is TLiteral<number>. */
-export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
-/** Returns true if the given value is TLiteral<string>. */
-export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
-/** Returns true if the given value is TLiteral. */
-export declare function IsLiteral(value: unknown): value is TLiteral;

package/node_modules/typebox/build/type/types/literal.mjs

@@ -1,62 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// InvalidLiteralValue
-// ------------------------------------------------------------------
-export class InvalidLiteralValue extends Error {
-    constructor(value) {
-        super(`Invalid Literal value`);
-        Object.defineProperty(this, 'cause', {
-            value: { value },
-            writable: false,
-            configurable: false,
-            enumerable: false
-        });
-    }
-}
-export function LiteralTypeName(value) {
-    return (Guard.IsBigInt(value) ? 'bigint' :
-        Guard.IsBoolean(value) ? 'boolean' :
-            Guard.IsNumber(value) ? 'number' :
-                Guard.IsString(value) ? 'string' :
-                    (() => { throw new InvalidLiteralValue(value); })());
-}
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Literal type. */
-export function Literal(value, options) {
-    return Memory.Create({ '~kind': 'Literal' }, { type: LiteralTypeName(value), const: value }, options);
-}
-// ------------------------------------------------------------------
-// Guards
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TLiteralValue. */
-export function IsLiteralValue(value) {
-    return Guard.IsBigInt(value)
-        || Guard.IsBoolean(value)
-        || Guard.IsNumber(value)
-        || Guard.IsString(value);
-}
-/** Returns true if the given value is TLiteral<bigint>. */
-export function IsLiteralBigInt(value) {
-    return IsLiteral(value) && Guard.IsBigInt(value.const);
-}
-/** Returns true if the given value is TLiteral<boolean>. */
-export function IsLiteralBoolean(value) {
-    return IsLiteral(value) && Guard.IsBoolean(value.const);
-}
-/** Returns true if the given value is TLiteral<number>. */
-export function IsLiteralNumber(value) {
-    return IsLiteral(value) && Guard.IsNumber(value.const);
-}
-/** Returns true if the given value is TLiteral<string>. */
-export function IsLiteralString(value) {
-    return IsLiteral(value) && Guard.IsString(value.const);
-}
-/** Returns true if the given value is TLiteral. */
-export function IsLiteral(value) {
-    return IsKind(value, 'Literal');
-}

package/node_modules/typebox/build/type/types/never.d.mts

@@ -1,12 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-export declare const NeverPattern = "(?!)";
-export type StaticNever = never;
-/** Represents a Never type. */
-export interface TNever extends TSchema {
-    '~kind': 'Never';
-    not: {};
-}
-/** Creates a Never type. */
-export declare function Never(options?: TSchemaOptions): TNever;
-/** Returns true if the given value is TNever. */
-export declare function IsNever(value: unknown): value is TNever;

package/node_modules/typebox/build/type/types/never.mjs

@@ -1,22 +0,0 @@
-// deno-lint-ignore-file ban-types
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Pattern
-// ------------------------------------------------------------------
-export const NeverPattern = '(?!)';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Never type. */
-export function Never(options) {
-    return Memory.Create({ '~kind': 'Never' }, { not: {} }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TNever. */
-export function IsNever(value) {
-    return IsKind(value, 'Never');
-}

package/node_modules/typebox/build/type/types/null.d.mts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-export type StaticNull = null;
-/** Represents a Null type. */
-export interface TNull extends TSchema {
-    '~kind': 'Null';
-    type: 'null';
-}
-/** Creates a Null type. */
-export declare function Null(options?: TSchemaOptions): TNull;
-/** Returns true if the given value is TNull. */
-export declare function IsNull(value: unknown): value is TNull;

package/node_modules/typebox/build/type/types/null.mjs

@@ -1,17 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Null type. */
-export function Null(options) {
-    return Memory.Create({ '~kind': 'Null' }, { type: 'null' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TNull. */
-export function IsNull(value) {
-    return IsKind(value, 'Null');
-}

package/node_modules/typebox/build/type/types/number.d.mts

@@ -1,12 +0,0 @@
-import { type TSchema, type TNumberOptions } from './schema.mjs';
-export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
-export type StaticNumber = number;
-/** Represents a Number type. */
-export interface TNumber extends TSchema {
-    '~kind': 'Number';
-    type: 'number';
-}
-/** Creates a Number type. */
-export declare function Number(options?: TNumberOptions): TNumber;
-/** Returns true if the given value is a TNumber. */
-export declare function IsNumber(value: unknown): value is TNumber;

package/node_modules/typebox/build/type/types/number.mjs

@@ -1,21 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Pattern
-// ------------------------------------------------------------------
-export const NumberPattern = '-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Number type. */
-export function Number(options) {
-    return Memory.Create({ '~kind': 'Number' }, { type: 'number' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TNumber. */
-export function IsNumber(value) {
-    return IsKind(value, 'Number');
-}

package/node_modules/typebox/build/type/types/object.d.mts

@@ -1,18 +0,0 @@
-import { type StaticDirection } from './static.mjs';
-import { type TSchema, type TObjectOptions } from './schema.mjs';
-import { type TProperties, type TRequiredArray, type StaticProperties } from './properties.mjs';
-export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
-/** Represents an Object type. */
-export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
-    '~kind': 'Object';
-    type: 'object';
-    properties: Properties;
-    required: TRequiredArray<Properties>;
-}
-/** Creates an Object type. */
-export declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
-export { _Object_ as Object };
-/** Returns true if the given value is TObject. */
-export declare function IsObject(value: unknown): value is TObject;
-/** Extracts options from a TObject. */
-export declare function ObjectOptions(type: TObject): TObjectOptions;

package/node_modules/typebox/build/type/types/object.mjs

@@ -1,28 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-import { RequiredArray } from './properties.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates an Object type. */
-export function _Object_(properties, options = {}) {
-    const requiredKeys = RequiredArray(properties);
-    const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
-    return Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
-}
-export { _Object_ as Object }; // Prevent Collision With Global Scope
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TObject. */
-export function IsObject(value) {
-    return IsKind(value, 'Object');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TObject. */
-export function ObjectOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'properties', 'required']);
-}

package/node_modules/typebox/build/type/types/parameter.d.mts

@@ -1,17 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type TUnknown } from './unknown.mjs';
-/** Represents a Generic parameter. */
-export interface TParameter<Name extends string = string, Extends extends TSchema = TSchema, Equals extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Parameter';
-    name: Name;
-    extends: Extends;
-    equals: Equals;
-}
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends, equals: Equals): TParameter<Name, Extends, Equals>;
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends): TParameter<Name, Extends, Extends>;
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string>(name: Name): TParameter<Name, TUnknown, TUnknown>;
-/** Returns true if the given value is TParameter. */
-export declare function IsParameter(value: unknown): value is TParameter;

package/node_modules/typebox/build/type/types/parameter.mjs

@@ -1,21 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-import { Unknown } from './unknown.mjs';
-/** Creates a Parameter type. */
-export function Parameter(...args) {
-    const [name, extends_, equals] = Arguments.Match(args, {
-        3: (name, extends_, equals) => [name, extends_, equals],
-        2: (name, extends_) => [name, extends_, extends_],
-        1: (name) => [name, Unknown(), Unknown()],
-    });
-    return Memory.Create({ '~kind': 'Parameter' }, { name, extends: extends_, equals }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TParameter. */
-export function IsParameter(value) {
-    return IsKind(value, 'Parameter');
-}

package/node_modules/typebox/build/type/types/promise.d.mts

@@ -1,21 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticPromise<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = Promise<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents a Promise type. */
-export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Promise';
-    type: 'promise';
-    item: Type;
-}
-/**
- * Creates a Promise type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export declare function _Promise_<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
-export { _Promise_ as Promise };
-/** Returns true if the given type is TPromise. */
-export declare function IsPromise(value: unknown): value is TPromise;
-/** Extracts options from a TPromise. */
-export declare function PromiseOptions(type: TPromise): TSchemaOptions;

package/node_modules/typebox/build/type/types/promise.mjs

@@ -1,29 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/**
- * Creates a Promise type.
- *
- * @deprecated This type is being removed in the next version of TypeBox. A fallback will be provided under examples.
- */
-export function _Promise_(item, options) {
-    return Memory.Create({ ['~kind']: 'Promise' }, { type: 'promise', item }, options);
-}
-export { _Promise_ as Promise };
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given type is TPromise. */
-export function IsPromise(value) {
-    return IsKind(value, 'Promise');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TPromise. */
-export function PromiseOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'item']);
-}

package/node_modules/typebox/build/type/types/properties.d.mts

@@ -1,43 +0,0 @@
-import { type StaticType, type StaticDirection, type StaticEvaluate } from './static.mjs';
-import { type TSchema } from './schema.mjs';
-import { type TOptional } from './_optional.mjs';
-import { type TReadonly } from './_readonly.mjs';
-import { type TUnionToTuple } from '../engine/helpers/union.mjs';
-type ReadonlyOptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
-}[keyof Properties]> = Result;
-type ReadonlyKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? never : Key) : never;
-}[keyof Properties]> = Result;
-type OptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TOptional<TSchema> ? (Properties[Key] extends TReadonly<Properties[Key]> ? never : Key) : never;
-}[keyof Properties]> = Result;
-type RequiredKeys<Properties extends TProperties, Result extends PropertyKey = keyof Omit<Properties, ReadonlyOptionalKeys<Properties> | ReadonlyKeys<Properties> | OptionalKeys<Properties>>> = Result;
-type StaticPropertiesWithModifiers<Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown>> = StaticEvaluate<Readonly<Partial<Pick<PropertiesWithoutModifiers, ReadonlyOptionalKeys<Properties>>>> & Readonly<Pick<PropertiesWithoutModifiers, ReadonlyKeys<Properties>>> & Partial<Pick<PropertiesWithoutModifiers, OptionalKeys<Properties>>> & Required<Pick<PropertiesWithoutModifiers, RequiredKeys<Properties>>>>;
-type StaticPropertiesWithoutModifiers<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, Result extends Record<PropertyKey, unknown> = {
-    [Key in keyof Properties]: StaticType<Stack, Direction, Context, This, Properties[Key]>;
-}> = Result;
-export type StaticProperties<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithoutModifiers<Stack, Direction, Context, This, Properties>, PropertiesWithModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithModifiers<Properties, PropertiesWithoutModifiers>, Result extends Record<PropertyKey, unknown> = {
-    [Key in keyof PropertiesWithModifiers]: PropertiesWithModifiers[Key];
-}> = Result;
-/** Represents a Record<PropertyKey, TSchema> structure. */
-export interface TProperties extends TSchema {
-    [key: PropertyKey]: TSchema;
-}
-/** Creates a RequiredArray derived from the given TProperties value. */
-export type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
-    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
-}, RequiredKeys extends string[] = TUnionToTuple<Extract<keyof RequiredProperties, string>>, Result extends string[] | undefined = RequiredKeys extends [] ? undefined : RequiredKeys> = Result;
-/** Creates a RequiredArray derived from the given TProperties value. */
-export declare function RequiredArray<Properties extends TProperties>(properties: Properties): TRequiredArray<Properties>;
-type TKeyToString<Key extends number | string> = `${Key}`;
-/** Extracts a tuple of keys from a TProperties value. */
-export type TPropertyKeys<Properties extends TProperties, ExtractKey extends number | string = Extract<keyof Properties, number | string>, StringKey extends string = TKeyToString<ExtractKey>, Result extends string[] = TUnionToTuple<StringKey>> = Result;
-/** Extracts a tuple of keys from a TProperties value. */
-export declare function PropertyKeys<Properties extends TProperties>(properties: Properties): TPropertyKeys<Properties>;
-type TPropertyValuesReduce<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Properties ? TPropertyValuesReduce<Properties, Right, [...Result, Properties[Left]]> : TPropertyValuesReduce<Properties, Right, Result> : Result;
-/** Extracts a tuple of property values from a TProperties value. */
-export type TPropertyValues<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, Result extends TSchema[] = TPropertyValuesReduce<Properties, Keys>> = Result;
-/** Extracts a tuple of property values from a TProperties value. */
-export declare function PropertyValues<Properties extends TProperties>(properties: Properties): TPropertyValues<Properties>;
-export {};

package/node_modules/typebox/build/type/types/properties.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsOptional } from './_optional.mjs';
-/** Creates a RequiredArray derived from the given TProperties value. */
-export function RequiredArray(properties) {
-    return Guard.Keys(properties).filter((key) => !IsOptional(properties[key]));
-}
-/** Extracts a tuple of keys from a TProperties value. */
-export function PropertyKeys(properties) {
-    return Guard.Keys(properties);
-}
-/** Extracts a tuple of property values from a TProperties value. */
-export function PropertyValues(properties) {
-    return Guard.Values(properties);
-}

package/node_modules/typebox/build/type/types/record.d.mts

@@ -1,46 +0,0 @@
-import { type TSchema, type TObjectOptions } from './schema.mjs';
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TProperties } from './properties.mjs';
-import { type TInteger } from './integer.mjs';
-import { type TNumber } from './number.mjs';
-import { type TString } from './string.mjs';
-import { type TDeferred } from './deferred.mjs';
-import { type TTemplateLiteralStatic } from '../engine/template_literal/index.mjs';
-import { type TTemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
-import { type TRecordAction } from '../engine/record/instantiate.mjs';
-type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
-export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = Record<StaticKey, StaticValue>> = Result;
-export type TStringKey = typeof StringKey;
-export type TIntegerKey = typeof IntegerKey;
-export type TNumberKey = typeof NumberKey;
-export declare const IntegerKey = "^-?(?:0|[1-9][0-9]*)$";
-export declare const NumberKey = "^-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?$";
-export declare const StringKey = "^.*$";
-export interface TRecord<Key extends string = string, Value extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Record';
-    type: 'object';
-    patternProperties: {
-        [_ in Key]: Value;
-    };
-}
-/** Represents a deferred Record action. */
-export type TRecordDeferred<Key extends TSchema = TSchema, Value extends TSchema = TSchema> = (TDeferred<'Record', [Key, Value]>);
-/** Represents a deferred Record action. */
-export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
-/** Creates a Record type. */
-export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordAction<Key, Value>;
-/** Creates a Record type from regular expression pattern. */
-export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
-/** Returns the raw string pattern used for the Record key  */
-export type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
-/** Returns the raw string pattern used for the Record key  */
-export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
-/** Returns the Record key as a TypeBox type  */
-export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof StringKey ? TString : Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TTemplateLiteralDecodeUnsafe<Pattern>)> = Result;
-/** Returns the Record key as a TypeBox type  */
-export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
-export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
-export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
-export declare function IsRecord(value: unknown): value is TRecord;
-export declare function RecordOptions(type: TRecord): TObjectOptions;
-export {};

package/node_modules/typebox/build/type/types/record.mjs

@@ -1,60 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsKind } from './schema.mjs';
-import { Integer, IntegerPattern } from './integer.mjs';
-import { Number, NumberPattern } from './number.mjs';
-import { String, StringPattern } from './string.mjs';
-import { Deferred } from './deferred.mjs';
-import { TemplateLiteralDecodeUnsafe } from '../engine/template_literal/decode.mjs';
-import { CreateRecord } from '../engine/record/record_create.mjs';
-import { RecordAction } from '../engine/record/instantiate.mjs';
-export const IntegerKey = `^${IntegerPattern}$`;
-export const NumberKey = `^${NumberPattern}$`;
-export const StringKey = `^${StringPattern}$`;
-/** Represents a deferred Record action. */
-export function RecordDeferred(key, value, options = {}) {
-    return Deferred('Record', [key, value], options);
-}
-// -------------------------------------------------------------------
-// Factory
-// -------------------------------------------------------------------
-/** Creates a Record type. */
-export function Record(key, value, options = {}) {
-    return RecordAction(key, value, options);
-}
-// -------------------------------------------------------------------
-// FromPattern
-// -------------------------------------------------------------------
-/** Creates a Record type from regular expression pattern. */
-export function RecordFromPattern(key, value) {
-    return CreateRecord(key, value);
-}
-/** Returns the raw string pattern used for the Record key  */
-export function RecordPattern(type) {
-    return Guard.Keys(type.patternProperties)[0];
-}
-/** Returns the Record key as a TypeBox type  */
-export function RecordKey(type) {
-    const pattern = RecordPattern(type);
-    const result = (Guard.IsEqual(pattern, StringKey) ? String() :
-        Guard.IsEqual(pattern, IntegerKey) ? Integer() :
-            Guard.IsEqual(pattern, NumberKey) ? Number() :
-                TemplateLiteralDecodeUnsafe(pattern));
-    return result;
-}
-export function RecordValue(type) {
-    return type.patternProperties[RecordPattern(type)];
-}
-// -------------------------------------------------------------------
-// Guard
-// -------------------------------------------------------------------
-export function IsRecord(value) {
-    return IsKind(value, 'Record');
-}
-// -------------------------------------------------------------------
-// Options
-// -------------------------------------------------------------------
-export function RecordOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'patternProperties']);
-}