@bonsae/nrg 0.6.0 → 0.6.2

package/types/server.d.ts

@@ -0,0 +1,2293 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { EventEmitter } from 'events';
+import { Http2ServerRequest } from 'http2';
+
+declare const TransformKind: unique symbol;
+declare const ReadonlyKind: unique symbol;
+declare const OptionalKind: unique symbol;
+declare const Hint: unique symbol;
+declare const Kind: unique symbol;
+export interface TAny extends TSchema {
+	[Kind]: "Any";
+	static: any;
+}
+export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
+	[Kind]: "MappedKey";
+	static: T[number];
+	keys: T;
+}
+export interface TMappedResult<T extends TProperties = TProperties> extends TSchema {
+	[Kind]: "MappedResult";
+	properties: T;
+	static: unknown;
+}
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+	[Kind]: "AsyncIterator";
+	static: AsyncIterableIterator<Static<T, this["params"]>>;
+	type: "AsyncIterator";
+	items: T;
+}
+export type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+export type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveReadonly<T> : TAddReadonly<T>;
+export type TReadonly<T extends TSchema> = T & {
+	[ReadonlyKind]: "Readonly";
+};
+export type TFromProperties<P extends TProperties, F extends boolean> = ({
+	[K2 in keyof P]: TReadonlyWithFlag<P[K2], F>;
+});
+export type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R["properties"], F>);
+export type TReadonlyFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+export type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>;
+export type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadonlyOptional<T> ? [
+	Readonly<Static<T, P>>?
+] : T extends TReadonly<T> ? [
+	Readonly<Static<T, P>>
+] : T extends TOptional<T> ? [
+	Static<T, P>?
+] : [
+	Static<T, P>
+];
+export type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? StaticParameters<R, P, [
+	...Acc,
+	...StaticParameter<L, P>
+]> : Acc);
+export type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Constructor";
+	static: StaticConstructor<T, U, this["params"]>;
+	type: "Constructor";
+	parameters: T;
+	returns: U;
+}
+export type TLiteralValue = boolean | number | string;
+export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+	[Kind]: "Literal";
+	static: T;
+	const: T;
+}
+export type TEnumRecord = Record<TEnumKey, TEnumValue>;
+export type TEnumValue = string | number;
+export type TEnumKey = string;
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+	[Kind]: "Union";
+	[Hint]: "Enum";
+	static: T[keyof T];
+	anyOf: TLiteral<T[keyof T]>[];
+}
+type StaticReturnType$1<U extends TSchema, P extends unknown[]> = Static<U, P>;
+type StaticParameter$1<T extends TSchema, P extends unknown[]> = T extends TReadonlyOptional<T> ? [
+	Readonly<Static<T, P>>?
+] : T extends TReadonly<T> ? [
+	Readonly<Static<T, P>>
+] : T extends TOptional<T> ? [
+	Static<T, P>?
+] : [
+	Static<T, P>
+];
+type StaticParameters$1<T extends TSchema[], P extends unknown[], Acc extends unknown[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? StaticParameters$1<R, P, [
+	...Acc,
+	...StaticParameter$1<L, P>
+]> : Acc);
+export type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: StaticParameters$1<T, P>) => StaticReturnType$1<U, P>>;
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Function";
+	static: StaticFunction<T, U, this["params"]>;
+	type: "Function";
+	parameters: T;
+	returns: U;
+}
+export interface TComputed<Target extends string = string, Parameters extends TSchema[] = [
+]> extends TSchema {
+	[Kind]: "Computed";
+	target: Target;
+	parameters: Parameters;
+}
+export interface TNever extends TSchema {
+	[Kind]: "Never";
+	static: never;
+	not: {};
+}
+export type TIntersectStatic<T extends TSchema[], P extends unknown[], Acc extends unknown = unknown> = T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TIntersectStatic<R, P, Acc & Static<L, P>> : Acc;
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+	unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+	[Kind]: "Intersect";
+	static: TIntersectStatic<T, this["params"]>;
+	type?: "object";
+	allOf: [
+		...T
+	];
+}
+export type TIsIntersectOptional<Types extends TSchema[]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TOptional<TSchema> ? TIsIntersectOptional<Right> : false : true);
+export type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+export type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromRest<Right, [
+	...Result,
+	TRemoveOptionalFromType<Type>
+]> : TRemoveOptionalFromRest<Right, [
+	...Result,
+	Left
+]> : Result);
+export type TResolveIntersect<Types extends TSchema[]> = (TIsIntersectOptional<Types> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> : TIntersect<TRemoveOptionalFromRest<Types>>);
+export type TIntersectEvaluated<Types extends TSchema[]> = (Types extends [
+	TSchema
+] ? Types[0] : Types extends [
+] ? TNever : TResolveIntersect<Types>);
+export type Intersect<Types extends TSchema[]> = (Types extends [
+	TSchema
+] ? Types[0] : Types extends [
+] ? TNever : TIntersect<Types>);
+declare function Intersect<Types extends TSchema[]>(types: [
+	...Types
+], options?: IntersectOptions): Intersect<Types>;
+export type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+	[K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+	[Kind]: "Union";
+	static: UnionStatic<T, this["params"]>;
+	anyOf: T;
+}
+export type TIsUnionOptional<Types extends TSchema[]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TOptional<TSchema> ? true : TIsUnionOptional<Right> : false);
+type TRemoveOptionalFromRest$1<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest$1<Right, [
+	...Result,
+	TRemoveOptionalFromType$1<S>
+]> : TRemoveOptionalFromRest$1<Right, [
+	...Result,
+	Left
+]> : Result);
+type TRemoveOptionalFromType$1<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType$1<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType$1<Type> : Type);
+export type TResolveUnion<Types extends TSchema[], Result extends TSchema[] = TRemoveOptionalFromRest$1<Types>, IsOptional extends boolean = TIsUnionOptional<Types>> = (IsOptional extends true ? TOptional<TUnion<Result>> : TUnion<Result>);
+export type TUnionEvaluated<Types extends TSchema[]> = (Types extends [
+	TSchema
+] ? Types[0] : Types extends [
+] ? TNever : TResolveUnion<Types>);
+export type Union<T extends TSchema[]> = (T extends [
+] ? TNever : T extends [
+	TSchema
+] ? T[0] : TUnion<T>);
+declare function Union<Types extends TSchema[]>(types: [
+	...Types
+], options?: SchemaOptions): Union<Types>;
+export interface TThis extends TSchema {
+	[Kind]: "This";
+	static: this["params"][0];
+	$ref: string;
+}
+export type RecursiveStatic<T extends TSchema> = Static<T, [
+	RecursiveStatic<T>
+]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+	[Hint]: "Recursive";
+	static: RecursiveStatic<T>;
+}
+export interface UnsafeOptions extends SchemaOptions {
+	[Kind]?: string;
+}
+export interface TUnsafe<T> extends TSchema {
+	[Kind]: string;
+	static: T;
+}
+export interface TRef<Ref extends string = string> extends TSchema {
+	[Kind]: "Ref";
+	static: unknown;
+	$ref: Ref;
+}
+export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>;
+export 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"];
+}
+export type StringFormatOption = "date-time" | "time" | "date" | "email" | "idn-email" | "hostname" | "idn-hostname" | "ipv4" | "ipv6" | "uri" | "uri-reference" | "iri" | "uuid" | "iri-reference" | "uri-template" | "json-pointer" | "relative-json-pointer" | "regex" | ({} & string);
+export type StringContentEncodingOption = "7bit" | "8bit" | "binary" | "quoted-printable" | "base64" | ({} & string);
+export interface StringOptions extends SchemaOptions {
+	/** The maximum string length */
+	maxLength?: number;
+	/** The minimum string length */
+	minLength?: number;
+	/** A regular expression pattern this string should match */
+	pattern?: string;
+	/** A format this string should match */
+	format?: StringFormatOption;
+	/** The content encoding for this string */
+	contentEncoding?: StringContentEncodingOption;
+	/** The content media type for this string */
+	contentMediaType?: string;
+}
+export interface TString extends TSchema, StringOptions {
+	[Kind]: "String";
+	static: string;
+	type: "string";
+}
+export interface TBoolean extends TSchema {
+	[Kind]: "Boolean";
+	static: boolean;
+	type: "boolean";
+}
+export interface NumberOptions extends SchemaOptions {
+	exclusiveMaximum?: number;
+	exclusiveMinimum?: number;
+	maximum?: number;
+	minimum?: number;
+	multipleOf?: number;
+}
+export interface TNumber extends TSchema, NumberOptions {
+	[Kind]: "Number";
+	static: number;
+	type: "number";
+}
+export interface IntegerOptions extends SchemaOptions {
+	exclusiveMaximum?: number;
+	exclusiveMinimum?: number;
+	maximum?: number;
+	minimum?: number;
+	multipleOf?: number;
+}
+export interface TInteger extends TSchema, IntegerOptions {
+	[Kind]: "Integer";
+	static: number;
+	type: "integer";
+}
+export interface BigIntOptions extends SchemaOptions {
+	exclusiveMaximum?: bigint;
+	exclusiveMinimum?: bigint;
+	maximum?: bigint;
+	minimum?: bigint;
+	multipleOf?: bigint;
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+	[Kind]: "BigInt";
+	static: bigint;
+	type: "bigint";
+}
+export type TFromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+export type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [
+	infer L extends TTemplateLiteralKind,
+	...infer R extends TTemplateLiteralKind[]
+] ? TFromTemplateLiteralKind<L> extends false ? false : TFromTemplateLiteralKinds<R> : true;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? TFromTemplateLiteralKinds<U> : false;
+export type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = [
+]> = R extends [
+	infer A extends string,
+	...infer B extends string[]
+] ? TStringReduceUnary<L, B, [
+	...Acc,
+	`${L}${A}`
+]> : Acc;
+export type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = [
+]> = L extends [
+	infer A extends string,
+	...infer B extends string[]
+] ? TStringReduceBinary<B, R, [
+	...Acc,
+	...TStringReduceUnary<A, R>
+]> : Acc;
+export type TStringReduceMany<T extends string[][]> = T extends [
+	infer L extends string[],
+	infer R extends string[],
+	...infer Rest extends string[][]
+] ? TStringReduceMany<[
+	TStringReduceBinary<L, R>,
+	...Rest
+]> : T;
+export type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [
+];
+export type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [
+	infer L extends TLiteral,
+	...infer R extends TLiteral[]
+] ? [
+	`${L["const"]}`,
+	...TFromTemplateLiteralUnionKinds<R>
+] : [
+];
+type TFromTemplateLiteralKinds$1<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = [
+]> = T extends [
+	infer L extends TTemplateLiteralKind,
+	...infer R extends TTemplateLiteralKind[]
+] ? (L extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds$1<[
+	...S,
+	...R
+], Acc> : L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds$1<R, [
+	...Acc,
+	[
+		S
+	]
+]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds$1<R, [
+	...Acc,
+	TFromTemplateLiteralUnionKinds<S>
+]> : L extends TBoolean ? TFromTemplateLiteralKinds$1<R, [
+	...Acc,
+	[
+		"true",
+		"false"
+	]
+]> : Acc) : Acc;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds$1<S> extends infer R extends string[][] ? TStringReduce<R> : [
+] : [
+]) : [
+];
+declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
+declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
+export type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [
+	TLiteral<Trim<L>>,
+	...FromUnionLiteral<R>
+] : T extends `${infer L}` ? [
+	TLiteral<Trim<L>>
+] : [
+];
+export type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>;
+export type FromTerminal<T extends string> = T extends "boolean" ? TBoolean : T extends "bigint" ? TBigInt : T extends "number" ? TNumber : T extends "string" ? TString : FromUnion<T>;
+export type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [
+	FromTerminal<L>,
+	...FromString<R>
+] : T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [
+	TLiteral<L>,
+	...FromString<`{${R1}}`>,
+	...FromString<R2>
+] : T extends `${infer L}$\{${infer R1}\}` ? [
+	TLiteral<L>,
+	...FromString<`{${R1}}`>
+] : T extends `${infer L}` ? [
+	TLiteral<L>
+] : [
+];
+export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+export type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
+	[K in keyof U]: TemplateLiteralStatic<Assert<[
+		U[K]
+	], TTemplateLiteralKind[]>, Acc>;
+}[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
+export type TemplateLiteralStatic<T extends TTemplateLiteralKind[], Acc extends string> = T extends [
+	infer L,
+	...infer R
+] ? `${TemplateLiteralStaticKind<L, Acc>}${TemplateLiteralStatic<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
+export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
+	[Kind]: "TemplateLiteral";
+	static: TemplateLiteralStatic<T, EmptyString>;
+	type: "string";
+	pattern: string;
+}
+export type TTemplateLiteralToUnionLiteralArray<T extends string[], Acc extends TLiteral[] = [
+]> = (T extends [
+	infer L extends string,
+	...infer R extends string[]
+] ? TTemplateLiteralToUnionLiteralArray<R, [
+	...Acc,
+	TLiteral<L>
+]> : Acc);
+export type TTemplateLiteralToUnion<T extends TTemplateLiteral, U extends string[] = UnionToTuple<Static<T>>> = TUnionEvaluated<TTemplateLiteralToUnionLiteralArray<U>>;
+export type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
+export type TFromUnion<Types extends TSchema[], Result extends string[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TFromUnion<Right, [
+	...Result,
+	...TIndexPropertyKeys<Left>
+]> : Result);
+export type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [
+	`${LiteralValue}`
+] : [
+]);
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? [
+	"[number]"
+] : Type extends TInteger ? [
+	"[number]"
+] : [
+]);
+type TFromProperties$1<Type extends TSchema, Properties extends TProperties> = ({
+	[K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>>;
+});
+type TFromMappedResult$1<Type extends TSchema, MappedResult extends TMappedResult> = (TFromProperties$1<Type, MappedResult["properties"]>);
+export type TIndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult$1<Type, MappedResult>> = (TMappedResult<Properties>);
+export type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TFromRest<Right, Key, [
+	...Result,
+	Assert<TIndexFromPropertyKey<Left, Key>, TSchema>
+]> : Result);
+export type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TNever ? TFromIntersectRest<Right, [
+	...Result
+]> : TFromIntersectRest<Right, [
+	...Result,
+	Left
+]> : Result);
+export type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
+export type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = [
+]> = Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TNever ? [
+] : TFromUnionRest<Right, [
+	Left,
+	...Result
+]> : Result;
+type TFromUnion$1<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
+export type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends "[number]" ? TUnionEvaluated<Types> : TNever);
+export type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends "[number]" ? Type : TNever);
+export type AssertPropertyKey<T> = Assert<T, string | number>;
+export type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion$1<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = [
+]> = (PropertyKeys extends [
+	infer Left extends PropertyKey,
+	...infer Right extends PropertyKey[]
+] ? TIndexFromPropertyKeys<Type, Right, [
+	...Result,
+	Assert<TIndexFromPropertyKey<Type, Left>, TSchema>
+]> : Result);
+export type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [
+	...PropertyKeys
+]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<"Index", [
+	Type,
+	Key
+]>);
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+export type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+	[_ in Key]: TIndex<Type, [
+		Key
+	]>;
+};
+export type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [
+	infer Left extends PropertyKey,
+	...infer Right extends PropertyKey[]
+] ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>> : Result);
+export type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<Type, MappedKey["keys"]>>;
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>> = (Ensure<TMappedResult<Properties>>);
+export interface TIterator<T extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Iterator";
+	static: IterableIterator<Static<T, this["params"]>>;
+	type: "Iterator";
+	items: T;
+}
+export interface TPromise<T extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Promise";
+	static: Promise<Static<T, this["params"]>>;
+	type: "Promise";
+	item: TSchema;
+}
+export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? S extends L ? true : TSetIncludes<R, S> : false);
+export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = [
+]> = T extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TSetIncludes<Acc, L> extends false ? TSetDistinct<R, [
+	...Acc,
+	L
+]> : TSetDistinct<R, [
+	...Acc
+]> : Acc;
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = [
+]> = (T extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [
+	...Acc,
+	L
+]> : TSetIntersect<R, S, [
+	...Acc
+]> : Acc);
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[]> = ([
+	...T,
+	...S
+]);
+export type TSetIntersectManyResolve<T extends PropertyKey[][], Acc extends PropertyKey[]> = (T extends [
+	infer L extends PropertyKey[],
+	...infer R extends PropertyKey[][]
+] ? TSetIntersectManyResolve<R, TSetIntersect<Acc, L>> : Acc);
+export type TSetIntersectMany<T extends PropertyKey[][]> = (T extends [
+	infer L extends PropertyKey[]
+] ? L : T extends [
+	infer L extends PropertyKey[],
+	...infer R extends PropertyKey[][]
+] ? TSetIntersectManyResolve<R, L> : [
+]);
+export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = [
+]> = (T extends [
+	infer L extends PropertyKey[],
+	...infer R extends PropertyKey[][]
+] ? TSetUnionMany<R, TSetUnion<Acc, L>> : Acc);
+type TFromMappedResult$2<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
+export type TMappedKeyToKnownMappedResultProperties<K extends PropertyKey> = {
+	[_ in K]: TLiteral<Assert<K, TLiteralValue>>;
+};
+export type TMappedKeyToUnknownMappedResultProperties<P extends PropertyKey[], Acc extends TProperties = {}> = (P extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TMappedKeyToUnknownMappedResultProperties<R, Acc & {
+	[_ in L]: TLiteral<Assert<L, TLiteralValue>>;
+}> : Acc);
+export type TMappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (TSetIncludes<P, K> extends true ? TMappedKeyToKnownMappedResultProperties<K> : TMappedKeyToUnknownMappedResultProperties<P>);
+export type TFromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = TMappedKeyToMappedResultProperties<K, P>> = (TFromMappedResult$2<K, R>);
+type TFromRest$1<K extends PropertyKey, T extends TSchema[], Acc extends TSchema[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromRest$1<K, R, [
+	...Acc,
+	FromSchemaType<K, L>
+]> : Acc);
+export type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{
+	[K2 in keyof T]: FromSchemaType<K, T[K2]>;
+}>> = R;
+declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
+export type FromSchemaType<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<FromSchemaType<K, S>> : T extends TOptional<infer S extends TSchema> ? TOptional<FromSchemaType<K, S>> : T extends TMappedResult<infer P extends TProperties> ? TFromMappedResult$2<K, P> : T extends TMappedKey<infer P extends PropertyKey[]> ? TFromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest$1<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest$1<K, S>, FromSchemaType<K, R>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<FromSchemaType<K, S>> : T extends TIterator<infer S extends TSchema> ? TIterator<FromSchemaType<K, S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest$1<K, S>> : T extends TEnum<infer S extends TEnumRecord> ? TEnum<S> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest$1<K, S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest$1<K, S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<K, S>> : T extends TArray<infer S extends TSchema> ? TArray<FromSchemaType<K, S>> : T extends TPromise<infer S extends TSchema> ? TPromise<FromSchemaType<K, S>> : T);
+declare function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T>;
+export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (K extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TMappedFunctionReturnType<R, T, Acc & {
+	[_ in L]: FromSchemaType<L, T>;
+}> : Acc);
+export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
+export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<TMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+export type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+export type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveOptional<T> : TAddOptional<T>;
+export type TOptional<T extends TSchema> = T & {
+	[OptionalKind]: "Optional";
+};
+type TFromProperties$2<P extends TProperties, F extends boolean> = ({
+	[K2 in keyof P]: TOptionalWithFlag<P[K2], F>;
+});
+type TFromMappedResult$3<R extends TMappedResult, F extends boolean> = (TFromProperties$2<R["properties"], F>);
+export type TOptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult$3<R, F>> = (TMappedResult<P>);
+export type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(TComputed<"Awaited", [
+	TComputed<Target, Parameters>
+]>)>;
+export type TFromRef<Ref extends string> = Ensure<TComputed<"Awaited", [
+	TRef<Ref>
+]>>;
+type TFromRest$2<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TFromRest$2<Right, [
+	...Result,
+	TAwaited<Left>
+]> : Result);
+export type TAwaited<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest$2<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest$2<Types>> : Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> : Type);
+type TFromRest$3<Types extends TSchema[], Result extends PropertyKey[][] = [
+]> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromRest$3<R, [
+	...Result,
+	TKeyOfPropertyKeys<L>
+]> : Result);
+type TFromIntersect$1<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest$3<Types>, PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>> = PropertyKeys;
+type TFromUnion$2<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest$3<Types>, PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>> = PropertyKeys;
+type TFromTuple$1<Types extends TSchema[], Indexer extends string = ZeroString, Acc extends PropertyKey[] = [
+]> = Types extends [
+	infer _ extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromTuple$1<R, TIncrement<Indexer>, [
+	...Acc,
+	Indexer
+]> : Acc;
+type TFromArray$1<_ extends TSchema> = ([
+	"[number]"
+]);
+type TFromProperties$3<Properties extends TProperties> = (UnionToTuple<keyof Properties>);
+export type TKeyOfPropertyKeys<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TKeyOfPropertyKeys<Type> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect$1<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion$2<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple$1<Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray$1<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties$3<Properties> : [
+]);
+type TFromComputed$1<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<"KeyOf", [
+	TComputed<Target, Parameters>
+]>>;
+type TFromRef$1<Ref extends string> = Ensure<TComputed<"KeyOf", [
+	TRef<Ref>
+]>>;
+/** `[Internal]` Used by KeyOfFromMappedResult */
+export type TKeyOfFromType<Type extends TSchema, PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>, PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>, Result = TUnionEvaluated<PropertyKeyTypes>> = Ensure<Result>;
+export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result extends TSchema[] = [
+]> = (PropertyKeys extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? L extends "[number]" ? TKeyOfPropertyKeysToRest<R, [
+	...Result,
+	TNumber
+]> : TKeyOfPropertyKeysToRest<R, [
+	...Result,
+	TLiteral<Assert<L, TLiteralValue>>
+]> : Result);
+export type TKeyOf<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed$1<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef$1<Ref> : Type extends TMappedResult ? TKeyOfFromMappedResult<Type> : TKeyOfFromType<Type>);
+type TFromProperties$4<Properties extends TProperties> = ({
+	[K2 in keyof Properties]: TKeyOfFromType<Properties[K2]>;
+});
+type TFromMappedResult$4<MappedResult extends TMappedResult> = (Evaluate<TFromProperties$4<MappedResult["properties"]>>);
+export type TKeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult$4<MappedResult>> = (Ensure<TMappedResult<Properties>>);
+type TFromProperties$5<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+	[K2 in keyof Properties]: TOmit<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult$5<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties$5<MappedResult["properties"], PropertyKeys>>);
+export type TOmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult$5<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+type TFromIntersect$2<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromIntersect$2<R, PropertyKeys, [
+	...Result,
+	TOmit<L, PropertyKeys>
+]> : Result);
+type TFromUnion$3<T extends TSchema[], K extends PropertyKey[], Result extends TSchema[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromUnion$3<R, K, [
+	...Result,
+	TOmit<L, K>
+]> : Result);
+type TFromProperties$6<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKey extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Omit<Properties, UnionKey>>);
+export type TFromObject<_Type extends TObject, PropertyKeys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties$6<Properties, PropertyKeys>, Result extends TSchema = TObject<MappedProperties>> = Result;
+export type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = [
+]> = (PropertyKeys extends [
+	infer Key extends PropertyKey,
+	...infer Rest extends PropertyKey[]
+] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [
+	...Result,
+	TLiteral<Key>
+]> : TUnionFromPropertyKeys<Rest, [
+	...Result
+]> : TUnion<Result>);
+export type TOmitResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TOmitResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect$2<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion$3<Types, PropertyKeys>> : Properties extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, PropertyKeys, Properties> : TObject<{}>);
+export type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+export type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TOmit<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TOmitFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TOmitFromMappedKey<Type, Key> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	true,
+	true
+] ? TComputed<"Omit", [
+	Type,
+	TResolveTypeKey<Key>
+]> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	false,
+	true
+] ? TComputed<"Omit", [
+	Type,
+	TResolveTypeKey<Key>
+]> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	true,
+	false
+] ? TComputed<"Omit", [
+	Type,
+	TResolveTypeKey<Key>
+]> : TOmitResolve<Type, TResolvePropertyKeys<Key>>);
+export type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+	[_ in Key]: TOmit<Type, [
+		Key
+	]>;
+};
+export type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [
+	infer LK extends PropertyKey,
+	...infer RK extends PropertyKey[]
+] ? TFromPropertyKeys<Type, RK, Result & TFromPropertyKey<Type, LK>> : Result);
+type TFromMappedKey$1<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey["keys"]>);
+export type TOmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey$1<Type, MappedKey>> = (TMappedResult<Properties>);
+type TFromProperties$7<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+	[K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult$6<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties$7<MappedResult["properties"], PropertyKeys>>);
+export type TPickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult$6<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+type TFromIntersect$3<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = [
+]> = Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromIntersect$3<R, PropertyKeys, [
+	...Result,
+	TPick<L, PropertyKeys>
+]> : Result;
+type TFromUnion$4<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = [
+]> = Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromUnion$4<R, PropertyKeys, [
+	...Result,
+	TPick<L, PropertyKeys>
+]> : Result;
+type TFromProperties$8<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKeys extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Pick<Properties, UnionKeys & keyof Properties>>);
+type TFromObject$1<_Type extends TObject, Keys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties$8<Properties, Keys>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TUnionFromPropertyKeys$1<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = [
+]> = (PropertyKeys extends [
+	infer Key extends PropertyKey,
+	...infer Rest extends PropertyKey[]
+] ? Key extends TLiteralValue ? TUnionFromPropertyKeys$1<Rest, [
+	...Result,
+	TLiteral<Key>
+]> : TUnionFromPropertyKeys$1<Rest, [
+	...Result
+]> : TUnion<Result>);
+export type TPickResolve<Type extends TProperties, PropertyKeys extends PropertyKey[]> = (Type extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect$3<Types, PropertyKeys>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion$4<Types, PropertyKeys>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject$1<TObject, PropertyKeys, Properties> : TObject<{}>);
+type TResolvePropertyKeys$1<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey$1<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys$1<Key> : Key;
+export type TPick<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TPickFromMappedResult<Type, TResolvePropertyKeys$1<Key>> : Key extends TMappedKey ? TPickFromMappedKey<Type, Key> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	true,
+	true
+] ? TComputed<"Pick", [
+	Type,
+	TResolveTypeKey$1<Key>
+]> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	false,
+	true
+] ? TComputed<"Pick", [
+	Type,
+	TResolveTypeKey$1<Key>
+]> : [
+	IsTypeRef,
+	IsKeyRef
+] extends [
+	true,
+	false
+] ? TComputed<"Pick", [
+	Type,
+	TResolveTypeKey$1<Key>
+]> : TPickResolve<Type, TResolvePropertyKeys$1<Key>>);
+type TFromPropertyKey$1<Type extends TSchema, Key extends PropertyKey> = {
+	[_ in Key]: TPick<Type, [
+		Key
+	]>;
+};
+type TFromPropertyKeys$1<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [
+	infer LeftKey extends PropertyKey,
+	...infer RightKeys extends PropertyKey[]
+] ? TFromPropertyKeys$1<Type, RightKeys, Result & TFromPropertyKey$1<Type, LeftKey>> : Result);
+type TFromMappedKey$2<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys$1<Type, MappedKey["keys"]>);
+export type TPickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey$2<Type, MappedKey>> = (TMappedResult<Properties>);
+export interface TNull extends TSchema {
+	[Kind]: "Null";
+	static: null;
+	type: "null";
+}
+export interface TSymbol extends TSchema, SchemaOptions {
+	[Kind]: "Symbol";
+	static: symbol;
+	type: "symbol";
+}
+export interface TUndefined extends TSchema {
+	[Kind]: "Undefined";
+	static: undefined;
+	type: "undefined";
+}
+type TFromComputed$2<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<"Partial", [
+	TComputed<Target, Parameters>
+]>>;
+type TFromRef$2<Ref extends string> = Ensure<TComputed<"Partial", [
+	TRef<Ref>
+]>>;
+type TFromProperties$9<Properties extends TProperties> = Evaluate<{
+	[K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<Properties[K]>;
+}>;
+type TFromObject$2<_Type extends TObject, Properties extends TProperties, MappedProperties extends TProperties = TFromProperties$9<Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRest$4<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromRest$4<R, [
+	...Result,
+	TPartial<L>
+]> : Result);
+export type TPartial<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed$2<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef$2<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest$4<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest$4<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject$2<TObject, Properties> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
+type TFromProperties$10<P extends TProperties> = ({
+	[K2 in keyof P]: TPartial<P[K2]>;
+});
+type TFromMappedResult$7<R extends TMappedResult> = (Evaluate<TFromProperties$10<R["properties"]>>);
+export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult$7<R>> = (Ensure<TMappedResult<P>>);
+export interface RegExpOptions extends SchemaOptions {
+	/** The maximum length of the string */
+	maxLength?: number;
+	/** The minimum length of the string */
+	minLength?: number;
+}
+export interface TRegExp extends TSchema {
+	[Kind]: "RegExp";
+	static: `${string}`;
+	type: "RegExp";
+	source: string;
+	flags: string;
+}
+export type TFromTemplateLiteralKeyInfinite<Key extends TTemplateLiteral, Type extends TSchema> = Ensure<TRecord<Key, Type>>;
+export type TFromTemplateLiteralKeyFinite<Key extends TTemplateLiteral, Type extends TSchema, I extends string = Static<Key>> = (Ensure<TObject<Evaluate<{
+	[_ in I]: Type;
+}>>>);
+export type TFromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema> = TIsTemplateLiteralFinite<Key> extends false ? TFromTemplateLiteralKeyInfinite<Key, Type> : TFromTemplateLiteralKeyFinite<Key, Type>;
+export type TFromEnumKey<Key extends Record<string, string | number>, Type extends TSchema> = Ensure<TObject<{
+	[_ in Key[keyof Key]]: Type;
+}>>;
+export type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSchema> = {
+	[_ in Key["const"]]: Type;
+};
+export type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = {
+	[_ in Key["const"]]: Type;
+};
+export type TFromUnionKeyVariants<Keys extends TSchema[], Type extends TSchema, Result extends TProperties = {}> = Keys extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? (Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyVariants<Types, Type>> : Left extends TLiteral<string> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralString<Left, Type>> : Left extends TLiteral<number> ? TFromUnionKeyVariants<Right, Type, Result & TFromUnionKeyLiteralNumber<Left, Type>> : {}) : Result;
+export type TFromUnionKey<Key extends TSchema[], Type extends TSchema, Properties extends TProperties = TFromUnionKeyVariants<Key, Type>> = (Ensure<TObject<Evaluate<Properties>>>);
+export type TFromLiteralKey<Key extends TLiteralValue, Type extends TSchema> = (Ensure<TObject<{
+	[_ in Assert<Key, PropertyKey>]: Type;
+}>>);
+export type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (Ensure<TRecord<TRegExp, Type>>);
+export type TFromStringKey<_Key extends TString, Type extends TSchema> = (Ensure<TRecord<TString, Type>>);
+export type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (Ensure<TRecord<TAny, Type>>);
+export type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (Ensure<TRecord<TNever, Type>>);
+export type TFromBooleanKey<_Key extends TBoolean, Type extends TSchema> = (Ensure<TObject<{
+	true: Type;
+	false: Type;
+}>>);
+export type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+export type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+export type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
+	[_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
+}>);
+export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Record";
+	static: RecordStatic<Key, Type, this["params"]>;
+	type: "object";
+	patternProperties: {
+		[pattern: string]: Type;
+	};
+	additionalProperties: TAdditionalProperties;
+}
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TBoolean ? TFromBooleanKey<Key, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
+type TFromComputed$3<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<"Required", [
+	TComputed<Target, Parameters>
+]>>;
+type TFromRef$3<Ref extends string> = Ensure<TComputed<"Required", [
+	TRef<Ref>
+]>>;
+type TFromProperties$11<Properties extends TProperties> = Evaluate<{
+	[K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonly<S> : Properties[K] extends (TOptional<infer S>) ? S : Properties[K];
+}>;
+type TFromObject$3<_Type extends TObject, Properties extends TProperties, MappedProperties extends TProperties = TFromProperties$11<Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRest$5<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromRest$5<R, [
+	...Result,
+	TRequired<L>
+]> : Result);
+export type TRequired<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed$3<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef$3<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest$5<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest$5<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject$3<TObject, Properties> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
+type TFromProperties$12<P extends TProperties> = ({
+	[K2 in keyof P]: TRequired<P[K2]>;
+});
+type TFromMappedResult$8<R extends TMappedResult> = (Evaluate<TFromProperties$12<R["properties"]>>);
+export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult$8<R>> = (Ensure<TMappedResult<P>>);
+declare class TransformDecodeBuilder<T extends TSchema> {
+	private readonly schema;
+	constructor(schema: T);
+	Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(decode: D): TransformEncodeBuilder<T, D>;
+}
+declare class TransformEncodeBuilder<T extends TSchema, D extends TransformFunction> {
+	private readonly schema;
+	private readonly decode;
+	constructor(schema: T, decode: D);
+	private EncodeTransform;
+	private EncodeSchema;
+	Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
+}
+export type TransformStatic<T extends TSchema, P extends unknown[] = [
+]> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
+export type TransformFunction<T = any, U = any> = (value: T) => U;
+export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
+	Decode: TransformFunction<StaticDecode<I>, O>;
+	Encode: TransformFunction<O, StaticDecode<I>>;
+}
+export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
+	static: TransformStatic<I, this["params"]>;
+	[TransformKind]: TransformOptions<I, O>;
+	[key: string]: any;
+}
+export type TDereferenceParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? Left extends TRef<infer Key extends string> ? TDereferenceParameters<ModuleProperties, Right, [
+	...Result,
+	TDereference<ModuleProperties, Key>
+]> : TDereferenceParameters<ModuleProperties, Right, [
+	...Result,
+	TFromType<ModuleProperties, Left>
+]> : Result);
+export type TDereference<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDereference<ModuleProperties, Ref2> : TFromType<ModuleProperties, ModuleProperties[Ref]> : TNever)> = Result;
+export type TFromAwaited<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema
+] ? TAwaited<T0> : never);
+export type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema,
+	infer T1 extends TSchema
+] ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema ? Result : never : never);
+export type TFromKeyOf<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema
+] ? TKeyOf<T0> : never);
+export type TFromPartial<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema
+] ? TPartial<T0> : never);
+export type TFromOmit<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema,
+	infer T1 extends TSchema
+] ? TOmit<T0, T1> : never);
+export type TFromPick<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema,
+	infer T1 extends TSchema
+] ? TPick<T0, T1> : never);
+export type TFromRequired<Parameters extends TSchema[]> = (Parameters extends [
+	infer T0 extends TSchema
+] ? TRequired<T0> : never);
+type TFromComputed$4<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[], Dereferenced extends TSchema[] = TDereferenceParameters<ModuleProperties, Parameters>> = (Target extends "Awaited" ? TFromAwaited<Dereferenced> : Target extends "Index" ? TFromIndex<Dereferenced> : Target extends "KeyOf" ? TFromKeyOf<Dereferenced> : Target extends "Partial" ? TFromPartial<Dereferenced> : Target extends "Omit" ? TFromOmit<Dereferenced> : Target extends "Pick" ? TFromPick<Dereferenced> : Target extends "Required" ? TFromRequired<Dereferenced> : TNever);
+type TFromArray$2<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<TArray<TFromType<ModuleProperties, Type>>>);
+export type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
+export type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (TConstructor<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>);
+export type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<Ensure<TFunction<TFromTypes<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>>;
+type TFromIntersect$4<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TIntersectEvaluated<TFromTypes<ModuleProperties, Types>>>);
+export type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
+type TFromObject$4<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{
+	[Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>;
+}>>>;
+export type TFromRecord<ModuleProperties extends TProperties, Key extends TSchema, Value extends TSchema, Result extends TSchema = TRecordOrObject<Key, TFromType<ModuleProperties, Value>>> = Result;
+export type TFromTransform<ModuleProperties extends TProperties, Input extends TSchema, Output extends unknown, Result extends TSchema = Input extends TRef<infer Key extends string> ? TTransform<TDereference<ModuleProperties, Key>, Output> : TTransform<Input, Output>> = Result;
+type TFromTuple$2<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TTuple<TFromTypes<ModuleProperties, Types>>>);
+type TFromUnion$5<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TUnionEvaluated<TFromTypes<ModuleProperties, Types>>>);
+export type TFromTypes<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TFromTypes<ModuleProperties, Right, [
+	...Result,
+	TFromType<ModuleProperties, Left>
+]> : Result);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TFromType<ModuleProperties, Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TFromType<ModuleProperties, Type>> : Type extends TTransform<infer Input extends TSchema, infer Output extends unknown> ? TFromTransform<ModuleProperties, Input, Output> : Type extends TArray<infer Type extends TSchema> ? TFromArray$2<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed$4<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect$4<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject$4<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<ModuleProperties, Key, Value> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple$2<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion$5<ModuleProperties, Types> : Type);
+export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
+export type TComputeModuleProperties<ModuleProperties extends TProperties> = Evaluate<{
+	[Key in keyof ModuleProperties]: TComputeType<ModuleProperties, Key>;
+}>;
+export type TInferArray<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<Array<TInfer<ModuleProperties, Type>>>);
+export type TInferAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<AsyncIterableIterator<TInfer<ModuleProperties, Type>>>);
+export type TInferConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = Ensure<new (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, InstanceType>>;
+export type TInferFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<(...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, ReturnType>>;
+export type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<IterableIterator<TInfer<ModuleProperties, Type>>>);
+export type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TInferIntersect<ModuleProperties, Right, Result & TInfer<ModuleProperties, Left>> : Result);
+export type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = {
+	[Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
+}[keyof Properties];
+export type ReadonlyPropertyKeys<Source extends TProperties> = {
+	[Key in keyof Source]: Source[Key] extends TReadonly<TSchema> ? (Source[Key] extends TOptional<Source[Key]> ? never : Key) : never;
+}[keyof Source];
+export type OptionalPropertyKeys<Source extends TProperties> = {
+	[Key in keyof Source]: Source[Key] extends TOptional<TSchema> ? (Source[Key] extends TReadonly<Source[Key]> ? never : Key) : never;
+}[keyof Source];
+export type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>;
+export type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<Source, ReadonlyOptionalPropertyKeys<Properties>>>> & Readonly<Pick<Source, ReadonlyPropertyKeys<Properties>>> & Partial<Pick<Source, OptionalPropertyKeys<Properties>>> & Required<Pick<Source, RequiredPropertyKeys<Properties>>>)>;
+export type InferProperties<ModuleProperties extends TProperties, Properties extends TProperties> = InferPropertiesWithModifiers<Properties, {
+	[K in keyof Properties]: TInfer<ModuleProperties, Properties[K]>;
+}>;
+export type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (InferProperties<ModuleProperties, Properties>);
+export type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = [
+]> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TInferTuple<ModuleProperties, R, [
+	...Result,
+	TInfer<ModuleProperties, L>
+]> : Result);
+export type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Ensure<{
+	[_ in InferredKey]: InferedType;
+}>;
+export type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
+export type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
+export type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Type extends TRecursive<infer Schema extends TSchema> ? TInfer<ModuleProperties, Schema> : Static<Type>);
+/** Inference Path for Imports. This type is used to compute TImport `static` */
+export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
+export interface TImport<ModuleProperties extends TProperties = {}, Key extends keyof ModuleProperties = keyof ModuleProperties> extends TSchema {
+	[Kind]: "Import";
+	static: TInferFromModuleKey<ModuleProperties, Key>;
+	$defs: ModuleProperties;
+	$ref: Key;
+}
+declare class TModule<ModuleProperties extends TProperties, ComputedModuleProperties extends TProperties = TComputeModuleProperties<ModuleProperties>> {
+	private readonly $defs;
+	constructor($defs: ModuleProperties);
+	/** `[Json]` Imports a Type by Key. */
+	Import<Key extends keyof ComputedModuleProperties>(key: Key, options?: SchemaOptions): TImport<ComputedModuleProperties, Key>;
+	private WithIdentifiers;
+}
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
+	[Kind]: "Not";
+	static: T extends TNot<infer U> ? Static<U> : unknown;
+	not: T;
+}
+export type TDecodeImport<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TDecodeType<ModuleProperties[Key]> extends infer Type extends TSchema ? Type extends TRef<infer Ref extends string> ? TDecodeImport<ModuleProperties, Ref> : Type : TNever : TNever);
+export type TDecodeProperties<Properties extends TProperties> = {
+	[Key in keyof Properties]: TDecodeType<Properties[Key]>;
+};
+export type TDecodeTypes<Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TDecodeTypes<Right, [
+	...Result,
+	TDecodeType<Left>
+]> : Result);
+export type TDecodeType<Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TDecodeType<Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TDecodeType<Type>> : Type extends TTransform<infer _Input extends TSchema, infer Output> ? TUnsafe<Output> : Type extends TArray<infer Type extends TSchema> ? TArray<TDecodeType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TDecodeType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TDecodeTypes<Parameters>, TDecodeType<InstanceType>> : Type extends TEnum<infer Values> ? TEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TDecodeTypes<Parameters>, TDecodeType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TDecodeTypes<Types>> : Type extends TImport<infer ModuleProperties extends TProperties, infer Key> ? TDecodeImport<ModuleProperties, Key> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TDecodeType<Type>> : Type extends TNot<infer Type extends TSchema> ? TNot<TDecodeType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<Evaluate<TDecodeProperties<Properties>>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TDecodeType<Type>> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecord<Key, TDecodeType<Value>> : Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TDecodeType<Type>> : Type extends TRef<infer Ref extends string> ? TRef<Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TDecodeTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TDecodeTypes<Types>> : Type);
+export type StaticDecodeIsAny<Type> = boolean extends (Type extends TSchema ? true : false) ? true : false;
+/** Creates an decoded static type from a TypeBox type */
+export type StaticDecode<Type extends TSchema, Params extends unknown[] = [
+], Result = StaticDecodeIsAny<Type> extends true ? unknown : Static<TDecodeType<Type>, Params>> = Result;
+/** Creates a static type from a TypeBox type */
+export type Static<Type extends TSchema, Params extends unknown[] = [
+], Result = (Type & {
+	params: Params;
+})["static"]> = Result;
+type ReadonlyOptionalPropertyKeys$1<T extends TProperties> = {
+	[K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys$1<T extends TProperties> = {
+	[K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys$1<T extends TProperties> = {
+	[K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys$1<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys$1<T> | ReadonlyPropertyKeys$1<T> | OptionalPropertyKeys$1<T>>;
+export type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys$1<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys$1<T>>> & Partial<Pick<R, OptionalPropertyKeys$1<T>>> & Required<Pick<R, RequiredPropertyKeys$1<T>>>)>;
+export type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+	[K in keyof T]: Static<T[K], P>;
+}>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
+export type TIsLiteralString<Type extends string> = ([
+	Type
+] extends [
+	string
+] ? [
+	string
+] extends [
+	Type
+] ? false : true : false);
+export type IsRequiredArrayLiteralConstant<RequiredTuple extends string[]> = (RequiredTuple extends [
+	infer Left extends string,
+	...infer _ extends string[]
+] ? TIsLiteralString<Left> : false);
+export type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
+	[Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
+}, RequiredUnion extends string = Extract<keyof RequiredProperties, string>, RequiredTuple extends string[] = UnionToTuple<RequiredUnion>, Result extends string[] | undefined = (IsRequiredArrayLiteralConstant<RequiredTuple> extends true ? RequiredTuple : string[] | undefined)> = Result;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+	/** Additional property constraints for this object */
+	additionalProperties?: TAdditionalProperties;
+	/** The minimum number of properties allowed on this object */
+	minProperties?: number;
+	/** The maximum number of properties allowed on this object */
+	maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+	[Kind]: "Object";
+	static: ObjectStatic<T, this["params"]>;
+	additionalProperties?: TAdditionalProperties;
+	type: "object";
+	properties: T;
+	required: TRequiredArray<T>;
+}
+export type TupleToUnion<T extends any[]> = {
+	[K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, Acc extends unknown[] = [
+], R = UnionLast<U>> = [
+	U
+] extends [
+	never
+] ? Acc : UnionToTuple<Exclude<U, R>, [
+	Extract<U, R>,
+	...Acc
+]>;
+export type Trim<T> = T extends `${" "}${infer U}` ? Trim<U> : T extends `${infer U}${" "}` ? Trim<U> : T;
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+	[K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type EmptyString = "";
+export type ZeroString = "0";
+export type IncrementBase = {
+	m: "9";
+	t: "01";
+	"0": "1";
+	"1": "2";
+	"2": "3";
+	"3": "4";
+	"4": "5";
+	"5": "6";
+	"6": "7";
+	"7": "8";
+	"8": "9";
+	"9": "0";
+};
+export type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
+export type IncrementStep<T extends string> = T extends IncrementBase["m"] ? IncrementBase["t"] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase["m"] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
+export type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
+export type TIncrement<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [
+];
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export interface ArrayOptions extends SchemaOptions {
+	/** The minimum number of items in this array */
+	minItems?: number;
+	/** The maximum number of items in this array */
+	maxItems?: number;
+	/** Should this schema contain unique items */
+	uniqueItems?: boolean;
+	/** A schema for which some elements should match */
+	contains?: TSchema;
+	/** A minimum number of contains schema matches */
+	minContains?: number;
+	/** A maximum number of contains schema matches */
+	maxContains?: number;
+}
+export type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+	[Kind]: "Array";
+	static: ArrayStatic<T, this["params"]>;
+	type: "array";
+	items: T;
+}
+export interface DateOptions extends SchemaOptions {
+	/** The exclusive maximum timestamp value */
+	exclusiveMaximumTimestamp?: number;
+	/** The exclusive minimum timestamp value */
+	exclusiveMinimumTimestamp?: number;
+	/** The maximum timestamp value */
+	maximumTimestamp?: number;
+	/** The minimum timestamp value */
+	minimumTimestamp?: number;
+	/** The multiple of timestamp value */
+	multipleOfTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+	[Kind]: "Date";
+	static: Date;
+	type: "date";
+}
+export interface Uint8ArrayOptions extends SchemaOptions {
+	maxByteLength?: number;
+	minByteLength?: number;
+}
+export interface TUint8Array extends TSchema, Uint8ArrayOptions {
+	[Kind]: "Uint8Array";
+	static: Uint8Array;
+	type: "uint8array";
+}
+export interface TUnknown extends TSchema {
+	[Kind]: "Unknown";
+	static: unknown;
+}
+export interface TVoid extends TSchema {
+	[Kind]: "Void";
+	static: void;
+	type: "void";
+}
+export interface SchemaOptions {
+	$schema?: string;
+	/** Id for this schema */
+	$id?: string;
+	/** Title of this schema */
+	title?: string;
+	/** Description of this schema */
+	description?: string;
+	/** Default value for this schema */
+	default?: any;
+	/** Example values matching this schema */
+	examples?: any;
+	/** Optional annotation for readOnly */
+	readOnly?: boolean;
+	/** Optional annotation for writeOnly */
+	writeOnly?: boolean;
+	[prop: string]: any;
+}
+export interface TKind {
+	[Kind]: string;
+}
+export interface TSchema extends TKind, SchemaOptions {
+	[ReadonlyKind]?: string;
+	[OptionalKind]?: string;
+	[Hint]?: string;
+	params: unknown[];
+	static: unknown;
+}
+export interface TArgument<Index extends number = number> extends TSchema {
+	[Kind]: "Argument";
+	static: unknown;
+	index: Index;
+}
+export type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TCompositeKeys<R, [
+	...Acc,
+	...TKeyOfPropertyKeys<L>
+]> : TSetDistinct<Acc>);
+export type TFilterNever<T extends TSchema[], Acc extends TSchema[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? L extends TNever ? TFilterNever<R, [
+	...Acc
+]> : TFilterNever<R, [
+	...Acc,
+	L
+]> : Acc);
+export type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = [
+]> = (T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TCompositeProperty<R, K, [
+	...Acc,
+	...TIndexFromPropertyKeys<L, [
+		K
+	]>
+]> : TFilterNever<Acc>);
+export type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}> = (K extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TCompositeProperties<T, R, Acc & {
+	[_ in L]: TIntersectEvaluated<TCompositeProperty<T, L>>;
+}> : Acc);
+export type TCompositeEvaluate<T extends TSchema[], K extends PropertyKey[] = TCompositeKeys<T>, P extends TProperties = Evaluate<TCompositeProperties<T, K>>, R extends TSchema = TObject<P>> = R;
+export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>;
+type TFromArray$3<T extends readonly unknown[]> = T extends readonly [
+	infer L extends unknown,
+	...infer R extends unknown[]
+] ? [
+	FromValue<L, false>,
+	...TFromArray$3<R>
+] : T;
+type TFromProperties$13<T extends Record<PropertyKey, unknown>> = {
+	-readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
+};
+export type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+export type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<TFromArray$3<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? TConditionalReadonly<TObject<Evaluate<TFromProperties$13<T>>>, Root> : T extends Function ? TConditionalReadonly<TFunction<[
+], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
+declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
+export type TConst<T> = FromValue<T, true>;
+export type TConstructorParameters<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _InstanceType extends TSchema> ? TTuple<Parameters> : TNever);
+export type TExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExclude<TTemplateLiteralToUnion<L>, R>);
+export type TExcludeRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+	[K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? never : L[K];
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExclude<L extends TSchema, R extends TSchema> = (L extends TUnion<infer S> ? TExcludeRest<S, R> : L extends R ? TNever : L);
+type TFromProperties$14<K extends TProperties, T extends TSchema> = ({
+	[K2 in keyof K]: TExclude<K[K2], T>;
+});
+type TFromMappedResult$9<R extends TMappedResult, T extends TSchema> = (TFromProperties$14<R["properties"], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult$9<R, T>> = (TMappedResult<P>);
+type TFromProperties$15<P extends TProperties, Right extends TSchema, False extends TSchema, True extends TSchema> = ({
+	[K2 in keyof P]: TExtends<P[K2], Right, False, True>;
+});
+type TFromMappedResult$10<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties$15<Left["properties"], Right, True, False>);
+export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult$10<Left, Right, True, False>> = (TMappedResult<P>);
+export type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [
+	infer X extends TSchema,
+	infer Y extends TSchema
+] ? TUnion<[
+	X,
+	Y
+]> : O : never);
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = TExtendsResolve<L, R, T, F>;
+type TFromPropertyKey$2<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+	[_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+type TFromPropertyKeys$2<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema, Acc extends TProperties = {}> = (K extends [
+	infer LK extends PropertyKey,
+	...infer RK extends PropertyKey[]
+] ? TFromPropertyKeys$2<RK, U, L, R, Acc & TFromPropertyKey$2<LK, U, L, R>> : Acc);
+type TFromMappedKey$3<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromPropertyKeys$2<K["keys"], U, L, R>);
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey$3<T, U, L, R>> = (TMappedResult<P>);
+export type TExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExtract<TTemplateLiteralToUnion<L>, R>);
+export type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+	[K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExtract<L extends TSchema, U extends TSchema> = (L extends TUnion<infer S> ? TExtractRest<S, U> : L extends U ? L : TNever);
+type TFromProperties$16<P extends TProperties, T extends TSchema> = ({
+	[K2 in keyof P]: TExtract<P[K2], T>;
+});
+type TFromMappedResult$11<R extends TMappedResult, T extends TSchema> = (TFromProperties$16<R["properties"], T>);
+export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult$11<R, T>> = (TMappedResult<P>);
+export type TInstanceType<Type extends TSchema, Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever> = Result;
+type TFromConstructor$1<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes$1<Args, Parameters>, TFromType$1<Args, InstanceType>>> = Result;
+type TFromFunction$1<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes$1<Args, Parameters>, TFromType$1<Args, ReturnType>>> = Result;
+type TFromIntersect$5<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes$1<Args, Types>>> = Result;
+type TFromUnion$6<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes$1<Args, Types>>> = Result;
+type TFromTuple$3<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes$1<Args, Types>>> = Result;
+type TFromArray$4<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType$1<Args, Type>>> = Result;
+type TFromAsyncIterator$1<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType$1<Args, Type>>> = Result;
+type TFromIterator$1<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType$1<Args, Type>>> = Result;
+export type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType$1<Args, Type>>> = Result;
+type TFromObject$5<Args extends TSchema[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties$17<Args, Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRecord$1<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType$1<Args, Key>, MappedValue extends TSchema = TFromType$1<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+export type TFromArgument<Args extends TSchema[], Index extends number, Result extends TSchema = Index extends keyof Args[Index] ? Args[Index] : TUnknown> = Result;
+type TFromProperty$1<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType$1<Args, Type>, Result extends TSchema = ([
+	IsReadonly,
+	IsOptional
+] extends [
+	true,
+	true
+] ? TReadonlyOptional<Mapped> : [
+	IsReadonly,
+	IsOptional
+] extends [
+	true,
+	false
+] ? TReadonly<Mapped> : [
+	IsReadonly,
+	IsOptional
+] extends [
+	false,
+	true
+] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties$17<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+	[Key in keyof Properties]: TFromProperty$1<Args, Properties[Key]>;
+}> = Result;
+type TFromTypes$1<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = [
+]> = (Types extends [
+	infer Left extends TSchema,
+	...infer Right extends TSchema[]
+] ? TFromTypes$1<Args, Right, [
+	...Result,
+	TFromType$1<Args, Left>
+]> : Result);
+type TFromType$1<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor$1<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction$1<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect$5<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion$6<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple$3<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray$4<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator$1<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator$1<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject$5<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord$1<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType$1<Args, Type>> = Result;
+export type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
+	[_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
+};
+export type TMappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode, Acc extends TProperties = {}> = (K extends [
+	infer L extends PropertyKey,
+	...infer R extends PropertyKey[]
+] ? TMappedIntrinsicPropertyKeys<R, M, Acc & TMappedIntrinsicPropertyKey<L, M>> : Acc);
+export type TMappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (TMappedIntrinsicPropertyKeys<K["keys"], M>);
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export type IntrinsicMode = "Uppercase" | "Lowercase" | "Capitalize" | "Uncapitalize";
+type TFromTemplateLiteral$1<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [
+	infer L extends TTemplateLiteralKind,
+	...infer R extends TTemplateLiteralKind[]
+] ? [
+	TIntrinsic<L, M>,
+	...TFromTemplateLiteral$1<R, M>
+] : T : T;
+export type TFromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends "Uncapitalize" ? Uncapitalize<T> : M extends "Capitalize" ? Capitalize<T> : M extends "Uppercase" ? Uppercase<T> : M extends "Lowercase" ? Lowercase<T> : string : T);
+type TFromRest$6<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = [
+]> = T extends [
+	infer L extends TSchema,
+	...infer R extends TSchema[]
+] ? TFromRest$6<R, M, [
+	...Acc,
+	TIntrinsic<L, M>
+]> : Acc;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral$1<S, M>> : T extends TUnion<infer S> ? TUnion<TFromRest$6<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
+export type TCapitalize<T extends TSchema> = TIntrinsic<T, "Capitalize">;
+export type TLowercase<T extends TSchema> = TIntrinsic<T, "Lowercase">;
+export type TUncapitalize<T extends TSchema> = TIntrinsic<T, "Uncapitalize">;
+export type TUppercase<T extends TSchema> = TIntrinsic<T, "Uppercase">;
+export type TParameters<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema> ? TTuple<Parameters> : TNever);
+export type TRestResolve<T extends TSchema> = T extends TIntersect<infer S extends TSchema[]> ? S : T extends TUnion<infer S extends TSchema[]> ? S : T extends TTuple<infer S extends TSchema[]> ? S : [
+];
+export type TRest<T extends TSchema> = TRestResolve<T>;
+export type TReturnType<Type extends TSchema, Result extends TSchema = Type extends TFunction<infer _Parameters extends TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever> = Result;
+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>;
+}
+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;
+}
+declare const TYPED_INPUT_TYPES: readonly [
+	"msg",
+	"flow",
+	"global",
+	"str",
+	"num",
+	"bool",
+	"json",
+	"bin",
+	"re",
+	"jsonata",
+	"date",
+	"env",
+	"node",
+	"cred"
+];
+export interface TNodeRef<T = any> extends TSchema {
+	[Kind]: "NodeRef";
+	static: T;
+	type: "string";
+	"x-nrg-node-type"?: string;
+}
+export type ResolveNodeRefs<T> = T extends TNodeRef<infer N> ? N : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolveNodeRefs<Item>[] : T extends object ? {
+	[K in keyof T]: ResolveNodeRefs<T[K]>;
+} : T;
+export type Infer<T extends TSchema> = ResolveNodeRefs<Static<T>>;
+export type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
+export interface TTypedInput extends TSchema {
+	[Kind]: "TypedInput";
+	static: {
+		value: string | number | boolean | null;
+		type: TypedInputType;
+	};
+}
+export interface NrgFormOptions {
+	icon?: string;
+	typedInputTypes?: string[];
+	editorLanguage?: string;
+	toggle?: boolean;
+}
+export interface Schema<T extends TProperties = TProperties> extends TObject<T> {
+	$id: string;
+}
+export interface NodeRedRuntimeSettings {
+	userDir?: string;
+	nodesDir?: string | string[];
+	flowFile?: string;
+	flowFilePretty?: boolean;
+	credentialSecret?: string | false;
+	requireHttps?: boolean;
+	https?: {
+		key: string;
+		cert: string;
+	} | (() => Promise<{
+		key: string;
+		cert: string;
+	}> | {
+		key: string;
+		cert: string;
+	});
+	httpsRefreshInterval?: number;
+	httpAdminRoot?: string;
+	httpNodeRoot?: string;
+	httpNodeCors?: {
+		origin: string;
+		methods: string;
+	};
+	httpStatic?: string | {
+		path: string;
+		root: string;
+	}[];
+	httpStaticRoot?: string;
+	httpAdminMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+	httpNodeMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+	httpServerOptions?: Record<string, unknown>;
+	adminAuth?: {
+		type?: "credentials" | "strategy";
+		users?: {
+			username: string;
+			password: string;
+			permissions?: string | string[];
+		}[];
+		default?: {
+			permissions?: string | string[];
+		};
+		tokens?: (token: string) => Promise<{
+			user: string;
+			permissions: string | string[];
+		} | null>;
+		tokenHeader: "string";
+		sessionExpiryTime?: number;
+		[key: string]: unknown;
+	};
+	httpNodeAuth?: {
+		user?: string;
+		pass?: string;
+	};
+	httpStaticAuth?: {
+		user?: string;
+		pass?: string;
+	};
+	lang?: "en-US" | "de" | "es-ES" | "fr" | "ko" | "pt-BR" | "ru" | "ja" | "zh-CN" | "zh-TW";
+	diagnostics?: {
+		enabled?: boolean;
+		ui?: boolean;
+	};
+	runtimeState?: {
+		enabled?: boolean;
+		ui?: boolean;
+	};
+	disableEditor?: boolean;
+	editorTheme?: {
+		page?: {
+			title?: string;
+			favicon?: string;
+			css?: string | string[];
+			scripts?: string | string[];
+		};
+		header?: {
+			title?: string;
+			image?: string;
+			url?: string;
+		};
+		deployButton?: {
+			type?: "simple" | "default";
+			label?: string;
+			icon?: string;
+		};
+		menu?: {
+			"menu-item-import-library"?: boolean;
+			"menu-item-export-library"?: boolean;
+			"menu-item-keyboard-shortcuts"?: boolean;
+			"menu-item-help"?: {
+				label?: string;
+				url?: string;
+			};
+			[menuItem: string]: boolean | {
+				label?: string;
+				url?: string;
+			} | undefined;
+		};
+		userMenu?: boolean;
+		login?: {
+			image?: string;
+		};
+		logout?: {
+			redirect?: string;
+		};
+		palette?: {
+			catalogues?: string[];
+			categories?: string[];
+			theme?: {
+				category: string;
+				type: string;
+				color: string;
+			}[];
+		};
+		projects?: {
+			enabled?: boolean;
+			workflow?: {
+				mode: "manual" | "auto";
+			};
+		};
+		codeEditor?: {
+			lib?: "monaco" | "ace";
+			options?: Record<string, unknown>;
+		};
+		mermaid?: {
+			theme?: string;
+		};
+		tours?: boolean;
+		theme?: string;
+		[key: string]: unknown;
+	};
+	contextStorage?: {
+		default?: {
+			module?: "memory" | "localfilesystem" | object;
+			config?: Record<string, unknown>;
+		};
+		[store: string]: {
+			module?: "memory" | "localfilesystem" | object;
+			config?: Record<string, unknown>;
+		} | undefined;
+	};
+	exportGlobalContextKeys?: boolean;
+	logging?: {
+		console?: {
+			level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "off";
+			metrics?: boolean;
+			audit?: boolean;
+		};
+	};
+	fileWorkingDirectory?: string;
+	functionExternalModules?: boolean;
+	functionGlobalContext?: Record<string, unknown>;
+	nodeMessageBufferMaxLength?: number;
+	functionTimeout?: number;
+	externalModules?: {
+		autoInstall?: boolean;
+		autoInstallRetry?: number;
+		palette?: {
+			allowInstall?: boolean;
+			allowUpdate?: boolean;
+			allowUpload?: boolean;
+			allowList?: string[];
+			denyList?: string[];
+			allowUpdateList?: string[];
+			denyUpdateList?: string[];
+		};
+		modules?: {
+			allowInstall?: boolean;
+			allowList?: string[];
+			denyList?: string[];
+		};
+	};
+	execMaxBufferSize?: number;
+	debugMaxLength?: number;
+	debugUseColors?: boolean;
+	httpRequestTimeout?: number;
+	mqttReconnectTime?: number;
+	serialReconnectTime?: number;
+	socketReconnectTime?: number;
+	socketTimeout?: number;
+	tcpMsgQueueSize?: number;
+	inboundWebSocketTimeout?: number;
+	tlsConfigDisableLocalFiles?: boolean;
+	webSocketNodeVerifyClient?: (info: {
+		origin: string;
+		req: Http2ServerRequest;
+		secure: boolean;
+	}) => boolean;
+	apiMaxLength?: string;
+	[key: string]: unknown;
+}
+export interface NodeRedLog {
+	info(msg: any): void;
+	warn(msg: any): void;
+	error(msg: any, error?: any): void;
+	debug(msg: any): void;
+	trace(msg: any): void;
+	log(msg: {
+		level: number;
+		msg: string;
+	}): void;
+	metric(): boolean;
+	audit(msg: Record<string, any>, req?: any): void;
+	addHandler(handler: (msg: any) => void): void;
+	removeHandler(handler: (msg: any) => void): void;
+	FATAL: 10;
+	ERROR: 20;
+	WARN: 30;
+	INFO: 40;
+	DEBUG: 50;
+	TRACE: 60;
+	AUDIT: 98;
+	METRIC: 99;
+}
+export interface NodeRedNode {
+	id: string;
+	type: string;
+	name?: string;
+	z?: string;
+	x: number;
+	y: number;
+	g?: string;
+	wires: string[][];
+	credentials: any;
+	_node?: any;
+	send(msg: any): void;
+	receive(msg: any): void;
+	status(status: string | {
+		fill?: string;
+		shape?: string;
+		text?: string;
+	}): void;
+	updateWires(wires: string[][]): void;
+	on(event: string, callback: (...args: any[]) => void): void;
+	log(msg: any): void;
+	warn(msg: any): void;
+	error(msg: any, errorMsg?: any): void;
+	context(): NodeRedNodeContext;
+	[key: string]: any;
+}
+export interface NodeRedNodeContext extends NodeRedContextStore {
+	flow: NodeRedContextStore;
+	global: NodeRedContextStore;
+}
+export interface NodeRedNodes {
+	registerType(type: string, constructor: any, opts?: any): void;
+	getNode(id: string): (NodeRedNode & {
+		_node?: any;
+	}) | undefined;
+	createNode(node: NodeRedNode, config: Record<string, any>): void;
+	getCredentials(id: string): Record<string, any> | undefined;
+	eachNode(callback: (node: any) => void): void;
+	getType(type: string): any;
+	getNodeInfo(type: string): any;
+	getNodeList(filter?: any): any[];
+	getModuleInfo(module: string): any;
+	installModule(module: string, version?: string): Promise<any>;
+	uninstallModule(module: string): Promise<any>;
+	enableNode(id: string): Promise<any>;
+	disableNode(id: string): Promise<any>;
+}
+export interface NodeRedUtil {
+	evaluateNodeProperty(value: any, type: string, node: any, msg: Record<string, any> | undefined, callback: (err: Error | null, result: any) => void): void;
+	generateId(): string;
+	cloneMessage<T = any>(msg: T): T;
+	ensureString(o: any): string;
+	ensureBuffer(o: any): Buffer;
+	compareObjects(obj1: any, obj2: any): boolean;
+	getMessageProperty(msg: any, expr: string): any;
+	setMessageProperty(msg: any, prop: string, value: any, createMissing?: boolean): void;
+	getObjectProperty(obj: any, expr: string): any;
+	setObjectProperty(obj: any, prop: string, value: any, createMissing?: boolean): void;
+	normalisePropertyExpression(str: string, msg?: any, toString?: boolean): string[];
+	normaliseNodeTypeName(name: string): string;
+	prepareJSONataExpression(value: string, node: any): any;
+	evaluateJSONataExpression(expr: any, msg: any, callback: (err: Error | null, result: any) => void): void;
+	parseContextStore(key: string): {
+		store: string | undefined;
+		key: string;
+	};
+	getSetting(node: any, name: string, flow?: any): any;
+	encodeObject(obj: any): any;
+}
+export interface NodeRedHooks {
+	add(hookId: string, callback: (event: any) => void | Promise<void>): void;
+	remove(hookId: string): void;
+	trigger(hookId: string, event: any, callback?: (err?: Error) => void): void | Promise<void>;
+	has(hookId: string): boolean;
+	clear(): void;
+}
+export type NodeRedRequestHandler = (req: any, res: any, next?: () => void) => void;
+export interface NodeRedExpressApp {
+	get(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	post(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	put(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	delete(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	patch(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	options(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	head(path: string, ...handlers: NodeRedRequestHandler[]): void;
+	use(path: string | NodeRedRequestHandler, ...handlers: NodeRedRequestHandler[]): void;
+	all(path: string, ...handlers: NodeRedRequestHandler[]): void;
+}
+export interface RED {
+	/** Internationalization function */
+	_(key: string, substitutions?: Record<string, string>): string;
+	/** Logging API */
+	log: NodeRedLog;
+	/** Node registry and management */
+	nodes: NodeRedNodes;
+	/** Utility functions */
+	util: NodeRedUtil;
+	/** Hook system for message lifecycle and module events */
+	hooks: NodeRedHooks;
+	/** Runtime event emitter */
+	events: EventEmitter;
+	/** Express app for admin HTTP endpoints */
+	httpAdmin: NodeRedExpressApp;
+	/** Express app for node HTTP endpoints */
+	httpNode: NodeRedExpressApp;
+	/** Runtime settings (user-provided settings plus node-registered settings) */
+	settings: NodeRedRuntimeSettings & Record<string, any>;
+	/** Node-RED version string */
+	version(): string;
+}
+export interface NodeRedContextStore {
+	get(key: string, store: string | undefined, callback: (err: Error | null, value: any) => void): void;
+	set(key: string, value: any, store: string | undefined, callback: (err: Error | null) => void): void;
+	keys(store: string | undefined, callback: (err: Error | null, keys: string[]) => void): void;
+}
+declare const NodeConfigSchema: TObject<{
+	id: TString;
+	type: TString;
+	name: TString;
+	z: TOptional<TString>;
+}>;
+declare const ConfigNodeConfigSchema: TObject<{
+	_users: TArray<TString>;
+	id: TString;
+	type: TString;
+	name: TString;
+	z: TOptional<TString>;
+}>;
+declare const IONodeConfigSchema: TObject<{
+	wires: TArray<TArray<TString>>;
+	x: TNumber;
+	y: TNumber;
+	g: TOptional<TString>;
+	id: TString;
+	type: TString;
+	name: TString;
+	z: TOptional<TString>;
+}>;
+declare function NodeRef<T extends new (...args: any[]) => any>(nodeClass: T, options?: SchemaOptions): TNodeRef<InstanceType<T>>;
+declare function TypedInput(options?: SchemaOptions): TTypedInput;
+export declare const SchemaType: JavaScriptTypeBuilder & {
+	NodeRef: typeof NodeRef;
+	TypedInput: typeof TypedInput;
+};
+export declare function defineSchema<T extends TProperties>(properties: T, options: ObjectOptions & {
+	$id: string;
+}): Schema<T>;
+export type NodeContextScope = "node" | "flow" | "global";
+export interface NodeContextStore {
+	get<T = any>(key: string): Promise<T>;
+	set<T = any>(key: string, value: T): Promise<void>;
+	keys(): Promise<string[]>;
+}
+export type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;
+export type NodeCredentials<TCredentials = any> = TCredentials;
+type TypedInput$1 = Static<TTypedInput>;
+export type IONodeContextScope = NodeContextScope;
+export type IONodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof IONodeConfigSchema> & {
+	validateInput?: boolean;
+	validateOutput?: boolean;
+};
+export type IONodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
+export type IONodeStatus = {
+	fill?: "red" | "green";
+	shape?: "dot" | "string";
+	text?: string;
+} | string;
+export type IONodeContext = {
+	(scope: IONodeContextScope, store?: string): NodeContextStore;
+	node: NodeContextStore;
+	flow: NodeContextStore;
+	global: NodeContextStore;
+};
+export type HexColor = `#${string}`;
+export type ConfigNodeContextScope = Exclude<NodeContextScope, "flow">;
+export type ConfigNodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof ConfigNodeConfigSchema>;
+export type ConfigNodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
+export type ConfigNodeContext = {
+	(scope: ConfigNodeContextScope, store?: string): NodeContextStore;
+	node: NodeContextStore;
+	global: NodeContextStore;
+};
+export declare abstract class IONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> {
+	static readonly align?: "left" | "right";
+	static readonly color: HexColor;
+	static readonly labelStyle?: "node_label" | "node_label_italic" | string;
+	static readonly paletteLabel?: string;
+	static readonly inputs?: number;
+	static readonly outputs?: number;
+	static readonly inputLabels?: string | string[];
+	static readonly outputLabels?: string | string[];
+	static readonly inputSchema?: Schema;
+	static readonly outputsSchema?: Schema | Schema[];
+	static readonly validateInput: boolean;
+	static readonly validateOutput: boolean;
+	private _send;
+	readonly config: IONodeConfig<TConfig>;
+	protected readonly context: IONodeContext;
+	constructor(RED: RED, node: any, config: IONodeConfig<TConfig>, credentials: IONodeCredentials<TCredentials>);
+	abstract input(msg: TInput): void | Promise<void>;
+	send(msg: TOutput): void;
+	status(status: IONodeStatus): void;
+	updateWires(wires: string[][]): void;
+	receive(msg: TInput): void;
+	get x(): number;
+	get y(): number;
+	get g(): string | undefined;
+	get wires(): string[][];
+	get credentials(): IONodeCredentials<TCredentials> | undefined;
+}
+export declare abstract class ConfigNode<TConfig = any, TCredentials = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> {
+	static readonly category: string;
+	readonly config: ConfigNodeConfig<TConfig>;
+	protected readonly context: ConfigNodeContext;
+	constructor(RED: RED, node: any, config: ConfigNodeConfig<TConfig>, credentials: ConfigNodeCredentials<TCredentials>);
+	get userIds(): string[];
+	get users(): Node$1[];
+	getUser<T extends Node$1 = Node$1>(index: number): T | undefined;
+	get credentials(): ConfigNodeCredentials<TCredentials> | undefined;
+}
+export type InferOr<T, Fallback> = T extends TSchema ? Static<T> : Fallback;
+export type InferOutputs<T> = T extends readonly TSchema[] ? {
+	[K in keyof T]: T[K] extends TSchema ? Static<T[K]> : never;
+} : T extends TSchema ? Static<T> : any;
+export type BoundIONode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined, TIn extends TSchema | undefined, TOut extends TSchema | readonly TSchema[] | undefined> = IONode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TIn, any>, InferOutputs<TOut>, InferOr<TS, any>>;
+export type BoundConfigNode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined> = ConfigNode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TS, any>>;
+export interface IONodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined> {
+	type: string;
+	category?: string;
+	color?: HexColor;
+	inputs?: 0 | 1;
+	outputs?: number;
+	paletteLabel?: string;
+	inputLabels?: string | string[];
+	outputLabels?: string | string[];
+	align?: "left" | "right";
+	labelStyle?: string;
+	configSchema?: TConfigSchema;
+	credentialsSchema?: TCredsSchema;
+	settingsSchema?: TSettingsSchema;
+	inputSchema?: TInputSchema;
+	outputsSchema?: TOutputsSchema;
+	validateInput?: boolean;
+	validateOutput?: boolean;
+	registered?(RED: RED): void | Promise<void>;
+	created?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): void | Promise<void>;
+	closed?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>, removed?: boolean): void | Promise<void>;
+	input?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>, msg: InferOr<TInputSchema, any>): void | Promise<void>;
+}
+export interface ConfigNodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined> {
+	type: string;
+	configSchema?: TConfigSchema;
+	credentialsSchema?: TCredsSchema;
+	settingsSchema?: TSettingsSchema;
+	registered?(RED: RED): void | Promise<void>;
+	created?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>): void | Promise<void>;
+	closed?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>, removed?: boolean): void | Promise<void>;
+}
+export interface NodeClassBase {
+	readonly type: string;
+	readonly category: string;
+	new (...args: any[]): any;
+}
+declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any> {
+	static readonly type: string;
+	static readonly category: "config" | string;
+	static readonly configSchema?: Schema;
+	static readonly credentialsSchema?: Schema;
+	static readonly settingsSchema?: Schema;
+	private static _cachedSettings;
+	static registered?(RED: RED): void | Promise<void>;
+	static validateSettings(RED: RED): void;
+	protected readonly RED: RED;
+	protected readonly node: NodeRedNode;
+	protected readonly context: ConfigNodeContext | IONodeContext;
+	readonly config: NodeConfig<TConfig>;
+	private readonly timers;
+	private readonly intervals;
+	constructor(RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>);
+	i18n(key: string, substitutions?: Record<string, string>): string;
+	setTimeout(fn: () => void, ms: number): NodeJS.Timeout;
+	setInterval(fn: () => void, ms: number): NodeJS.Timeout;
+	clearTimeout(timer: NodeJS.Timeout): void;
+	clearInterval(interval: NodeJS.Timeout): void;
+	created?(): void | Promise<void>;
+	closed?(removed?: boolean): void | Promise<void>;
+	resolveTypedInput<T = any>(typedInput: TypedInput$1, msg?: Record<string, any>): Promise<T>;
+	on(event: string, callback: (...args: any[]) => void): void;
+	log(msg: any): void;
+	warn(message: string): void;
+	error(message: string, msg?: any): void;
+	get id(): string;
+	get name(): string | undefined;
+	get z(): string | undefined;
+	get credentials(): NodeCredentials<TCredentials> | undefined;
+	get settings(): TSettings;
+}
+export declare function defineIONode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | undefined = undefined>(def: IONodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): NodeClassBase;
+export declare function defineConfigNode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined>(def: ConfigNodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema>): NodeClassBase;
+export declare class NrgError extends Error {
+	constructor(message: string);
+}
+export type AnyNodeClass = (abstract new (...args: any[]) => Node$1) & Partial<typeof Node$1>;
+/**
+ * Registers a custom node with Node-RED.
+ *
+ * @param RED - The Node-RED runtime API object
+ * @param NodeClass - A node class extending Node, IONode, or ConfigNode
+ * @throws If NodeClass does not extend Node
+ * @throws If NodeClass.type is not defined
+ */
+export declare function registerType(RED: RED, NodeClass: AnyNodeClass): Promise<void>;
+export type RegistrationFunction = ((RED: RED) => Promise<void>) & {
+	nodes: AnyNodeClass[];
+};
+/**
+ * Registers multiple node classes with Node-RED.
+ *
+ * Returns a Node-RED package function that Node-RED calls with the RED
+ * runtime object when loading the package.
+ *
+ * @param nodes - Array of node classes to register
+ */
+export declare function registerTypes(nodes: AnyNodeClass[]): RegistrationFunction;
+export interface ModuleDefinition {
+	nodes: AnyNodeClass[];
+}
+export declare function defineModule(definition: ModuleDefinition): ModuleDefinition;
+
+export {
+	Node$1 as Node,
+};
+
+export {};