@evalops/maestro 0.10.20 → 0.10.21

package/node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs

@@ -1,40 +0,0 @@
-import { TransformKind } from '../symbols/index.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsTransform } from '../guard/kind.mjs';
-// ------------------------------------------------------------------
-// TransformBuilders
-// ------------------------------------------------------------------
-export class TransformDecodeBuilder {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    Decode(decode) {
-        return new TransformEncodeBuilder(this.schema, decode);
-    }
-}
-// prettier-ignore
-export class TransformEncodeBuilder {
-    constructor(schema, decode) {
-        this.schema = schema;
-        this.decode = decode;
-    }
-    EncodeTransform(encode, schema) {
-        const Encode = (value) => schema[TransformKind].Encode(encode(value));
-        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-        const Codec = { Encode: Encode, Decode: Decode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    EncodeSchema(encode, schema) {
-        const Codec = { Decode: this.decode, Encode: encode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    Encode(encode) {
-        return (IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
-    }
-}
-/** `[Json]` Creates a Transform type */
-export function Transform(schema) {
-    return new TransformDecodeBuilder(schema);
-}

package/node_modules/@sinclair/typebox/build/esm/type/tuple/index.d.mts

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

package/node_modules/@sinclair/typebox/build/esm/type/tuple/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.d.mts

@@ -1,16 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TupleStatic<R, P, [...Acc, Static<L, P>]> : Acc;
-export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Tuple';
-    static: TupleStatic<T, this['params']>;
-    type: 'array';
-    items: T;
-    additionalItems?: false;
-    minItems: T['length'];
-    maxItems: T['length'];
-}
-/** `[Json]` Creates a Tuple type */
-export declare function Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
-export {};

package/node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs

@@ -1,9 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a Tuple type */
-export function Tuple(types, options) {
-    // prettier-ignore
-    return CreateType(types.length > 0 ?
-        { [Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
-        { [Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length }, options);
-}

package/node_modules/@sinclair/typebox/build/esm/type/type/index.d.mts

@@ -1,6 +0,0 @@
-export { JsonTypeBuilder } from './json.mjs';
-import { JavaScriptTypeBuilder } from './javascript.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-declare const Type: InstanceType<typeof JavaScriptTypeBuilder>;
-export { JavaScriptTypeBuilder };
-export { Type };

package/node_modules/@sinclair/typebox/build/esm/type/type/index.mjs

@@ -1,13 +0,0 @@
-// ------------------------------------------------------------------
-// JsonTypeBuilder
-// ------------------------------------------------------------------
-export { JsonTypeBuilder } from './json.mjs';
-// ------------------------------------------------------------------
-// JavaScriptTypeBuilder
-// ------------------------------------------------------------------
-import * as TypeBuilder from './type.mjs';
-import { JavaScriptTypeBuilder } from './javascript.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-const Type = TypeBuilder;
-export { JavaScriptTypeBuilder };
-export { Type };

package/node_modules/@sinclair/typebox/build/esm/type/type/javascript.d.mts

@@ -1,64 +0,0 @@
-import { JsonTypeBuilder } from './json.mjs';
-import { type TArgument } from '../argument/index.mjs';
-import { type TAsyncIterator } from '../async-iterator/index.mjs';
-import { type TAwaited } from '../awaited/index.mjs';
-import { type TBigInt, type BigIntOptions } from '../bigint/index.mjs';
-import { type TConstructor } from '../constructor/index.mjs';
-import { type TConstructorParameters } from '../constructor-parameters/index.mjs';
-import { type TDate, type DateOptions } from '../date/index.mjs';
-import { type TFunction } from '../function/index.mjs';
-import { type TInstanceType } from '../instance-type/index.mjs';
-import { type TInstantiate } from '../instantiate/index.mjs';
-import { type TIterator } from '../iterator/index.mjs';
-import { type TParameters } from '../parameters/index.mjs';
-import { type TPromise } from '../promise/index.mjs';
-import { type TRegExp, RegExpOptions } from '../regexp/index.mjs';
-import { type TReturnType } from '../return-type/index.mjs';
-import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TSymbol } from '../symbol/index.mjs';
-import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index.mjs';
-import { type TUndefined } from '../undefined/index.mjs';
-import { type TVoid } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a Generic Argument Type */
-    Argument<Index extends number>(index: Index): TArgument<Index>;
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type>;
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited<Type extends TSchema>(schema: Type, options?: SchemaOptions): TAwaited<Type>;
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options?: BigIntOptions): TBigInt;
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: SchemaOptions): TConstructor<Parameters, InstanceType>;
-    /** `[JavaScript]` Creates a Date type */
-    Date(options?: DateOptions): TDate;
-    /** `[JavaScript]` Creates a Function type */
-    Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType>;
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;
-    /** `[JavaScript]` Instantiates a type with the given parameters */
-    Instantiate<Type extends TSchema, Parameters extends TSchema[]>(schema: Type, parameters: [...Parameters]): TInstantiate<Type, Parameters>;
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type>;
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;
-    /** `[JavaScript]` Creates a Promise type */
-    Promise<Type extends TSchema>(item: Type, options?: SchemaOptions): TPromise<Type>;
-    /** `[JavaScript]` Creates a RegExp type */
-    RegExp(pattern: string, options?: RegExpOptions): TRegExp;
-    /** `[JavaScript]` Creates a RegExp type */
-    RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType<Type extends TSchema>(type: Type, options?: SchemaOptions): TReturnType<Type>;
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options?: SchemaOptions): TSymbol;
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options?: SchemaOptions): TUndefined;
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
-    /** `[JavaScript]` Creates a Void type */
-    Void(options?: SchemaOptions): TVoid;
-}

package/node_modules/@sinclair/typebox/build/esm/type/type/javascript.mjs

@@ -1,99 +0,0 @@
-import { JsonTypeBuilder } from './json.mjs';
-import { Argument } from '../argument/index.mjs';
-import { AsyncIterator } from '../async-iterator/index.mjs';
-import { Awaited } from '../awaited/index.mjs';
-import { BigInt } from '../bigint/index.mjs';
-import { Constructor } from '../constructor/index.mjs';
-import { ConstructorParameters } from '../constructor-parameters/index.mjs';
-import { Date } from '../date/index.mjs';
-import { Function as FunctionType } from '../function/index.mjs';
-import { InstanceType } from '../instance-type/index.mjs';
-import { Instantiate } from '../instantiate/index.mjs';
-import { Iterator } from '../iterator/index.mjs';
-import { Parameters } from '../parameters/index.mjs';
-import { Promise } from '../promise/index.mjs';
-import { RegExp } from '../regexp/index.mjs';
-import { ReturnType } from '../return-type/index.mjs';
-import { Symbol } from '../symbol/index.mjs';
-import { Uint8Array } from '../uint8array/index.mjs';
-import { Undefined } from '../undefined/index.mjs';
-import { Void } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a Generic Argument Type */
-    Argument(index) {
-        return Argument(index);
-    }
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options) {
-        return AsyncIterator(items, options);
-    }
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options) {
-        return Awaited(schema, options);
-    }
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options) {
-        return BigInt(options);
-    }
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options) {
-        return ConstructorParameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, instanceType, options) {
-        return Constructor(parameters, instanceType, options);
-    }
-    /** `[JavaScript]` Creates a Date type */
-    Date(options = {}) {
-        return Date(options);
-    }
-    /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returnType, options) {
-        return FunctionType(parameters, returnType, options);
-    }
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options) {
-        return InstanceType(schema, options);
-    }
-    /** `[JavaScript]` Instantiates a type with the given parameters */
-    Instantiate(schema, parameters) {
-        return Instantiate(schema, parameters);
-    }
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options) {
-        return Iterator(items, options);
-    }
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options) {
-        return Parameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options) {
-        return Promise(item, options);
-    }
-    /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options) {
-        return RegExp(unresolved, options);
-    }
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(type, options) {
-        return ReturnType(type, options);
-    }
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options) {
-        return Symbol(options);
-    }
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options) {
-        return Undefined(options);
-    }
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options) {
-        return Uint8Array(options);
-    }
-    /** `[JavaScript]` Creates a Void type */
-    Void(options) {
-        return Void(options);
-    }
-}

package/node_modules/@sinclair/typebox/build/esm/type/type/json.d.mts

@@ -1,208 +0,0 @@
-import { type TAny } from '../any/index.mjs';
-import { type TArray, type ArrayOptions } from '../array/index.mjs';
-import { type TBoolean } from '../boolean/index.mjs';
-import { type TComposite } from '../composite/index.mjs';
-import { type TConst } from '../const/index.mjs';
-import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
-import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index.mjs';
-import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
-import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index.mjs';
-import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
-import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
-import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
-import { type TKeyOf } from '../keyof/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
-import { type TNever } from '../never/index.mjs';
-import { type TNot } from '../not/index.mjs';
-import { type TNull } from '../null/index.mjs';
-import { type TMappedKey } from '../mapped/index.mjs';
-import { TModule } from '../module/index.mjs';
-import { type TNumber, type NumberOptions } from '../number/index.mjs';
-import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit } from '../omit/index.mjs';
-import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index.mjs';
-import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
-import { type TPick } from '../pick/index.mjs';
-import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index.mjs';
-import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
-import { type TRecordOrObject } from '../record/index.mjs';
-import { type TRecursive, type TThis } from '../recursive/index.mjs';
-import { type TRef, type TRefUnsafe } from '../ref/index.mjs';
-import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
-import { type TRest } from '../rest/index.mjs';
-import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TString, type StringOptions } from '../string/index.mjs';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
-import { TransformDecodeBuilder } from '../transform/index.mjs';
-import { type TTuple } from '../tuple/index.mjs';
-import { Union } from '../union/index.mjs';
-import { type TUnknown } from '../unknown/index.mjs';
-import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
-/** Json Type Builder with Static Resolution for TypeScript */
-export declare class JsonTypeBuilder {
-    /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type>;
-    /** `[Json]` Creates a Readonly property */
-    Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>;
-    /** `[Json]` Creates a Readonly property */
-    Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>;
-    /** `[Json]` Creates a Optional property */
-    Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>;
-    /** `[Json]` Creates a Readonly property */
-    Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>;
-    /** `[Json]` Creates a Optional property */
-    Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>;
-    /** `[Json]` Creates a Optional property */
-    Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>;
-    /** `[Json]` Creates a Optional property */
-    Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>;
-    /** `[Json]` Creates a Optional property */
-    Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>;
-    /** `[Json]` Creates an Any type */
-    Any(options?: SchemaOptions): TAny;
-    /** `[Json]` Creates an Array type */
-    Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
-    /** `[Json]` Creates a Boolean type */
-    Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
-    /** `[Json]` Creates a Composite object type */
-    Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
-    /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
-    /** `[Json]` Creates a Enum type */
-    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>;
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Json]` Creates a Conditional type */
-    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
-    /** `[Json]` Creates a Conditional type */
-    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
-    /** `[Json]` Creates a Conditional type */
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>;
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
-    /** `[Json]` Creates an Integer type */
-    Integer(options?: IntegerOptions): TInteger;
-    /** `[Json]` Creates an Intersect type */
-    Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
-    /** `[Json]` Creates a Literal type */
-    Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue>;
-    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type>;
-    /** `[Json]` Creates a Mapped object type */
-    Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
-    /** `[Json]` Creates a Mapped object type */
-    Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
-    /** `[Json]` Creates a Type Definition Module. */
-    Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
-    /** `[Json]` Creates a Never type */
-    Never(options?: SchemaOptions): TNever;
-    /** `[Json]` Creates a Not type */
-    Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T>;
-    /** `[Json]` Creates a Null type */
-    Null(options?: SchemaOptions): TNull;
-    /** `[Json]` Creates a Number type */
-    Number(options?: NumberOptions): TNumber;
-    /** `[Json]` Creates an Object type */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
-    /** `[Json]` Creates a Record type */
-    Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
-    /** `[Json]` Creates a Recursive type */
-    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type.*/
-    Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
-    /**
-     * @deprecated `[Json]` Creates a Ref type. This signature was deprecated in 0.34.0 where Ref requires callers to pass
-     * a `string` value for the reference (and not a schema).
-     *
-     * To adhere to the 0.34.0 signature, Ref implementations should be updated to the following.
-     *
-     * ```typescript
-     * // pre-0.34.0
-     *
-     * const T = Type.String({ $id: 'T' })
-     *
-     * const R = Type.Ref(T)
-     * ```
-     * should be changed to the following
-     *
-     * ```typescript
-     * // post-0.34.0
-     *
-     * const T = Type.String({ $id: 'T' })
-     *
-     * const R = Type.Unsafe<Static<typeof T>>(Type.Ref('T'))
-     * ```
-     * You can also create a generic function to replicate the pre-0.34.0 signature if required
-     *
-     * ```typescript
-     * const LegacyRef = <T extends TSchema>(schema: T) => Type.Unsafe<Static<T>>(Type.Ref(schema.$id!))
-     * ```
-     */
-    Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;
-    /** `[Json]` Constructs a type where all properties are required */
-    Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
-    /** `[Json]` Constructs a type where all properties are required */
-    Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
-    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest<Type extends TSchema>(type: Type): TRest<Type>;
-    /** `[Json]` Creates a String type */
-    String(options?: StringOptions): TString;
-    /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>;
-    /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>;
-    /** `[Json]` Creates a Transform type */
-    Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type>;
-    /** `[Json]` Creates a Tuple type */
-    Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
-    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type>;
-    /** `[Json]` Creates a Union type */
-    Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;
-    /** `[Json]` Creates an Unknown type */
-    Unknown(options?: SchemaOptions): TUnknown;
-    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
-}