//#region ../../node_modules/.pnpm/openapi-types@12.1.3/node_modules/openapi-types/dist/index.d.ts
declare namespace OpenAPIV3 {
  interface Document<T extends {} = {}> {
    openapi: string;
    info: InfoObject;
    servers?: ServerObject[];
    paths: PathsObject<T>;
    components?: ComponentsObject;
    security?: SecurityRequirementObject[];
    tags?: TagObject[];
    externalDocs?: ExternalDocumentationObject;
    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
    'x-express-openapi-validation-strict'?: boolean;
  }
  interface InfoObject {
    title: string;
    description?: string;
    termsOfService?: string;
    contact?: ContactObject;
    license?: LicenseObject;
    version: string;
  }
  interface ContactObject {
    name?: string;
    url?: string;
    email?: string;
  }
  interface LicenseObject {
    name: string;
    url?: string;
  }
  interface ServerObject {
    url: string;
    description?: string;
    variables?: {
      [variable: string]: ServerVariableObject;
    };
  }
  interface ServerVariableObject {
    enum?: string[];
    default: string;
    description?: string;
  }
  interface PathsObject<T extends {} = {}, P extends {} = {}> {
    [pattern: string]: (PathItemObject<T> & P) | undefined;
  }
  enum HttpMethods {
    GET = "get",
    PUT = "put",
    POST = "post",
    DELETE = "delete",
    OPTIONS = "options",
    HEAD = "head",
    PATCH = "patch",
    TRACE = "trace"
  }
  type PathItemObject<T extends {} = {}> = {
    $ref?: string;
    summary?: string;
    description?: string;
    servers?: ServerObject[];
    parameters?: (ReferenceObject | ParameterObject)[];
  } & { [method in HttpMethods]?: OperationObject<T>; };
  type OperationObject<T extends {} = {}> = {
    tags?: string[];
    summary?: string;
    description?: string;
    externalDocs?: ExternalDocumentationObject;
    operationId?: string;
    parameters?: (ReferenceObject | ParameterObject)[];
    requestBody?: ReferenceObject | RequestBodyObject;
    responses: ResponsesObject;
    callbacks?: {
      [callback: string]: ReferenceObject | CallbackObject;
    };
    deprecated?: boolean;
    security?: SecurityRequirementObject[];
    servers?: ServerObject[];
  } & T;
  interface ExternalDocumentationObject {
    description?: string;
    url: string;
  }
  interface ParameterObject extends ParameterBaseObject {
    name: string;
    in: string;
  }
  interface HeaderObject extends ParameterBaseObject {}
  interface ParameterBaseObject {
    description?: string;
    required?: boolean;
    deprecated?: boolean;
    allowEmptyValue?: boolean;
    style?: string;
    explode?: boolean;
    allowReserved?: boolean;
    schema?: ReferenceObject | SchemaObject;
    example?: any;
    examples?: {
      [media: string]: ReferenceObject | ExampleObject;
    };
    content?: {
      [media: string]: MediaTypeObject;
    };
  }
  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
  type ArraySchemaObjectType = 'array';
  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
  interface ArraySchemaObject extends BaseSchemaObject {
    type: ArraySchemaObjectType;
    items: ReferenceObject | SchemaObject;
  }
  interface NonArraySchemaObject extends BaseSchemaObject {
    type?: NonArraySchemaObjectType;
  }
  interface BaseSchemaObject {
    title?: string;
    description?: string;
    format?: string;
    default?: any;
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: boolean;
    minimum?: number;
    exclusiveMinimum?: boolean;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    additionalProperties?: boolean | ReferenceObject | SchemaObject;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    maxProperties?: number;
    minProperties?: number;
    required?: string[];
    enum?: any[];
    properties?: {
      [name: string]: ReferenceObject | SchemaObject;
    };
    allOf?: (ReferenceObject | SchemaObject)[];
    oneOf?: (ReferenceObject | SchemaObject)[];
    anyOf?: (ReferenceObject | SchemaObject)[];
    not?: ReferenceObject | SchemaObject;
    nullable?: boolean;
    discriminator?: DiscriminatorObject;
    readOnly?: boolean;
    writeOnly?: boolean;
    xml?: XMLObject;
    externalDocs?: ExternalDocumentationObject;
    example?: any;
    deprecated?: boolean;
  }
  interface DiscriminatorObject {
    propertyName: string;
    mapping?: {
      [value: string]: string;
    };
  }
  interface XMLObject {
    name?: string;
    namespace?: string;
    prefix?: string;
    attribute?: boolean;
    wrapped?: boolean;
  }
  interface ReferenceObject {
    $ref: string;
  }
  interface ExampleObject {
    summary?: string;
    description?: string;
    value?: any;
    externalValue?: string;
  }
  interface MediaTypeObject {
    schema?: ReferenceObject | SchemaObject;
    example?: any;
    examples?: {
      [media: string]: ReferenceObject | ExampleObject;
    };
    encoding?: {
      [media: string]: EncodingObject;
    };
  }
  interface EncodingObject {
    contentType?: string;
    headers?: {
      [header: string]: ReferenceObject | HeaderObject;
    };
    style?: string;
    explode?: boolean;
    allowReserved?: boolean;
  }
  interface RequestBodyObject {
    description?: string;
    content: {
      [media: string]: MediaTypeObject;
    };
    required?: boolean;
  }
  interface ResponsesObject {
    [code: string]: ReferenceObject | ResponseObject;
  }
  interface ResponseObject {
    description: string;
    headers?: {
      [header: string]: ReferenceObject | HeaderObject;
    };
    content?: {
      [media: string]: MediaTypeObject;
    };
    links?: {
      [link: string]: ReferenceObject | LinkObject;
    };
  }
  interface LinkObject {
    operationRef?: string;
    operationId?: string;
    parameters?: {
      [parameter: string]: any;
    };
    requestBody?: any;
    description?: string;
    server?: ServerObject;
  }
  interface CallbackObject {
    [url: string]: PathItemObject;
  }
  interface SecurityRequirementObject {
    [name: string]: string[];
  }
  interface ComponentsObject {
    schemas?: {
      [key: string]: ReferenceObject | SchemaObject;
    };
    responses?: {
      [key: string]: ReferenceObject | ResponseObject;
    };
    parameters?: {
      [key: string]: ReferenceObject | ParameterObject;
    };
    examples?: {
      [key: string]: ReferenceObject | ExampleObject;
    };
    requestBodies?: {
      [key: string]: ReferenceObject | RequestBodyObject;
    };
    headers?: {
      [key: string]: ReferenceObject | HeaderObject;
    };
    securitySchemes?: {
      [key: string]: ReferenceObject | SecuritySchemeObject;
    };
    links?: {
      [key: string]: ReferenceObject | LinkObject;
    };
    callbacks?: {
      [key: string]: ReferenceObject | CallbackObject;
    };
  }
  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
  interface HttpSecurityScheme {
    type: 'http';
    description?: string;
    scheme: string;
    bearerFormat?: string;
  }
  interface ApiKeySecurityScheme {
    type: 'apiKey';
    description?: string;
    name: string;
    in: string;
  }
  interface OAuth2SecurityScheme {
    type: 'oauth2';
    description?: string;
    flows: {
      implicit?: {
        authorizationUrl: string;
        refreshUrl?: string;
        scopes: {
          [scope: string]: string;
        };
      };
      password?: {
        tokenUrl: string;
        refreshUrl?: string;
        scopes: {
          [scope: string]: string;
        };
      };
      clientCredentials?: {
        tokenUrl: string;
        refreshUrl?: string;
        scopes: {
          [scope: string]: string;
        };
      };
      authorizationCode?: {
        authorizationUrl: string;
        tokenUrl: string;
        refreshUrl?: string;
        scopes: {
          [scope: string]: string;
        };
      };
    };
  }
  interface OpenIdSecurityScheme {
    type: 'openIdConnect';
    description?: string;
    openIdConnectUrl: string;
  }
  interface TagObject {
    name: string;
    description?: string;
    externalDocs?: ExternalDocumentationObject;
  }
}
declare namespace OpenAPIV2 {
  interface Document<T extends {} = {}> {
    basePath?: string;
    consumes?: MimeTypes;
    definitions?: DefinitionsObject;
    externalDocs?: ExternalDocumentationObject;
    host?: string;
    info: InfoObject;
    parameters?: ParametersDefinitionsObject;
    paths: PathsObject<T>;
    produces?: MimeTypes;
    responses?: ResponsesDefinitionsObject;
    schemes?: string[];
    security?: SecurityRequirementObject[];
    securityDefinitions?: SecurityDefinitionsObject;
    swagger: string;
    tags?: TagObject[];
    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
    'x-express-openapi-validation-strict'?: boolean;
  }
  interface TagObject {
    name: string;
    description?: string;
    externalDocs?: ExternalDocumentationObject;
  }
  interface SecuritySchemeObjectBase {
    type: 'basic' | 'apiKey' | 'oauth2';
    description?: string;
  }
  interface SecuritySchemeBasic extends SecuritySchemeObjectBase {
    type: 'basic';
  }
  interface SecuritySchemeApiKey extends SecuritySchemeObjectBase {
    type: 'apiKey';
    name: string;
    in: string;
  }
  type SecuritySchemeOauth2 = SecuritySchemeOauth2Implicit | SecuritySchemeOauth2AccessCode | SecuritySchemeOauth2Password | SecuritySchemeOauth2Application;
  interface ScopesObject {
    [index: string]: any;
  }
  interface SecuritySchemeOauth2Base extends SecuritySchemeObjectBase {
    type: 'oauth2';
    flow: 'implicit' | 'password' | 'application' | 'accessCode';
    scopes: ScopesObject;
  }
  interface SecuritySchemeOauth2Implicit extends SecuritySchemeOauth2Base {
    flow: 'implicit';
    authorizationUrl: string;
  }
  interface SecuritySchemeOauth2AccessCode extends SecuritySchemeOauth2Base {
    flow: 'accessCode';
    authorizationUrl: string;
    tokenUrl: string;
  }
  interface SecuritySchemeOauth2Password extends SecuritySchemeOauth2Base {
    flow: 'password';
    tokenUrl: string;
  }
  interface SecuritySchemeOauth2Application extends SecuritySchemeOauth2Base {
    flow: 'application';
    tokenUrl: string;
  }
  type SecuritySchemeObject = SecuritySchemeBasic | SecuritySchemeApiKey | SecuritySchemeOauth2;
  interface SecurityDefinitionsObject {
    [index: string]: SecuritySchemeObject;
  }
  interface SecurityRequirementObject {
    [index: string]: string[];
  }
  interface ReferenceObject {
    $ref: string;
  }
  type Response = ResponseObject | ReferenceObject;
  interface ResponsesDefinitionsObject {
    [index: string]: ResponseObject;
  }
  type Schema = SchemaObject | ReferenceObject;
  interface ResponseObject {
    description: string;
    schema?: Schema;
    headers?: HeadersObject;
    examples?: ExampleObject;
  }
  interface HeadersObject {
    [index: string]: HeaderObject;
  }
  interface HeaderObject extends ItemsObject {
    description?: string;
  }
  interface ExampleObject {
    [index: string]: any;
  }
  interface ResponseObject {
    description: string;
    schema?: Schema;
    headers?: HeadersObject;
    examples?: ExampleObject;
  }
  type OperationObject<T extends {} = {}> = {
    tags?: string[];
    summary?: string;
    description?: string;
    externalDocs?: ExternalDocumentationObject;
    operationId?: string;
    consumes?: MimeTypes;
    produces?: MimeTypes;
    parameters?: Parameters;
    responses: ResponsesObject;
    schemes?: string[];
    deprecated?: boolean;
    security?: SecurityRequirementObject[];
  } & T;
  interface ResponsesObject {
    [index: string]: Response | undefined;
    default?: Response;
  }
  type Parameters = (ReferenceObject | Parameter)[];
  type Parameter = InBodyParameterObject | GeneralParameterObject;
  interface InBodyParameterObject extends ParameterObject {
    schema: Schema;
  }
  interface GeneralParameterObject extends ParameterObject, ItemsObject {
    allowEmptyValue?: boolean;
  }
  enum HttpMethods {
    GET = "get",
    PUT = "put",
    POST = "post",
    DELETE = "delete",
    OPTIONS = "options",
    HEAD = "head",
    PATCH = "patch"
  }
  type PathItemObject<T extends {} = {}> = {
    $ref?: string;
    parameters?: Parameters;
  } & { [method in HttpMethods]?: OperationObject<T>; };
  interface PathsObject<T extends {} = {}> {
    [index: string]: PathItemObject<T>;
  }
  interface ParametersDefinitionsObject {
    [index: string]: ParameterObject;
  }
  interface ParameterObject {
    name: string;
    in: string;
    description?: string;
    required?: boolean;
    [index: string]: any;
  }
  type MimeTypes = string[];
  interface DefinitionsObject {
    [index: string]: SchemaObject;
  }
  interface SchemaObject extends IJsonSchema {
    [index: string]: any;
    discriminator?: string;
    readOnly?: boolean;
    xml?: XMLObject;
    externalDocs?: ExternalDocumentationObject;
    example?: any;
    default?: any;
    items?: ItemsObject | ReferenceObject;
    properties?: {
      [name: string]: SchemaObject;
    };
  }
  interface ExternalDocumentationObject {
    [index: string]: any;
    description?: string;
    url: string;
  }
  interface ItemsObject {
    type: string;
    format?: string;
    items?: ItemsObject | ReferenceObject;
    collectionFormat?: string;
    default?: any;
    maximum?: number;
    exclusiveMaximum?: boolean;
    minimum?: number;
    exclusiveMinimum?: boolean;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    enum?: any[];
    multipleOf?: number;
    $ref?: string;
  }
  interface XMLObject {
    [index: string]: any;
    name?: string;
    namespace?: string;
    prefix?: string;
    attribute?: boolean;
    wrapped?: boolean;
  }
  interface InfoObject {
    title: string;
    description?: string;
    termsOfService?: string;
    contact?: ContactObject;
    license?: LicenseObject;
    version: string;
  }
  interface ContactObject {
    name?: string;
    url?: string;
    email?: string;
  }
  interface LicenseObject {
    name: string;
    url?: string;
  }
}
interface IJsonSchema {
  id?: string;
  $schema?: string;
  title?: string;
  description?: string;
  multipleOf?: number;
  maximum?: number;
  exclusiveMaximum?: boolean;
  minimum?: number;
  exclusiveMinimum?: boolean;
  maxLength?: number;
  minLength?: number;
  pattern?: string;
  additionalItems?: boolean | IJsonSchema;
  items?: IJsonSchema | IJsonSchema[];
  maxItems?: number;
  minItems?: number;
  uniqueItems?: boolean;
  maxProperties?: number;
  minProperties?: number;
  required?: string[];
  additionalProperties?: boolean | IJsonSchema;
  definitions?: {
    [name: string]: IJsonSchema;
  };
  properties?: {
    [name: string]: IJsonSchema;
  };
  patternProperties?: {
    [name: string]: IJsonSchema;
  };
  dependencies?: {
    [name: string]: IJsonSchema | string[];
  };
  enum?: any[];
  type?: string | string[];
  allOf?: IJsonSchema[];
  anyOf?: IJsonSchema[];
  oneOf?: IJsonSchema[];
  not?: IJsonSchema;
  $ref?: string;
}
//#endregion
//#region src/types/generate-options.d.ts
/**
 * 生成全局选项
 */
interface GenerateOptions {
  // 网关地址
  gateway: string;
  // OpenAPI地址
  openapi: string;
  // 输出目录
  output: string;
  // 输出Model路径
  exportModels: boolean;
  // 开启日志输出
  logger?: boolean;
  // 强制清空输出目录(跳过 .generated 标记检查,用于旧项目迁移)
  forceClear?: boolean;
  // 输出Model路径
  exportServices?: {
    serviceResolve?: (options: {
      path: string;
      method: string;
      object: OpenAPIV2.OperationObject | OpenAPIV3.OperationObject;
      tags: OpenAPIV2.TagObject[];
    }) => string | string[];
    operationResolve?: (options: {
      path: string;
      method: string;
      object: OpenAPIV2.OperationObject | OpenAPIV3.OperationObject;
    }) => string;
    excludeQueryParams?: string[];
    responseType?: 'promise' | 'observable';
  };
  // 多应用列表
  applications?: Record<string, ApplicationConfig>;
  // 追加service
  appendService?: boolean;
}
type ApplicationConfig = {
  key: string;
  openapi: string;
} | string;
/**
 * 生成应用选项
 */
type GenerateApplicationOptions = Pick<GenerateOptions, 'exportModels' | 'output' | 'forceClear'> & {
  // 服务名称
  name?: string;
  // 应用名称
  application?: string;
  // OPENAPI地址
  input: string;
};
//#endregion
//#region src/download/index.d.ts
declare class Download {
  static options: GenerateOptions;
  static startup(options: GenerateOptions): Promise<void>;
  static downloadOpenAPIFile(option: GenerateApplicationOptions): Promise<{
    size: number;
    duration: number;
  }>;
}
//#endregion
//#region src/entities/field.d.ts
declare class Field {
  name: string;
  required: boolean;
  type: string;
  ref?: string;
  enums?: string[];
  description?: string;
  imports?: string[];
  constructor(name: string, required: boolean);
}
//#endregion
//#region src/entities/model.d.ts
declare class Model {
  name: string;
  fields: Field[];
  imports: string[];
  constructor(name: string);
}
//#endregion
//#region src/entities/operation-parameter.d.ts
declare class OperationParameter {
  in: 'path' | 'query' | 'body';
  name: string;
  type: string;
  ref?: string;
  enums?: string[];
  description?: string;
  required?: boolean;
  imports: string[];
  mediaType?: string;
}
//#endregion
//#region src/entities/operation.d.ts
declare class Operation {
  name: string;
  method: string;
  path: string;
  description?: string;
  responseRef: string;
  responseType: 'promise' | 'observable';
  parametersPath: OperationParameter[];
  parametersQuery: OperationParameter[];
  parametersBody?: OperationParameter;
  imports: string[];
  constructor(name: string, method: string, path: string);
}
//#endregion
//#region src/entities/service.d.ts
declare class Service {
  constructor(name: string);
  name: string;
  application?: string;
  imports: string[];
  operations: Operation[];
  responseType: 'promise' | 'observable';
}
//#endregion
//#region src/types/generate-client.d.ts
interface GenerateClient {
  // 模型列表
  models: Model[];
  // 服务列表
  services: Service[];
}
//#endregion
//#region src/config/enum.config.d.ts
declare enum OpenAPIVersion {
  V2 = 2,
  V3 = 3
}
//#endregion
//#region src/generate/index.d.ts
type UnknownVersionDocument = OpenAPIV3.Document & OpenAPIV2.Document;
declare class Generate {
  static options: GenerateOptions;
  /**
   * 生成入口
   * @param options
   * @returns Promise<void>
   */
  static startup(options: GenerateOptions): Promise<void>;
  static getApiDocument(input: string): Promise<UnknownVersionDocument>;
  /**
   * 生成应用
   */
  static generateApplicationClient(options: GenerateApplicationOptions): Promise<GenerateClient>;
  /**
   * 生成对象信息
   * @param document
   * @param version
   * @returns GenerateClient
   */
  static generateClient(document: UnknownVersionDocument, version: OpenAPIVersion): GenerateClient;
  /**
   * 写入Client对象
   * @param client
   * @param options
   */
  static writeClient(client: GenerateClient, options: GenerateApplicationOptions): void;
}
//#endregion
//#region src/define-config.d.ts
declare function defineConfig(config: GenerateOptions): GenerateOptions;
//#endregion
//#region src/load-config.d.ts
/**
 * 加载 request-generate 配置文件
 *
 * 通过 tsx 的 tsImport 加载 .ts/.mts/.cts 配置,使其在普通 Node 进程(如 Vite 插件)中也能工作;
 * .js/.mjs/.cjs 则直接使用原生 import。
 *
 * @param filePath 通过 --config 指定的路径(可选)
 * @param cwd 解析配置文件的基准目录(默认 process.cwd())
 * @returns `{ default: 配置对象 }`,配置对象统一位于 default 字段
 */
declare function loadConfigFile(filePath?: string, cwd?: string): Promise<{
  default: GenerateOptions;
}>;
//#endregion
//#region src/index.d.ts
declare const generate: typeof Generate.startup;
declare const download: typeof Download.startup;
//#endregion
export { type GenerateOptions, defineConfig, download, generate, loadConfigFile };