OpenApi

declare const annotations: (options: {
  readonly deprecated?: boolean;
  readonly description?: string;
  readonly exclude?: boolean;
  readonly externalDocs?: OpenAPISpecExternalDocs;
  readonly format?: string;
  readonly identifier?: string;
  readonly license?: OpenAPISpecLicense;
  readonly override?: Record<string, unknown>;
  readonly servers?: ReadonlyArray<OpenAPISpecServer>;
  readonly summary?: string;
  readonly title?: string;
  readonly transform?: (openApiSpec: Record<string, any>) => Record<string, any>;
  readonly version?: string;
}) => Context.Context<never>

declare class Deprecated extends any {
  constructor();
}

declare class Description extends any {
  constructor();
}

declare class Exclude extends any {
  constructor();
}

declare class ExternalDocs extends any {
  constructor();
}

declare class Format extends any {
  constructor();
}

declare class Identifier extends any {
  constructor();
}

declare class License extends any {
  constructor();
}

declare class Override extends any {
  constructor();
}

declare class Servers extends any {
  constructor();
}

declare class Summary extends any {
  constructor();
}

declare class Title extends any {
  constructor();
}

declare class Transform extends any {
  constructor();
}

declare class Version extends any {
  constructor();
}

declare function fromApi<Id extends string, Groups extends Any, E, R>(api: HttpApi<Id, Groups, E, R>, options?: {
  readonly additionalPropertiesStrategy?: AdditionalPropertiesStrategy;
}): OpenAPISpec

type AdditionalPropertiesStrategy = "allow" | "strict"

interface OpenAPIApiKeySecurityScheme {
  description?: string;
  in: "header" | "query" | "cookie";
  name: string;
  readonly type: "apiKey";
}

interface OpenAPIComponents {
  schemas: Record<string, JsonSchema.JsonSchema>;
  securitySchemes: Record<string, OpenAPISecurityScheme>;
}

interface OpenAPIHTTPSecurityScheme {
  bearerFormat?: string;
  description?: string;
  scheme: string;
  readonly type: "http";
}

type OpenAPISecurityRequirement = Record<string, Array<string>>

type OpenAPISecurityScheme = OpenAPIHTTPSecurityScheme | OpenAPIApiKeySecurityScheme

interface OpenAPISpec {
  components: OpenAPIComponents;
  info: OpenAPISpecInfo;
  openapi: "3.1.0";
  paths: OpenAPISpecPaths;
  security: Array<OpenAPISecurityRequirement>;
  servers?: Array<OpenAPISpecServer>;
  tags: Array<OpenAPISpecTag>;
}

type OpenApiSpecContent = { [K in OpenApiSpecContentType]: OpenApiSpecMediaType }

type OpenApiSpecContentType = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain"

interface OpenAPISpecExternalDocs {
  description?: string;
  url: string;
}

interface OpenAPISpecInfo {
  description?: string;
  license?: OpenAPISpecLicense;
  summary?: string;
  title: string;
  version: string;
}

interface OpenAPISpecLicense {
  name: string;
  url?: string;
}

interface OpenApiSpecMediaType {
  schema: JsonSchema;
}

type OpenAPISpecMethodName = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"

interface OpenAPISpecOperation {
  deprecated?: boolean;
  description?: string;
  externalDocs?: OpenAPISpecExternalDocs;
  operationId: string;
  parameters: Array<OpenAPISpecParameter>;
  requestBody?: OpenAPISpecRequestBody;
  responses: OpenAPISpecResponses;
  security: Array<OpenAPISecurityRequirement>;
  summary?: string;
  tags: [string, ...Array<string>];
}

interface OpenAPISpecParameter {
  description?: string;
  in: "header" | "query" | "cookie" | "path";
  name: string;
  required: boolean;
  schema: JsonSchema;
}

type OpenAPISpecPathItem = { [K in OpenAPISpecMethodName]: OpenAPISpecOperation }

type OpenAPISpecPaths = Record<string, OpenAPISpecPathItem>

interface OpenAPISpecRequestBody {
  content: OpenApiSpecContent;
  required: true;
}

interface OpenApiSpecResponse {
  content?: OpenApiSpecContent;
  description: string;
}

type OpenAPISpecResponses = Record<number, OpenApiSpecResponse>

interface OpenAPISpecServer {
  description?: string;
  url: string;
  variables?: Record<string, OpenAPISpecServerVariable>;
}

interface OpenAPISpecServerVariable {
  default: string;
  description?: string;
  enum?: [string, ...Array<string>];
}

interface OpenAPISpecTag {
  description?: string;
  externalDocs?: OpenAPISpecExternalDocs;
  name: string;
}