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;
}