@huanglangjian/specs 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,864 @@
+//#region ../../node_modules/.pnpm/type-fest@5.5.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.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	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] } & {};
+//#endregion
+//#region src/schemas/json-schema-draft-2020-12.d.ts
+interface JsonSchemaObject extends JsonSchemaCore, JsonSchemaApplicator, JsonSchemaUnevaluated, JsonSchemaValidation, JsonSchemaMetaData, JsonSchemaFormat, JsonSchemaContent {}
+type JsonSchema = JsonSchemaObject | boolean | undefined;
+interface JsonSchemaCore {
+  $id?: string;
+  $schema?: string;
+  $ref?: string;
+  $anchor?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: {
+    [key: string]: boolean;
+  };
+  $comment?: string;
+  $defs?: {
+    [key: string]: JsonSchema;
+  };
+}
+interface JsonSchemaApplicator {
+  prefixItems?: JsonSchema[];
+  items?: JsonSchema;
+  contains?: JsonSchema;
+  additionalProperties?: JsonSchema;
+  properties?: {
+    [key: string]: JsonSchema;
+  };
+  patternProperties?: {
+    [key: string]: JsonSchema;
+  };
+  dependentSchemas?: {
+    [key: string]: JsonSchema;
+  };
+  propertyNames?: JsonSchema;
+  if?: JsonSchema;
+  then?: JsonSchema;
+  else?: JsonSchema;
+  allOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  not?: JsonSchema;
+}
+interface JsonSchemaUnevaluated {
+  unevaluatedItems?: JsonSchema;
+  unevaluatedProperties?: JsonSchema;
+}
+interface JsonSchemaValidation {
+  type?: SimpleType | SimpleType[];
+  const?: any;
+  enum?: any[];
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: {
+    [key: string]: string[];
+  };
+}
+interface JsonSchemaMetaData {
+  title?: string;
+  description?: string;
+  default?: any;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  examples?: any[];
+}
+interface JsonSchemaFormat {
+  format?: FormatVariants | (string & {});
+}
+type FormatVariants = "date-time" | "date" | "time" | "duration" | "email" | "hostname" | "ipv4" | "ipv6" | "uri" | "uri-reference" | "uri-template" | "url" | "json-pointer" | "relative-json-pointer" | "regex" | "byte" | "binary" | "uuid" | "ipvfuture" | "int64" | "int32" | "float" | "double";
+interface JsonSchemaContent {
+  contentEncoding?: string;
+  contentMediaType?: string;
+  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[];
+  };
+}
+//#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<TypeModels> ? 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;
+}> = [Context] extends [never] ? {
+  code: Code;
+} : {
+  code: Code;
+  context: Context;
+};
+interface ErrorModelOptions<Code extends string, Context extends {
+  [key: string]: TypeModels;
+}> extends Omit<ErrorModel<Code, Context>, "kind"> {}
+declare function error<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]> {
+  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>;
+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;
+}> | 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 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 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;
+}>;
+//#endregion
+//#region src/schemas/openapi-schema.d.ts
+interface OpenAPIObject {
+  openapi: string;
+  info: InfoObject;
+  SchemaObjectDialect?: string;
+  servers?: ServerObject[];
+  paths?: PathsObject;
+  webhooks?: {
+    [key: string]: PathItemObject;
+  };
+  components?: ComponentsObject;
+  security?: SecurityRequirementObject;
+  tags?: TagObject[];
+  externalDocs?: ExternalDocumentationObject;
+}
+interface InfoObject {
+  title: string;
+  summary?: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: ContactObject;
+  license?: LicenseObject;
+  version: string;
+}
+interface ContactObject {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+interface LicenseObject {
+  name: string;
+  identifier?: string;
+  url?: string;
+}
+interface ServerObject {
+  url: string;
+  description?: string;
+  variables?: {
+    [key: string]: ServerVariableObject;
+  };
+}
+interface ServerVariableObject {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+interface ComponentsObject {
+  schemas?: {
+    [key: string]: SchemaObject;
+  };
+  responses?: {
+    [key: string]: ResponseObject | ReferenceObject;
+  };
+  parameters?: {
+    [key: string]: ParameterObject | ReferenceObject;
+  };
+  examples?: {
+    [key: string]: ExampleObject | ReferenceObject;
+  };
+  requestBodies?: {
+    [key: string]: RequestBodyObject | ReferenceObject;
+  };
+  headers?: {
+    [key: string]: HeaderObject | ReferenceObject;
+  };
+  securitySchemes?: {
+    [key: string]: SecuritySchemeObject | ReferenceObject;
+  };
+  links?: {
+    [key: string]: LinkObject | ReferenceObject;
+  };
+  callbacks?: {
+    [key: string]: CallbackObject | ReferenceObject;
+  };
+  pathItems?: {
+    [key: string]: PathItemObject | ReferenceObject;
+  };
+}
+interface PathsObject {
+  [key: string]: PathItemObject;
+}
+interface PathItemObject {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  get?: OperationObject;
+  put?: OperationObject;
+  post?: OperationObject;
+  delete?: OperationObject;
+  options?: OperationObject;
+  head?: OperationObject;
+  patch?: OperationObject;
+  trace?: OperationObject;
+  servers?: ServerObject[];
+  parameters?: Array<ParameterObject | ReferenceObject>;
+}
+interface OperationObject {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+  operationId?: string;
+  parameters?: Array<ParameterObject | ReferenceObject>;
+  requestBody?: RequestBodyObject | ReferenceObject;
+  responses?: ResponsesObject;
+  callbacks?: {
+    [key: string]: CallbackObject | ReferenceObject;
+  };
+  deprecated?: boolean;
+  security?: SecurityRequirementObject[];
+  servers?: ServerObject[];
+}
+interface ExternalDocumentationObject {
+  url: string;
+  description?: string;
+}
+interface ParameterObjectCommon {
+  name: string;
+  in: string;
+  description?: string;
+  required: boolean;
+  deprecated?: boolean;
+  /** @deprecated Deprecated in Openapi 3.1*/
+  allowEmptyValue?: boolean;
+}
+interface ParameterObjectAsSchema extends ParameterObjectCommon {
+  schema: SchemaObject;
+  style?: StyleValues;
+  explode?: boolean;
+  allowReserved?: boolean;
+  example?: any;
+  examples?: {
+    [key: string]: ExampleObject | ReferenceObject;
+  };
+}
+interface ParameterObjectAsContent extends ParameterObjectCommon {
+  content: {
+    [key: string]: MediaTypeObject;
+  };
+}
+type ParameterObject = ParameterObjectAsSchema | ParameterObjectAsContent;
+type StyleValues = "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject";
+interface RequestBodyObject {
+  description?: string;
+  content: {
+    [key: string]: MediaTypeObject;
+  };
+  required?: boolean;
+}
+interface MediaTypeObject {
+  schema?: SchemaObject;
+  itemSchema?: SchemaObject;
+  itemEncoding?: {
+    contentType: string;
+  };
+  example?: any;
+  examples?: {
+    [key: string]: ExampleObject | ReferenceObject;
+  };
+  encoding?: {
+    [key: string]: EncodingObject;
+  };
+}
+interface EncodingObjectCommon {
+  contentType?: string;
+  headers?: {
+    [key: string]: HeaderObject | ReferenceObject;
+  };
+}
+interface EncodingObjectAsRFC6570 extends EncodingObjectCommon {
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+}
+type EncodingObject = EncodingObjectCommon | EncodingObjectAsRFC6570;
+interface ResponsesObject {
+  [key: string]: ResponseObject | ReferenceObject;
+}
+interface ResponseObject {
+  description: string;
+  headers?: {
+    [key: string]: HeaderObject | ReferenceObject;
+  };
+  content?: {
+    [key: string]: MediaTypeObject;
+  };
+  links?: {
+    [key: string]: LinkObject | ReferenceObject;
+  };
+}
+interface CallbackObject {
+  [key: string]: PathItemObject;
+}
+interface ExampleObject {
+  summary?: string;
+  description?: string;
+  value?: any;
+  externalValue?: string;
+}
+interface LinkObject {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: {
+    [key: string]: any;
+  };
+  requestBody?: any;
+  description?: string;
+  server?: ServerObject;
+}
+interface HeaderObjectCommon {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+}
+interface HeaderObjectAsSchema extends HeaderObjectCommon {
+  schema: SchemaObject | ReferenceObject;
+  style?: string;
+  explode?: boolean;
+  example?: any;
+  examples?: {
+    [key: string]: ExampleObject | ReferenceObject;
+  };
+}
+interface HeaderObjectAsContent extends HeaderObjectCommon {
+  content: {
+    [key: string]: MediaTypeObject;
+  };
+}
+type HeaderObject = HeaderObjectAsSchema | HeaderObjectAsContent;
+interface TagObject {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocumentationObject;
+}
+interface ReferenceObject {
+  $ref: string;
+  summary?: string;
+  description?: string;
+}
+type SchemaObject = JsonSchema;
+type SecuritySchemeObject = ApiKeySecurityScheme | HttpSecurityScheme | OAuth2SecurityScheme | OpenIdConnectSecurityScheme;
+interface ApiKeySecurityScheme {
+  type: "apiKey";
+  name: string;
+  in: "query" | "header" | "cookie";
+  description?: string;
+}
+interface HttpSecurityScheme {
+  type: "http";
+  scheme: string;
+  bearerFormat?: string;
+  description?: string;
+}
+interface OAuth2SecurityScheme {
+  type: "oauth2";
+  flows: OAuthFlowsObject;
+  description?: string;
+}
+interface OpenIdConnectSecurityScheme {
+  type: "openIdConnect";
+  openIdConnectUrl: string;
+  description?: string;
+}
+interface AuthorizationCodeFlowObject {
+  authorizationUrl: string;
+  tokenUrl: string;
+  refreshUrl?: string;
+  scopes: {
+    [key: string]: string;
+  };
+}
+interface PasswordFlowObject {
+  tokenUrl: string;
+  refreshUrl?: string;
+  scopes: {
+    [key: string]: string;
+  };
+}
+interface ClientCredentialsFlowObject {
+  tokenUrl: string;
+  refreshUrl?: string;
+  scopes: {
+    [key: string]: string;
+  };
+}
+interface OAuthFlowsObject {
+  authorizationCode?: AuthorizationCodeFlowObject;
+  password?: PasswordFlowObject;
+  clientCredentials?: ClientCredentialsFlowObject;
+}
+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] }>;
+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[];
+  security?: {
+    [key: string]: string[];
+  };
+}
+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 PlainTextStreamContentOptions extends Omit<PlainTextStreamContentModel, "kind"> {}
+declare function plainTextStream(options: PlainTextStreamContentOptions): PlainTextStreamContentModel;
+interface JsonStreamContentModel {
+  kind: "json-stream-content";
+  type: JsonStreamLikeContentType;
+  model: TypeModels;
+  description?: string;
+}
+interface JsonStreamContentOptions extends Omit<JsonStreamContentModel, "kind"> {}
+declare function jsonStream(options: JsonStreamContentOptions): JsonStreamContentModel;
+interface BinaryStreamContentModel {
+  kind: "binary-stream-content";
+  type: BinaryLikeContentType;
+  description?: string;
+}
+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;
+}
+declare function generateJavaClass(options: GenerateJavaClassOptions): string;
+declare function formatJava(code: string): Promise<string>;
+interface GenerateJavaOptions {
+  package: string;
+  srcDir: string;
+  routes?: HttpRouteModel[];
+  models?: TypeModels[];
+}
+declare function generateJavaCodes(options: GenerateJavaOptions): Promise<{
+  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;
+  }>;
+}
+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
+export { AllowedHttpValue, ArrayModel, ArrayModelOptions, BasicModel, BinaryLikeContentType, BinaryStreamContentModel, BinaryStreamContentOptions, BooleanModel, BooleanModelOptions, DateModel, DateModelOptions, DatetimeModel, DatetimeModelOptions, DurationModel, DurationModelOptions, EnumsModel, EnumsModelOptions, ErrorModel, ErrorModelOptions, Float32Model, Float32ModelOptions, Float64Model, Float64ModelOptions, FormContentModel, FormContentOptions, FormLikeContentType, GenerateJavaClassOptions, GenerateJavaOptions, GenerateOpenapiOptions, GenerateRustCodeOptions, GenerateRustOptions, HttpContentModel, HttpResponseModel, HttpRouteModel, HttpRouteModelOptions, InferErrorModel, InferModelJsonType, InferRecordJsonType, InferUnionJsonType, Int32Model, Int32ModelOptions, Int64Model, Int64ModelOptions, JsonContentModel, JsonContentOptions, JsonLikeContentType, JsonStreamContentModel, JsonStreamContentOptions, JsonStreamLikeContentType, LiteralModel, LiteralModelOptions, MapModel, MapModelOptions, ModelToJsonSchemaOptions, NamedModel, OptionalModel, OptionalModelOptions, Optionalize, PartialOf, PlainTextContentModel, PlainTextContentOptions, PlainTextLikeContentType, PlainTextStreamContentModel, PlainTextStreamContentOptions, PlainTextStreamLikeContentType, RecordModel, RecordModelOptions, SetModel, SetModelOptions, StringModel, StringModelOptions, TypeModels, UnionModel, UnionModelOptions, array, binary, boolean, collectModelDeep, collectModelFromRoutes, date, datetime, 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, set, string, union };
+//# sourceMappingURL=index.d.mts.map