@huanglangjian/specs 0.3.1 → 0.5.0

package/dist/index.d.mts

@@ -1,4 +1,929 @@
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/primitive.d.ts
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/if.d.ts
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import type {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Returns a boolean for whether the given `boolean` is not `false`.
+*/
+type IsNotFalse<T extends boolean> = [T] extends [false] ? false : true;
+/**
+Returns a boolean for whether the given type is primitive value or primitive type.
+
+@example
+```
+type A = IsPrimitive<'string'>;
+//=> true
+
+type B = IsPrimitive<string>;
+//=> true
+
+type C = IsPrimitive<Object>;
+//=> false
+```
+*/
+type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
+*/
+type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/numeric.d.ts
+type _Numeric = number | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/tagged-tag@1.0.0/node_modules/tagged-tag/index.d.ts
+declare const tag: unique symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/tagged.d.ts
+// eslint-disable-next-line type-fest/require-exported-types
+type TagContainer<Token> = {
+  readonly [tag]: Token;
+};
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
+/**
+Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
+
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+
+@category Type
+*/
+type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+/**
+Get the untagged portion of a tagged type created with `Tagged`.
+
+Why is this necessary?
+
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1,
+};
+
+// Without UnwrapTagged, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass a non-Tagged type to UnwrapTagged will raise a type error.
+// @ts-expect-error
+type WontWork = UnwrapTagged<string>;
+```
+
+@category Type
+*/
+type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> = RemoveAllTags<TaggedType>;
+type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never }[keyof T[typeof tag]] : T;
+/**
+Note: The `Opaque` type is deprecated in favor of `Tagged`.
+
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
+
+The generic type parameters can be anything.
+
+Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
+
+Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne(): NewThingOne {
+	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+	return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+// @ts-expect-error
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+	id: Opaque<number, Person>;
+	name: string;
+};
+```
+
+@category Type
+@deprecated Use {@link Tagged} instead
+*/
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-literal.d.ts
+/**
+Returns a boolean for whether the given type `T` is the specified `LiteralType`.
+
+@link https://stackoverflow.com/a/52806744/10292952
+
+@example
+```
+type A = LiteralCheck<1, number>;
+//=> true
+
+type B = LiteralCheck<number, number>;
+//=> false
+
+type C = LiteralCheck<1, string>;
+//=> false
+```
+*/
+type LiteralCheck<T, LiteralType extends Primitive> = (IsNever<T> extends false // Must be wider than `never`
+? [T] extends [LiteralType & infer U] // Remove any branding
+? [U] extends [LiteralType] // Must be narrower than `LiteralType`
+? [LiteralType] extends [U] // Cannot be wider than `LiteralType`
+? false : true : false : false : false);
+/**
+Returns a boolean for whether the given type `T` is one of the specified literal types in `LiteralUnionType`.
+
+@example
+```
+type A = LiteralChecks<1, Numeric>;
+//=> true
+
+type B = LiteralChecks<1n, Numeric>;
+//=> true
+
+type C = LiteralChecks<bigint, Numeric>;
+//=> false
+```
+*/
+type LiteralChecks<T, LiteralUnionType> = (// Conditional type to force union distribution.
+// If `T` is none of the literal types in the union `LiteralUnionType`, then `LiteralCheck<T, LiteralType>` will evaluate to `false` for the whole union.
+// If `T` is one of the literal types in the union, it will evaluate to `boolean` (i.e. `true | false`)
+IsNotFalse<LiteralUnionType extends Primitive ? LiteralCheck<T, LiteralUnionType> : never>);
+/**
+Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed string manipulation functions
+	- constraining strings to be a string literal
+	- type utilities, such as when constructing parsers and ASTs
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+
+// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
+function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
+	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
+}
+
+const output = capitalize('hello, world!');
+//=> 'Hello, world!'
+```
+
+@example
+```
+// String types with infinite set of possible values return `false`.
+
+import type {IsStringLiteral} from 'type-fest';
+
+type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
+//=> false
+
+// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
+
+type Length<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends false
+		? number // return `number` for infinite string types
+		: S extends `${string}${infer Tail}`
+			? Length<Tail, [...Counter, never]>
+			: Counter['length'];
+
+type L1 = Length<Lowercase<string>>;
+//=> number
+
+type L2 = Length<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsStringLiteral<S> = IfNotAnyOrNever<S, _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>, false, false>;
+type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+// and since `{}` extends index signatures, the result becomes `false`.
+S extends string ? {} extends Record<S, never> ? false : true : false;
+/**
+Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsNumericLiteral, IsStringLiteral} from 'type-fest';
+
+// https://github.com/inocan-group/inferred-types/blob/master/modules/types/src/boolean-logic/operators/EndsWith.ts
+type EndsWith<TValue, TEndsWith extends string> =
+	TValue extends string
+		? IsStringLiteral<TEndsWith> extends true
+			? IsStringLiteral<TValue> extends true
+				? TValue extends `${string}${TEndsWith}`
+					? true
+					: false
+				: boolean
+			: boolean
+		: TValue extends number
+			? IsNumericLiteral<TValue> extends true
+				? EndsWith<`${TValue}`, TEndsWith>
+				: false
+			: false;
+
+function endsWith<Input extends string | number, End extends string>(input: Input, end: End) {
+	return `${input}`.endsWith(end) as EndsWith<Input, End>;
+}
+
+endsWith('abc', 'c');
+//=> true
+
+endsWith(123_456, '456');
+//=> true
+
+const end = '123' as string;
+
+endsWith('abc123', end);
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNumericLiteral<T> = LiteralChecks<T, _Numeric>;
+/**
+Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsBooleanLiteral} from 'type-fest';
+
+const id = 123;
+
+type GetId<AsString extends boolean> =
+	IsBooleanLiteral<AsString> extends true
+		? AsString extends true
+			? `${typeof id}`
+			: typeof id
+		: number | string;
+
+function getId<AsString extends boolean = false>(options?: {asString: AsString}) {
+	return (options?.asString ? `${id}` : id) as GetId<AsString>;
+}
+
+const numberId = getId();
+//=> 123
+
+const stringId = getId({asString: true});
+//=> '123'
+
+declare const runtimeBoolean: boolean;
+const eitherId = getId({asString: runtimeBoolean});
+//=> string | number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsBooleanLiteral<T> = LiteralCheck<T, boolean>;
+/**
+Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsSymbolLiteral} from 'type-fest';
+
+type Get<Object_ extends Record<symbol, number>, Key extends keyof Object_> =
+	IsSymbolLiteral<Key> extends true
+		? Object_[Key]
+		: number;
+
+function get<Object_ extends Record<symbol, number>, Key extends keyof Object_>(o: Object_, key: Key) {
+	return o[key] as Get<Object_, Key>;
+}
+
+const symbolLiteral = Symbol('literal');
+let symbolValue = Symbol('value1');
+symbolValue = Symbol('value2');
+
+get({[symbolLiteral]: 1} as const, symbolLiteral);
+//=> 1
+
+get({[symbolValue]: 1} as const, symbolValue);
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsSymbolLiteral<T> = LiteralCheck<T, symbol>;
+/** Helper type for `IsLiteral`. */
+type IsLiteralUnion<T> = IsStringLiteral<T> | IsNumericLiteral<T> | IsBooleanLiteral<T> | IsSymbolLiteral<T>;
+/**
+Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed functions when given literal arguments
+	- type utilities, such as when constructing parsers and ASTs
+
+@example
+```
+import type {IsLiteral} from 'type-fest';
+
+type A = IsLiteral<1>;
+//=> true
+
+type B = IsLiteral<number>;
+//=> false
+
+type C = IsLiteral<1n>;
+//=> true
+
+type D = IsLiteral<bigint>;
+//=> false
+
+type E = IsLiteral<'type-fest'>;
+//=> true
+
+type F = IsLiteral<string>;
+//=> false
+
+type G = IsLiteral<`on${string}`>;
+//=> false
+
+declare const symbolLiteral: unique symbol;
+type H = IsLiteral<typeof symbolLiteral>;
+//=> true
+
+type I = IsLiteral<symbol>;
+//=> false
+
+type J = IsLiteral<true>;
+//=> true
+
+type K = IsLiteral<boolean>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsLiteral<T> = IsPrimitive<T> extends true ? IsNotFalse<IsLiteralUnion<T>> : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-null.d.ts
+/**
+Returns a boolean for whether the given type is `null`.
+
+@example
+```
+import type {IsNull} from 'type-fest';
+
+type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
+
+type Example1 = NonNullFallback<null, string>;
+//=> string
+
+type Example2 = NonNullFallback<number, string>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNull<T> = [T] extends [null] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-unknown.d.ts
+/**
+Returns a boolean for whether the given type is `unknown`.
+
+@link https://github.com/dsherret/conditional-type-checks/pull/16
+
+Useful in type utilities, such as when dealing with unknown data from API calls.
+
+@example
+```
+import type {IsUnknown} from 'type-fest';
+
+type A = IsUnknown<unknown>;
+//=> true
+
+type B = IsUnknown<any>;
+//=> false
+
+type C = IsUnknown<never>;
+//=> false
+
+type D = IsUnknown<unknown[]>;
+//=> false
+
+type E = IsUnknown<object>;
+//=> false
+
+type F = IsUnknown<string>;
+//=> false
+```
+
+@category Utilities
+*/
+type IsUnknown<T> = (unknown extends T // `T` can be `unknown` or `any`
+? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
+? true : false : false);
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/keys.d.ts
+/**
+Utility type to retrieve only literal keys from type.
+*/
+type LiteralKeyOf<T> = keyof { [K in keyof T as IsLiteral<K> extends true ? K : never]-?: never };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/simplify.d.ts
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -33,31 +958,671 @@ interface SomeInterface {
 	bar?: string;
 	baz: number | undefined;
 }
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-declare function fn(object: Record<string, unknown>): void;
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-// @ts-expect-error
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see {@link SimplifyDeep}
-@category Object
-*/
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/pick-index-signature.d.ts
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see {@link OmitIndexSignature}
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+};
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+//=> {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
+@category Object
+*/
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key] }>>>;
+/**
+Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
+
+Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
+
+Use-case: For collapsing unions created using {@link LiteralUnion}.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
+//=> string
+
+type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
+//=> number
+
+type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
+//=> `on${string}`
+
+type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
+//=> 'click' | 'change' | `on${string}`
+
+type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
+//=> string | null | undefined
+```
+*/
+type CollapseLiterals<T> = {} extends T ? T : T extends infer U & {} ? U : T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.7.0/node_modules/type-fest/source/partial-on-undefined-deep.d.ts
+/**
+@see {@link PartialOnUndefinedDeep}
+*/
+type PartialOnUndefinedDeepOptions = {
+  /**
+  Whether to affect the individual elements of arrays and tuples.
+  	@default false
+  */
+  readonly recurseIntoArrays?: boolean;
+};
+type DefaultPartialOnUndefinedDeepOptions = {
+  recurseIntoArrays: false;
+};
+/**
+Create a deep version of another type where all keys accepting `undefined` type are set to optional.
+
+This utility type is recursive, transforming at any level deep. By default, it does not affect arrays and tuples items unless you explicitly pass `{recurseIntoArrays: true}` as the second type argument.
+
+Use-cases:
+- Make all properties of a type that can be undefined optional to not have to specify keys with undefined value.
+
+@example
+```
+import type {PartialOnUndefinedDeep} from 'type-fest';
+
+type Settings = {
+	optionA: string;
+	optionB: number | undefined;
+	subOption: {
+		subOptionA: boolean;
+		subOptionB: boolean | undefined;
+	};
+};
+
+const testSettings: PartialOnUndefinedDeep<Settings> = {
+	optionA: 'foo',
+	// 👉 optionB is now optional and can be omitted
+	subOption: {
+		subOptionA: true,
+		// 👉 subOptionB is now optional as well and can be omitted
+	},
+};
+```
+
+@category Object
+*/
+type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOptions = {}> = _PartialOnUndefinedDeep<T, ApplyDefaultOptions<PartialOnUndefinedDeepOptions, DefaultPartialOnUndefinedDeepOptions, Options>>;
+type _PartialOnUndefinedDeep<T, Options extends Required<PartialOnUndefinedDeepOptions>> = T extends Record<any, any> | undefined ? { [KeyType in keyof T as undefined extends T[KeyType] ? If<IsUnknown<T[KeyType]>, never, KeyType> : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options> } extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
+? Merge<{ [KeyType in keyof T as KeyType extends LiteralKeyOf<U> ? never : KeyType]: PartialOnUndefinedDeepValue<T[KeyType], Options> }, U> // Join all remaining keys not treated in U
+: never // Should not happen
+: T;
+/**
+Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
+*/
+type PartialOnUndefinedDeepValue<T, Options extends Required<PartialOnUndefinedDeepOptions>> = T extends BuiltIns | ((...arguments_: any[]) => unknown) ? T : T extends ReadonlyArray<infer U> // Test if type is array or tuple
+? Options['recurseIntoArrays'] extends true // Check if option is activated
+? U[] extends T // Check if array not tuple
+? readonly U[] extends T ? ReadonlyArray<_PartialOnUndefinedDeep<U, Options>> // Readonly array treatment
+: Array<_PartialOnUndefinedDeep<U, Options>> // Mutable array treatment
+: _PartialOnUndefinedDeep<{ [Key in keyof T]: _PartialOnUndefinedDeep<T[Key], Options> }, Options> // Tuple treatment
+: T : T extends Record<any, any> | undefined ? _PartialOnUndefinedDeep<T, Options> : unknown;
+//#endregion
+//#region src/types.d.ts
+interface BasicModel<T> {
+  title?: string;
+  description?: string;
+  examples?: T[];
+  schema?: StandardTypedV1<T, T>;
+}
+interface Int32Model extends BasicModel<number> {
+  kind: "int32";
+}
+interface Float32Model extends BasicModel<number> {
+  kind: "float32";
+}
+interface Float64Model extends BasicModel<number> {
+  kind: "float64";
+}
+interface BooleanModel extends BasicModel<boolean> {
+  kind: "boolean";
+}
+interface StringModel extends BasicModel<string> {
+  kind: "string";
+}
+interface ArrayModel<T extends Models> extends BasicModel<InferModel<T>[]> {
+  kind: "array";
+  base: T;
+}
+interface SetModel<T extends Models> extends BasicModel<Set<InferModel<T>>> {
+  kind: "set";
+  base: T;
+}
+interface MapModel<T extends Models> extends BasicModel<Map<string, InferModel<T>>> {
+  kind: "map";
+  base: T;
+}
+interface RecordModel<T extends Record<string, Models>, R extends keyof T & string> extends BasicModel<PropertiesType<T, R>> {
+  kind: "record";
+  properties: T;
+  required: R[];
+  id: string;
+}
+type PropertiesType<T extends Record<string, Models>, R extends keyof T> = PartialOnUndefinedDeep<{ [key in keyof T]: key extends R ? InferModel<T[key]> : InferModel<T[key]> | undefined }>;
+interface UnionModel<T extends Record<string, Models>> extends BasicModel<InferUnion<T>> {
+  kind: "union";
+  variants: T;
+  id: string;
+}
+type InferUnion<T extends Record<string, Models>> = { [key in keyof T]: { [k in key]: StandardTypedV1.InferOutput<NonNullable<T[key]["schema"]>> } }[keyof T];
+interface TaggedUnionModel<K extends string, D extends string, V extends Record<string, Models>> extends BasicModel<InferTaggedUnion<K, D, V>> {
+  kind: "taggedUnion";
+  variants: V;
+  variantKey: K;
+  payloadKey: D;
+  id: string;
+}
+interface TaggedUnionModelOptions<K extends string, D extends string, V extends Record<string, Models>> extends Omit<TaggedUnionModel<K, D, V>, "kind"> {}
+type InferTaggedUnion<K extends string, D extends string, V extends Record<string, Models>> = { [key in keyof V]: { [k in K | D]: k extends K ? key : k extends D ? StandardTypedV1.InferOutput<NonNullable<V[key]["schema"]>> : never } }[keyof V];
+interface LiteralModel<T extends string | number | boolean> extends BasicModel<T> {
+  kind: "literal";
+  value: T;
+}
+interface NullModel extends BasicModel<undefined | null> {
+  kind: "null";
+}
+type OptionsOf<T extends Models> = Omit<T, "kind">;
+interface EnumsModel<T extends {
+  [key: string]: string;
+}> extends BasicModel<T[keyof T]> {
+  kind: "enums";
+  id: string;
+  variants: T;
+}
+interface DatetimeModel extends BasicModel<string> {
+  kind: "datetime";
+}
+interface DateModel extends BasicModel<string> {
+  kind: "date";
+}
+interface DurationModel extends BasicModel<string> {
+  kind: "duration";
+}
+type Models = Int32Model | Float32Model | Float64Model | BooleanModel | StringModel | ArrayModel<any> | SetModel<any> | MapModel<any> | RecordModel<Record<string, Models>, string> | UnionModel<Record<string, Models>> | TaggedUnionModel<string, string, Record<string, Models>> | LiteralModel<string | number | boolean> | NullModel | EnumsModel<{
+  [key: string]: string;
+}> | DatetimeModel | DateModel | DurationModel;
+type InferModel<T> = T extends {
+  schema?: StandardTypedV1<unknown, unknown>;
+} ? StandardTypedV1.InferOutput<NonNullable<T["schema"]>> : never;
+declare function int32(options?: OptionsOf<Int32Model>): Int32Model;
+declare function float32(options?: OptionsOf<Float32Model>): Float32Model;
+declare function float64(options?: OptionsOf<Float64Model>): Float64Model;
+declare function boolean(options?: OptionsOf<BooleanModel>): BooleanModel;
+declare function string(options?: OptionsOf<StringModel>): StringModel;
+declare function array<T extends Models>(options: OptionsOf<ArrayModel<T>>): ArrayModel<T>;
+declare function set<T extends Models>(options: OptionsOf<SetModel<T>>): SetModel<T>;
+declare function map<T extends Models>(options: OptionsOf<MapModel<T>>): MapModel<T>;
+declare function record<T extends Record<string, Models>, R extends keyof T & string>(options: OptionsOf<RecordModel<T, R>>): RecordModel<T, R>;
+declare function union<T extends Record<string, Models>>(options: OptionsOf<UnionModel<T>>): UnionModel<T>;
+declare function taggedUnion<K extends string, D extends string, V extends Record<string, Models>>(options: TaggedUnionModelOptions<K, D, V>): TaggedUnionModel<K, D, V>;
+declare function literal<const T extends string | boolean | number>(value: T): LiteralModel<T>;
+declare function nullLike(): NullModel;
+interface EnumsModelOptions<T extends {
+  [key: string]: string;
+}> extends Omit<EnumsModel<T>, "kind"> {}
+declare function enums<const T extends {
+  [key: string]: string;
+}>(options: EnumsModelOptions<T>): EnumsModel<T>;
+interface DatetimeModelOptions extends Omit<DatetimeModel, "kind"> {}
+declare function datetime(options?: DatetimeModelOptions): DatetimeModel;
+interface DateModelOptions extends Omit<DateModel, "kind"> {}
+declare function date(options?: DateModelOptions): DateModel;
+interface DurationModelOptions extends Omit<DurationModel, "kind"> {}
+declare function duration(options?: DurationModelOptions): DurationModel;
+//#endregion
+//#region src/utils/index.d.ts
+type ExtractPathParams<Path extends string> = string extends Path ? string : Path extends `${infer _Start}/{${infer Param}}/${infer Rest}` ? Param | ExtractPathParams<`/${Rest}`> : Path extends `${infer _Start}/{${infer Param}}` ? Param : never;
+//#endregion
+//#region src/api.d.ts
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "TRACE";
+type SimpleType = Int32Model | Float32Model | Float64Model | StringModel | BooleanModel | DatetimeModel | DateModel | DurationModel;
+interface RouterModel {
+  basePath?: string;
+  name: string;
+  routes: Record<string, RouteModel<string, Record<string, SimpleType>, Models, RecordModel<Record<string, Models>, string>, RecordModel<Record<string, Models>, string>, Record<number, ResponseModel<Models, RecordModel<Record<string, Models>, string>>>>>;
+}
+interface RouteModel<Path extends string, Variables extends Record<string, SimpleType>, Body extends Models, Queries extends RecordModel<Record<string, Models>, string>, Headers extends RecordModel<Record<string, Models>, string>, Responses extends Record<number, ResponseModel<Models, RecordModel<Record<string, Models>, string>>>> {
+  kind: "route";
+  method: HttpMethod;
+  contentType?: string;
+  summary?: string;
+  description?: string;
+  path: Path;
+  variables?: Variables;
+  body?: Body;
+  headers?: Headers;
+  queries?: Queries;
+  responses: Responses;
+  tags?: string[];
+}
+type ResponseModel<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>> = JsonResponseModel<Body, Headers> | StreamResponseModel<Body, Headers> | SSEResponseModel<Body, Headers> | BinaryResponseModel<Headers>;
+interface JsonResponseModel<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>> {
+  kind: "json-response";
+  contentType?: PlainTextLikeContentType | JsonLikeContentType;
+  summary?: string;
+  body?: Body;
+  headers?: Headers;
+}
+interface StreamResponseModel<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>> {
+  kind: "stream-response";
+  contentType?: JsonStreamLikeContentType;
+  summary?: string;
+  body?: Body;
+  headers?: Headers;
+}
+interface SSEResponseModel<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>> {
+  kind: "sse-response";
+  contentType?: PlainTextStreamLikeContentType;
+  summary?: string;
+  body?: Body;
+  headers?: Headers;
+}
+interface BinaryResponseModel<Headers extends RecordModel<Record<string, Models>, string>> {
+  kind: "binary";
+  contentType?: BinaryLikeContentType;
+  summary?: string;
+  headers?: Headers;
+}
+interface RouteOptions<Path extends string, Variables extends Record<ExtractPathParams<Path>, SimpleType>, Body extends Models, Queries extends RecordModel<Record<string, Models>, string>, Headers extends RecordModel<Record<string, Models>, string>, Responses extends Record<string, ResponseModel<Models, RecordModel<Record<string, Models>, string>>>> extends Omit<RouteModel<string, Variables, Body, Queries, Headers, Responses>, "kind"> {}
+declare function route<Path extends string, Variables extends Record<ExtractPathParams<Path>, SimpleType>, Body extends Models, Queries extends RecordModel<Record<string, Models>, string>, Headers extends RecordModel<Record<string, Models>, string>, Responses extends Record<string, ResponseModel<Models, RecordModel<Record<string, Models>, string>>>>(options: RouteOptions<Path, Variables, Body, Queries, Headers, Responses>): RouteModel<Path, Variables, Body, Queries, Headers, Responses>;
+interface ResponseOptions<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>> {
+  contentType?: string;
+  summary?: string;
+  body?: Body;
+  headers?: Headers;
+}
+declare function json<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>>(options: ResponseOptions<Body, Headers>): JsonResponseModel<Body, Headers>;
+declare function jsonStream<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>>(options: ResponseOptions<Body, Headers>): StreamResponseModel<Body, Headers>;
+declare function sseStream<Body extends Models, Headers extends RecordModel<Record<string, Models>, string>>(options: ResponseOptions<Body, Headers>): SSEResponseModel<Body, Headers>;
+interface BinaryResponseOptions<Headers extends RecordModel<Record<string, Models>, string>> {
+  contentType?: BinaryLikeContentType;
+  summary?: string;
+  headers?: Headers;
+}
+declare function binary<Headers extends RecordModel<Record<string, Models>, string>>(options: BinaryResponseOptions<Headers>): BinaryResponseModel<Headers>;
+type PlainTextLikeContentType = (string & {}) | "text/plain" | "text/html" | "text/css" | "text/xml" | "text/markdown" | "text/csv";
+type JsonLikeContentType = (string & {}) | "application/json" | "application/json; charset=utf-8" | "application/ld+json" | "application/hal+json" | "application/vnd.api+json" | "application/problem+json" | "application/schema+json";
+type PlainTextStreamLikeContentType = (string & {}) | "text/event-stream";
+type JsonStreamLikeContentType = (string & {}) | "application/ndjson" | "application/x-ndjson" | "application/jsonl" | "application/json-seq" | "application/stream+json";
+type BinaryLikeContentType = (string & {}) | "application/octet-stream" | "application/pdf" | "application/zip" | "application/gzip" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "video/mp4" | "video/webm";
+type FormLikeContentType = (string & {}) | "application/x-www-form-urlencoded" | "multipart/form-data";
+//#endregion
+//#region src/security.d.ts
+interface SecurityPolicyModel {
+  name: string;
+  /** key就是path的模式, 支持正则表达 */
+  paths: Record<string, SecurityPolicyPathItem>;
+}
+interface SecurityPolicyPathItem {
+  /** 如果没有设置, 则默认对所有http method生效 */
+  methods?: HttpMethod[];
+  /** 如果没有设置, 则忽略该规则 */
+  pipeline?: SecurityApply[];
+}
+type SecurityComponent = ApikeySecurityComponent | OpenIdSecurityComponent;
+interface ApikeySecurityComponent {
+  kind: "apikey";
+  id: string;
+  name: string;
+  description?: string;
+}
+interface OpenIdSecurityComponent {
+  kind: "openIdConnect";
+  id: string;
+  description?: string;
+  scopes: string[];
+}
+interface SecurityApply {
+  component: SecurityComponent;
+  scopes: string[];
+}
+interface SecurityAppliable {
+  apply: (...scopes: string[]) => SecurityApply;
+}
+interface ApikeySecurityComponentOptions {
+  id: string;
+  name: string;
+  description?: string;
+}
+declare function apikey(options: ApikeySecurityComponentOptions): ApikeySecurityComponent & SecurityAppliable;
+interface OpenIdComponentOptions {
+  id: string;
+  description?: string;
+  scopes: string[];
+}
+declare function openIdConnect(options: OpenIdComponentOptions): OpenIdSecurityComponent & SecurityAppliable;
+//#endregion
+//#region src/deployment.d.ts
+interface OpenIdDeployment {
+  kind: "openIdConnectDeployment";
+  component: OpenIdSecurityComponent;
+  issuer: string;
+}
+interface OpenIdDeploymentOptions {
+  component: OpenIdSecurityComponent;
+  issuer: string;
+}
+declare function deployOpenIdConnect(options: OpenIdDeploymentOptions): OpenIdDeployment;
+type SecurityDeployment = OpenIdDeployment;
 //#endregion
 //#region src/schemas/json-schema-draft-2020-12.d.ts
 interface JsonSchemaObject extends JsonSchemaCore, JsonSchemaApplicator, JsonSchemaUnevaluated, JsonSchemaValidation, JsonSchemaMetaData, JsonSchemaFormat, JsonSchemaContent {}
@@ -105,7 +1670,7 @@ interface JsonSchemaUnevaluated {
   unevaluatedProperties?: JsonSchema;
 }
 interface JsonSchemaValidation {
-  type?: SimpleType | SimpleType[];
+  type?: SimpleType$1 | SimpleType$1[];
   const?: any;
   enum?: any[];
   multipleOf?: number;
@@ -147,280 +1712,31 @@ interface JsonSchemaContent {
   contentSchema?: JsonSchema;
 }
 declare const SimpleTypes: readonly ["array", "boolean", "integer", "null", "number", "object", "string"];
-type SimpleType = (typeof SimpleTypes)[number];
-//#endregion
-//#region src/schemas/schema-variants.d.ts
-interface StringSchema {
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-  format?: FormatVariants | (string & {});
-}
-interface NumberSchema {
-  multipleOf?: number;
-  maximum?: number;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-}
-interface ArraySchema {
-  maxItems?: number;
-  minItems?: number;
-  contains?: JsonSchemaObject;
-  maxContains?: number;
-  minContains?: number;
-}
-interface SetSchema {
-  maxItems?: number;
-  minItems?: number;
-  contains?: JsonSchemaObject;
-  maxContains?: number;
-  minContains?: number;
-}
-interface MapSchema {
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  dependentRequired?: {
-    [key: string]: string[];
-  };
-}
+type SimpleType$1 = (typeof SimpleTypes)[number];
 //#endregion
-//#region src/type-system/basic.d.ts
-interface BasicModel<T> {
-  id?: string;
-  title?: string;
-  description?: string;
-  examples?: T[];
-  default?: T;
-  deprecated?: boolean;
-}
-interface Int32Model extends BasicModel<number> {
-  kind: "int32";
-  schema?: NumberSchema;
-}
-interface Int32ModelOptions extends Omit<Int32Model, "kind"> {}
-declare function int32(options?: Int32ModelOptions): Int32Model;
-interface Int64Model extends BasicModel<string> {
-  kind: "int64";
-  schema?: StringSchema;
-}
-interface Int64ModelOptions extends Omit<Int64Model, "kind"> {}
-declare function int64(options?: Int64ModelOptions): Int64Model;
-interface Float32Model extends BasicModel<number> {
-  kind: "float32";
-  schema?: NumberSchema;
-}
-interface Float32ModelOptions extends Omit<Float32Model, "kind"> {}
-declare function float32(options?: Float32ModelOptions): Float32Model;
-interface Float64Model extends BasicModel<number> {
-  kind: "float64";
-  schema?: NumberSchema;
-}
-interface Float64ModelOptions extends Omit<Float64Model, "kind"> {}
-declare function float64(options?: Float64ModelOptions): Float64Model;
-interface BooleanModel extends BasicModel<boolean> {
-  kind: "boolean";
-}
-interface BooleanModelOptions extends Omit<BooleanModel, "kind"> {}
-declare function boolean(options?: BooleanModelOptions): BooleanModel;
-interface StringModel extends BasicModel<string> {
-  kind: "string";
-  schema?: StringSchema;
-}
-interface StringModelOptions extends Omit<StringModel, "kind"> {}
-declare function string(options?: StringModelOptions): StringModel;
-interface LiteralModel<T extends string | number | boolean> extends BasicModel<T> {
-  kind: "literal";
-  value: T;
-}
-interface LiteralModelOptions<T extends string | number | boolean> extends Omit<LiteralModel<T>, "kind"> {}
-declare function literal<const T extends string | number | boolean>(options: LiteralModelOptions<T>): LiteralModel<T>;
-/**
- * 表示一个可选类型，代表"值可能存在也可能不存在"的语义。
- *
- * 设计理念：
- * - 统一"空白"语义：将 `null`、`undefined` 和缺失值等多种"空"的概念合并为单一语义，
- *   避免类型系统中存在多个含义模糊的"空"状态。
- * - 序列化到 JSON 时，`Optional` 可以表示为 `null` 或完全省略（取决于上下文）。
- *   `InferModelJsonType<T> | null | undefined` 表示该值可以是基础类型、`null` 或 `undefined`。
- * - 如果需要区分"显式设置为空"和"从未设置"等细分语义，应当另行设计专用类型。
- *
- * @template T 基础模型类型
- */
-interface OptionalModel<T extends TypeModels> extends BasicModel<InferModelJsonType<T> | null | undefined> {
-  kind: "optional";
-  base: T;
-}
-/**
- * 将类型模型转换为可选类型。
- *
- * @template T 基础模型类型
- */
-type Optionalize<T extends TypeModels> = T extends TypeModels ? OptionalModel<T> : never;
-interface OptionalModelOptions<T extends TypeModels> extends Omit<OptionalModel<T>, "kind" | "base"> {}
-/**
- * 创建一个可选类型模型。
- *
- * @param base 基础模型类型
- * @param options 可选配置选项
- * @returns 可选类型模型
- */
-declare function optional<T extends TypeModels>(base: T, options?: OptionalModelOptions<T>): OptionalModel<T>;
-interface ArrayModel<T> extends BasicModel<InferModelJsonType<T>[]> {
-  kind: "array";
-  base: T;
-  schema?: ArraySchema;
-}
-interface ArrayModelOptions<T extends TypeModels> extends Omit<ArrayModel<T>, "kind" | "base"> {}
-declare function array<T extends TypeModels>(base: T, options?: ArrayModelOptions<T>): ArrayModel<T>;
-interface SetModel<T extends TypeModels> extends BasicModel<InferModelJsonType<T>[]> {
-  kind: "set";
-  base: T;
-  schema?: SetSchema;
-}
-interface SetModelOptions<T extends TypeModels> extends Omit<SetModel<T>, "kind" | "base"> {}
-declare function set<T extends TypeModels>(base: T, options?: SetModelOptions<T>): SetModel<T>;
-interface MapModel<T> extends BasicModel<{
-  [key: string]: InferModelJsonType<T>;
-}> {
-  kind: "map";
-  base: T;
-  schema?: MapSchema;
-}
-interface MapModelOptions<T extends TypeModels> extends Omit<MapModel<T>, "kind" | "base"> {}
-declare function map<T extends TypeModels>(base: T, options?: MapModelOptions<T>): MapModel<T>;
-interface RecordModel<T extends {
-  [key: string]: TypeModels;
-}> extends BasicModel<InferRecordJsonType<T>> {
-  kind: "record";
-  id: string;
-  properties: T;
-}
-type KeyOfOptional<T extends {
-  [key: string]: TypeModels;
-}> = { [key in keyof T]: T[key] extends OptionalModel<any> ? key : never }[keyof T];
-type InferRecordJsonType<T extends {
-  [key: string]: TypeModels;
-}, O extends KeyOfOptional<T> = KeyOfOptional<T>> = Simplify<{ [key in Exclude<keyof T, O>]: InferModelJsonType<T[key]> } & { [key in O]?: InferModelJsonType<T[key]> }>;
-interface RecordModelOptions<T extends {
-  [key: string]: TypeModels;
-}> extends Omit<RecordModel<T>, "kind"> {}
-declare function record<const T extends {
-  [key: string]: TypeModels;
-}>(options: RecordModelOptions<T>): RecordModel<T>;
-interface UnionModel<T extends {
-  [key: string]: TypeModels;
-}> extends BasicModel<InferUnionJsonType<T>> {
-  kind: "union";
-  id: string;
-  variants: T;
-}
-type InferUnionJsonType<T extends {
-  [key: string]: TypeModels;
-}> = { [key in keyof T]: { [k in key]: InferModelJsonType<T[key]> } }[keyof T];
-interface UnionModelOptions<T extends {
-  [key: string]: TypeModels;
-}> extends Omit<UnionModel<T>, "kind"> {}
-declare function union<const T extends {
-  [key: string]: TypeModels;
-}>(options: UnionModelOptions<T>): UnionModel<T>;
-interface DatetimeModel extends BasicModel<string> {
-  kind: "datetime";
-  schema?: StringSchema;
-}
-interface DatetimeModelOptions extends Omit<DatetimeModel, "kind"> {}
-declare function datetime(options?: DatetimeModelOptions): DatetimeModel;
-interface DateModel extends BasicModel<string> {
-  kind: "date";
-  schema?: StringSchema;
-}
-interface DateModelOptions extends Omit<DateModel, "kind"> {}
-declare function date(options?: DateModelOptions): DateModel;
-interface DurationModel extends BasicModel<string> {
-  kind: "duration";
-  schema?: StringSchema;
-}
-interface DurationModelOptions extends Omit<DurationModel, "kind"> {}
-declare function duration(options?: DurationModelOptions): DurationModel;
-interface ErrorModel<Code extends string, Context extends {
-  [key: string]: TypeModels;
-}> extends BasicModel<InferErrorModel<Code, Context>> {
-  kind: "error";
-  id: string;
-  code: Code;
-  context: Context;
-}
-type InferErrorModel<Code extends string, Context extends {
-  [key: string]: TypeModels;
-}> = {
-  code: Code;
-  context: InferRecordJsonType<Context>;
-};
-interface ErrorModelOptions<Code extends string, Context extends {
-  [key: string]: TypeModels;
-}> extends Omit<ErrorModel<Code, Context>, "kind"> {}
-declare function error<const Code extends string, Context extends {
-  [key: string]: TypeModels;
-}>(options: ErrorModelOptions<Code, Context>): ErrorModel<Code, Context>;
-interface EnumsModel<T extends {
-  [key: string]: string;
-}> extends BasicModel<T[keyof T]> {
+//#region src/generate-jsonschema.d.ts
+interface SchemaRegistry {
+  getRef: (model: Models) => string | undefined;
+  add: (id: string, model: Models) => SchemaRegistry;
+}
+interface GenerateJsonSchemaOptions {
+  model: Models;
+  registry?: SchemaRegistry;
+  toJsonSchema?: (type?: StandardTypedV1) => JsonSchemaObject;
+}
+interface GenerateJsonSchemaResult {
+  jsonSchema: JsonSchema;
+  registry: SchemaRegistry;
+}
+declare function generateJsonSchema(options: GenerateJsonSchemaOptions): GenerateJsonSchemaResult;
+declare function createJsonSchemaRegistry(models?: Map<Models, {
   id: string;
-  kind: "enums";
-  variants: T;
-}
-interface EnumsModelOptions<T extends {
-  [key: string]: string;
-}> extends Omit<EnumsModel<T>, "kind"> {}
-declare function enums<const T extends {
-  [key: string]: string;
-}>(options: EnumsModelOptions<T>): EnumsModel<T>;
-interface TaggedUnionModel<Tag extends string, Variants extends {
-  [key: string]: RecordModel<{ [key in Tag]: LiteralModel<string> }>;
-}> extends BasicModel<InferTaggedUnionJsonType<Tag, Variants>> {
+  schema: JsonSchema;
+}>): SchemaRegistry;
+declare function createOpenapiSchemaRegistry(models?: Map<Models, {
   id: string;
-  kind: "tagged-union";
-  tag: Tag;
-  variants: Variants;
-}
-type InferTaggedUnionJsonType<Tag extends string, Variants extends {
-  [key: string]: RecordModel<{ [key in Tag]: LiteralModel<string> }>;
-}> = { [key in keyof Variants]: Variants[key] extends RecordModel<infer R> ? InferRecordJsonType<R> : never }[keyof Variants];
-interface TaggedUnionModelOptions<Tag extends string, Variants extends {
-  [key: string]: RecordModel<{ [key in Tag]: LiteralModel<string> }>;
-}> extends Omit<TaggedUnionModel<Tag, Variants>, "kind"> {}
-declare function taggedUnion<const Tag extends string, Variants extends {
-  [key: string]: RecordModel<{ [key in Tag]: LiteralModel<string> }>;
-}>(options: TaggedUnionModelOptions<Tag, Variants>): TaggedUnionModel<Tag, Variants>;
-type TypeModels = Int32Model | Int64Model | Float32Model | Float64Model | BooleanModel | StringModel | LiteralModel<string | number | boolean> | OptionalModel<TypeModels> | ArrayModel<TypeModels> | SetModel<TypeModels> | MapModel<TypeModels> | RecordModel<{
-  [key: string]: TypeModels;
-}> | UnionModel<{
-  [key: string]: TypeModels;
-}> | TaggedUnionModel<string, {
-  [key: string]: any;
-}> | DatetimeModel | DateModel | DurationModel | ErrorModel<string, {
-  [key: string]: TypeModels;
-}> | EnumsModel<{
-  [key: string]: string;
-}>;
-type InferModelJsonType<T> = any extends T ? never : TypeModels extends T ? any : T extends Int32Model ? number : T extends Int64Model ? string : T extends Float32Model ? number : T extends Float64Model ? number : T extends BooleanModel ? boolean : T extends StringModel ? string : T extends LiteralModel<infer R> ? R : T extends OptionalModel<infer R> ? InferModelJsonType<R> | undefined | null : T extends ArrayModel<infer R> ? InferModelJsonType<R>[] : T extends SetModel<infer R> ? InferModelJsonType<R>[] : T extends MapModel<infer R> ? Record<string, InferModelJsonType<R>> : T extends RecordModel<infer R> ? InferRecordJsonType<R> : T extends UnionModel<infer R> ? InferUnionJsonType<R> : T extends TaggedUnionModel<infer Tag, infer Variants> ? InferTaggedUnionJsonType<Tag, Variants> : T extends DatetimeModel ? string : T extends DateModel ? string : T extends DurationModel ? string : T extends ErrorModel<infer Code, infer Context> ? InferErrorModel<Code, Context> : T extends EnumsModel<infer R> ? R[keyof R] : never;
-interface ModelToJsonSchemaOptions {
-  model: TypeModels;
-  target?: "draft-2020-12";
-  reference?: "inline" | "json-schema" | "openapi";
-  depth?: number;
-}
-declare function generateJsonSchema(options: ModelToJsonSchemaOptions): JsonSchemaObject;
-type NamedModel = RecordModel<{
-  [key: string]: TypeModels;
-}> | EnumsModel<{
-  [key: string]: string;
-}> | UnionModel<{
-  [key: string]: TypeModels;
-}> | ErrorModel<string, {
-  [key: string]: TypeModels;
-}>;
+  schema: JsonSchema;
+}>): SchemaRegistry;
 //#endregion
 //#region src/schemas/openapi-schema.d.ts
 interface OpenAPIObject {
@@ -716,204 +2032,133 @@ interface SecurityRequirementObject {
   [key: string]: string[];
 }
 //#endregion
-//#region src/utils/index.d.ts
-type ExtractPathParams<Path extends string> = string extends Path ? string : Path extends `${infer _Start}/{${infer Param}}/${infer Rest}` ? Param | ExtractPathParams<`/${Rest}`> : Path extends `${infer _Start}/{${infer Param}}` ? Param : never;
-//#endregion
-//#region src/type-system/http.d.ts
-type AllowedHttpValue = StringModel | Int32Model | Int64Model | BooleanModel | LiteralModel<string | number | boolean> | Optionalize<StringModel | Int32Model | Int64Model | BooleanModel | LiteralModel<string | number | boolean>>;
-type PartialOf<T extends {
-  [key: string]: any;
-}, K extends keyof T> = Simplify<{ [key in Exclude<keyof T, K>]: T[key] } & { [key in K]?: T[key] }>;
+//#region src/generate-openapi.d.ts
 interface GenerateOpenapiOptions {
-  info: OpenAPIObject["info"];
-  routes: HttpRouteModel[];
-  securitySchemes?: NonNullable<OpenAPIObject["components"]>["securitySchemes"];
-  tags?: OpenAPIObject["tags"];
-  servers?: OpenAPIObject["servers"];
-}
-declare function generateOpenapi(options: GenerateOpenapiOptions): OpenAPIObject;
-declare function collectModelFromRoutes(routes: HttpRouteModel[]): Map<string, TypeModels>;
-declare function collectModelDeep(model: TypeModels): Map<string, TypeModels>;
-interface HttpResponseModel {
-  status: number;
-  description?: string;
-  content?: HttpContentModel;
-  headers?: {
-    [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-  };
-  cookies?: {
-    [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-  };
-}
-interface HttpRouteModel<Path extends string = string> {
-  kind: "http-route";
-  id: string;
-  path: Path;
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "TRACE";
-  description?: string;
-  summary?: string;
-  variables: { [key in ExtractPathParams<Path>]: AllowedHttpValue };
-  queries?: {
-    [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-  };
-  cookies?: {
-    [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-  };
-  headers?: {
-    [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-  };
-  content?: HttpContentModel;
-  responses?: {
-    [key: string]: HttpResponseModel;
-  };
-  tags?: string[];
+  info: InfoObject;
+  servers?: ServerObject[];
+  routers: RouterModel[];
   security?: {
-    [key: string]: string[];
+    policy?: SecurityPolicyModel;
+    deployments?: Record<string, SecurityDeployment>;
   };
 }
-interface HttpRouteModelOptions<Path extends string> extends Omit<HttpRouteModel<Path>, "kind"> {}
-declare function route<const Path extends string>(options: HttpRouteModelOptions<Path>): HttpRouteModel<Path>;
-interface PlainTextContentModel {
-  kind: "plain-text-content";
-  type: PlainTextLikeContentType;
-  model?: StringModel;
-}
-interface PlainTextContentOptions extends Omit<PlainTextContentModel, "kind"> {}
-declare function plainText(options: PlainTextContentOptions): PlainTextContentModel;
-interface JsonContentModel {
-  kind: "json-content";
-  type: JsonLikeContentType;
-  model: TypeModels;
-}
-interface JsonContentOptions extends Omit<JsonContentModel, "kind"> {}
-declare function json(options: JsonContentOptions): JsonContentModel;
-interface PlainTextStreamContentModel {
-  kind: "plain-text-stream-content";
-  type: PlainTextLikeContentType;
-  model?: StringModel;
-  description?: string;
+interface GenerateOpenapiResult {
+  openapi: OpenAPIObject;
+  registry: SchemaRegistry;
 }
-interface PlainTextStreamContentOptions extends Omit<PlainTextStreamContentModel, "kind"> {}
-declare function plainTextStream(options: PlainTextStreamContentOptions): PlainTextStreamContentModel;
-interface JsonStreamContentModel {
-  kind: "json-stream-content";
-  type: JsonStreamLikeContentType;
-  model: TypeModels;
+declare function generateOpenapi(options: GenerateOpenapiOptions): GenerateOpenapiResult;
+//#endregion
+//#region src/codegen/descriptors.d.ts
+type AnyRouteModel = RouteModel<string, Record<string, SimpleType>, Models, RecordModel<Record<string, Models>, string>, RecordModel<Record<string, Models>, string>, Record<number, any>>;
+interface CollectOptions {
+  /** 将 originalId 映射为标识符，默认 pascalCase */
+  identifier?: (id: string) => string;
+  /** 命名空间，如 "com.example" */
+  namespace?: string;
+}
+interface ModelDescriptor {
+  kind: string;
+  originalId: string;
+  identifier: string;
+  namespace?: string;
+  title?: string;
   description?: string;
+  deprecated?: boolean;
+  examples?: unknown[];
+}
+interface RecordDescriptor extends ModelDescriptor {
+  kind: "record";
+  fields: FieldDescriptor[];
 }
-interface JsonStreamContentOptions extends Omit<JsonStreamContentModel, "kind"> {}
-declare function jsonStream(options: JsonStreamContentOptions): JsonStreamContentModel;
-interface BinaryStreamContentModel {
-  kind: "binary-stream-content";
-  type: BinaryLikeContentType;
+interface FieldDescriptor {
+  name: string;
+  model: Models;
+  required: boolean;
+  title?: string;
   description?: string;
+  deprecated?: boolean;
 }
-interface BinaryStreamContentOptions extends Omit<BinaryStreamContentModel, "kind"> {}
-declare function binary(options: BinaryStreamContentOptions): BinaryStreamContentModel;
-interface FormContentModel<T extends {
-  [key: string]: AllowedHttpValue | OptionalModel<AllowedHttpValue>;
-}> {
-  kind: "form-content";
-  type: FormLikeContentType;
-  model: RecordModel<T>;
-}
-interface FormContentOptions<T extends {
-  [key: string]: AllowedHttpValue;
-}> extends Omit<FormContentModel<T>, "kind"> {}
-declare function form<T extends {
-  [key: string]: AllowedHttpValue;
-}>(options: FormContentOptions<T>): FormContentModel<T>;
-type HttpContentModel = PlainTextContentModel | JsonContentModel | PlainTextStreamContentModel | JsonStreamContentModel | BinaryStreamContentModel | FormContentModel<{
-  [key: string]: AllowedHttpValue;
-}>;
-type PlainTextLikeContentType = (string & {}) | "text/plain" | "text/html" | "text/css" | "text/xml" | "text/markdown" | "text/csv";
-type JsonLikeContentType = (string & {}) | "application/json" | "application/json; charset=utf-8" | "application/ld+json" | "application/hal+json" | "application/vnd.api+json" | "application/problem+json" | "application/schema+json";
-type PlainTextStreamLikeContentType = (string & {}) | "text/event-stream";
-type JsonStreamLikeContentType = (string & {}) | "application/ndjson" | "application/x-ndjson" | "application/jsonl" | "application/json-seq" | "application/stream+json";
-type BinaryLikeContentType = (string & {}) | "application/octet-stream" | "application/pdf" | "application/zip" | "application/gzip" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "video/mp4" | "video/webm";
-type FormLikeContentType = (string & {}) | "application/x-www-form-urlencoded" | "multipart/form-data";
-//#endregion
-//#region src/generator/java.d.ts
-interface GenerateJavaClassOptions {
-  package: string;
-  model: NamedModel;
+interface EnumsDescriptor extends ModelDescriptor {
+  kind: "enums";
+  values: Record<string, string>;
 }
-declare function generateJavaClass(options: GenerateJavaClassOptions): string;
-declare function formatJava(code: string): Promise<string>;
-interface GenerateJavaOptions {
-  package: string;
-  srcDir: string;
-  routes?: HttpRouteModel[];
-  models?: TypeModels[];
+interface UnionDescriptor extends ModelDescriptor {
+  kind: "union";
+  variants: Record<string, Models>;
+}
+interface TaggedUnionDescriptor extends ModelDescriptor {
+  kind: "taggedUnion";
+  variants: Record<string, Models>;
+  variantKey: string;
+  payloadKey: string;
 }
-declare function generateJavaCodes(options: GenerateJavaOptions): Promise<{
+type AnyNamedDescriptor = RecordDescriptor | EnumsDescriptor | UnionDescriptor | TaggedUnionDescriptor;
+interface OperationDescriptor {
+  id: string;
+  group: string;
+  method: HttpMethod;
   path: string;
-  code: string;
-}[]>;
-//#endregion
-//#region src/generator/rust.d.ts
-interface GenerateRustCodeOptions {
-  module_name: string;
-  model: RecordModel<{
-    [key: string]: TypeModels;
-  }> | UnionModel<{
-    [key: string]: TypeModels;
-  }> | EnumsModel<{
-    [key: string]: string;
-  }> | ErrorModel<string, {
-    [key: string]: TypeModels;
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  requestModel: Models | null;
+  responses: Record<number, Models | null>;
+  responseKinds: Record<number, string>;
+  pathVariables: Record<string, {
+    model: Models;
+    name: string;
+  }>;
+  queries: Record<string, {
+    model: Models;
+    name: string;
+    required: boolean;
+  }>;
+  headers: Record<string, {
+    model: Models;
+    name: string;
+    required: boolean;
   }>;
 }
-declare function generateRustCode(options: GenerateRustCodeOptions): string;
-declare function formatRust(code: string): Promise<string>;
-interface GenerateRustOptions {
-  module_name: string;
-  srcDir: string;
-  routes?: HttpRouteModel[];
-  models?: TypeModels[];
-}
-declare function generateRustCodes(options: GenerateRustOptions): Promise<{
-  path: string;
-  code: string;
-}[]>;
-//#endregion
-//#region src/type-system/serialize.d.ts
-type InferDeserialized<T> = any extends T ? never : TypeModels extends T ? any : T extends Int32Model ? number : T extends Int64Model ? bigint : T extends Float32Model ? number : T extends Float64Model ? number : T extends BooleanModel ? boolean : T extends StringModel ? string : T extends LiteralModel<infer R> ? R : T extends OptionalModel<infer R> ? InferDeserialized<R> | undefined | null : T extends ArrayModel<infer R> ? InferDeserialized<R>[] : T extends SetModel<infer R> ? Set<InferDeserialized<R>> : T extends MapModel<infer R> ? Map<string, InferDeserialized<R>> : T extends RecordModel<infer R> ? InferDeserializedRecord<R> : T extends UnionModel<infer R> ? InferDeserializedUnion<R> : T extends TaggedUnionModel<infer _Tag, infer R> ? InferDeserializedTaggedUnion<R> : T extends DatetimeModel ? Temporal.Instant : T extends DateModel ? Temporal.Instant : T extends DurationModel ? Temporal.Duration : T extends ErrorModel<infer Code, infer Context> ? InferDeserializedError<Code, Context> : T extends EnumsModel<infer R> ? R[keyof R] : never;
-type InferDeserializedRecord<T extends {
-  [key: string]: TypeModels;
-}, O extends KeyOfOptional<T> = KeyOfOptional<T>> = Simplify<{ [key in Exclude<keyof T, O>]: InferDeserialized<T[key]> } & { [key in O]?: InferDeserialized<T[key]> }>;
-type InferDeserializedUnion<T extends {
-  [key: string]: TypeModels;
-}> = { [key in keyof T]: { [k in key]: InferDeserialized<T[key]> } }[keyof T];
-type InferDeserializedTaggedUnion<Variants extends {
-  [key: string]: RecordModel<{
-    [key: string]: TypeModels;
+interface SchemaInfo {
+  kind: "record" | "enums" | "union" | "taggedUnion";
+  fields?: Array<{
+    name: string;
+    model: Models;
+    required: boolean;
   }>;
-}> = { [key in keyof Variants]: InferDeserialized<Variants[key]> }[keyof Variants];
-type InferDeserializedError<Code extends string, Context extends {
-  [key: string]: TypeModels;
-}> = [Context] extends [never] ? {
-  code: Code;
-} : {
-  code: Code;
-  context: InferDeserializedRecord<Context>;
-};
-declare function deserialize<T extends TypeModels>(model: T, json: string): DeserializeResult<InferDeserialized<T>>;
-declare function deserializeInner<T extends TypeModels>(model: T, value: any): DeserializeResult<InferDeserialized<T>>;
-interface DeserializeSuccess<T> {
-  isSuccess: true;
-  value: T;
+  variants?: Record<string, string>;
+  unionVariants?: Record<string, Models>;
+  variantKey?: string;
+  payloadKey?: string;
 }
-interface DeserializeFailed {
-  isSuccess: false;
-  code: "deserial-failed";
-  context: {
-    expect: TypeModels;
-    receive: any;
-  };
+type SchemaMap = Map<string, SchemaInfo>;
+//#endregion
+//#region src/codegen/collect.d.ts
+declare function collectNamedModels(models: Models[], options?: CollectOptions): AnyNamedDescriptor[];
+declare function collectOperations(routers: RouterModel[]): OperationDescriptor[];
+declare function collectSchemaMap(ops: OperationDescriptor[]): SchemaMap;
+declare function resolveNamedRoot(m: Models): {
+  id: string;
+} | null;
+//#endregion
+//#region src/codegen/json-schema.d.ts
+declare function mergeJsonSchemas(schemas: Record<string, Models>): JsonSchemaObject;
+//#endregion
+//#region src/codegen/hono-server.d.ts
+interface HonoServerOptions {
+  routers: RouterModel[];
+  identifier?: (id: string) => string;
+  namespace?: string;
+}
+declare function generateHonoServer(options: HonoServerOptions): Record<string, string>;
+//#endregion
+//#region src/codegen/ts-client.d.ts
+interface TsClientOptions {
+  routers: RouterModel[];
+  identifier?: (id: string) => string;
+  namespace?: string;
 }
-type DeserializeResult<T> = DeserializeSuccess<T> | DeserializeFailed;
-declare function serialize<T extends TypeModels>(model: T, value: InferDeserialized<T>): string;
+declare function generateTsClient(options: TsClientOptions): Record<string, string>;
 //#endregion
-export { AllowedHttpValue, ArrayModel, ArrayModelOptions, BasicModel, BinaryLikeContentType, BinaryStreamContentModel, BinaryStreamContentOptions, BooleanModel, BooleanModelOptions, DateModel, DateModelOptions, DatetimeModel, DatetimeModelOptions, DeserializeFailed, DeserializeResult, DeserializeSuccess, DurationModel, DurationModelOptions, EnumsModel, EnumsModelOptions, ErrorModel, ErrorModelOptions, Float32Model, Float32ModelOptions, Float64Model, Float64ModelOptions, FormContentModel, FormContentOptions, FormLikeContentType, GenerateJavaClassOptions, GenerateJavaOptions, GenerateOpenapiOptions, GenerateRustCodeOptions, GenerateRustOptions, HttpContentModel, HttpResponseModel, HttpRouteModel, HttpRouteModelOptions, InferDeserialized, InferDeserializedError, InferDeserializedRecord, InferDeserializedTaggedUnion, InferDeserializedUnion, InferErrorModel, InferModelJsonType, InferRecordJsonType, InferTaggedUnionJsonType, InferUnionJsonType, Int32Model, Int32ModelOptions, Int64Model, Int64ModelOptions, JsonContentModel, JsonContentOptions, JsonLikeContentType, JsonStreamContentModel, JsonStreamContentOptions, JsonStreamLikeContentType, KeyOfOptional, LiteralModel, LiteralModelOptions, MapModel, MapModelOptions, ModelToJsonSchemaOptions, NamedModel, OptionalModel, OptionalModelOptions, Optionalize, PartialOf, PlainTextContentModel, PlainTextContentOptions, PlainTextLikeContentType, PlainTextStreamContentModel, PlainTextStreamContentOptions, PlainTextStreamLikeContentType, RecordModel, RecordModelOptions, SetModel, SetModelOptions, StringModel, StringModelOptions, TaggedUnionModel, TaggedUnionModelOptions, TypeModels, UnionModel, UnionModelOptions, array, binary, boolean, collectModelDeep, collectModelFromRoutes, date, datetime, deserialize, deserializeInner, duration, enums, error, float32, float64, form, formatJava, formatRust, generateJavaClass, generateJavaCodes, generateJsonSchema, generateOpenapi, generateRustCode, generateRustCodes, int32, int64, json, jsonStream, literal, map, optional, plainText, plainTextStream, record, route, serialize, set, string, taggedUnion, union };
+export { AnyNamedDescriptor, AnyRouteModel, ApikeySecurityComponent, ApikeySecurityComponentOptions, ArrayModel, BasicModel, BinaryLikeContentType, BinaryResponseModel, BinaryResponseOptions, BooleanModel, CollectOptions, DateModel, DateModelOptions, DatetimeModel, DatetimeModelOptions, DurationModel, DurationModelOptions, EnumsDescriptor, EnumsModel, EnumsModelOptions, FieldDescriptor, Float32Model, Float64Model, FormLikeContentType, GenerateJsonSchemaOptions, GenerateJsonSchemaResult, GenerateOpenapiOptions, GenerateOpenapiResult, HonoServerOptions, HttpMethod, InferModel, InferTaggedUnion, InferUnion, Int32Model, JsonLikeContentType, JsonResponseModel, JsonStreamLikeContentType, LiteralModel, MapModel, ModelDescriptor, Models, NullModel, OpenIdComponentOptions, OpenIdDeployment, OpenIdDeploymentOptions, OpenIdSecurityComponent, OperationDescriptor, OptionsOf, PlainTextLikeContentType, PlainTextStreamLikeContentType, PropertiesType, RecordDescriptor, RecordModel, ResponseModel, ResponseOptions, RouteModel, RouteOptions, RouterModel, SSEResponseModel, SchemaInfo, SchemaMap, SchemaRegistry, SecurityAppliable, SecurityApply, SecurityComponent, SecurityDeployment, SecurityPolicyModel, SecurityPolicyPathItem, SetModel, SimpleType, StreamResponseModel, StringModel, TaggedUnionDescriptor, TaggedUnionModel, TsClientOptions, UnionDescriptor, UnionModel, apikey, array, binary, boolean, collectNamedModels, collectOperations, collectSchemaMap, createJsonSchemaRegistry, createOpenapiSchemaRegistry, date, datetime, deployOpenIdConnect, duration, enums, float32, float64, generateHonoServer, generateJsonSchema, generateOpenapi, generateTsClient, int32, json, jsonStream, literal, map, mergeJsonSchemas, nullLike, openIdConnect, record, resolveNamedRoot, route, set, sseStream, string, taggedUnion, union };
 //# sourceMappingURL=index.d.mts.map