import { RouteMeta } from '@novice1/routing';
import { DocGenerator, ProcessedRoute } from '../commons';
import { SchemaObject, SecuritySchemeObject, ReferenceObject, RequestBodyObject, ResponseObject, TagObject, ExampleObject, ComponentsObject, ParameterObject, LinkObject, HeaderObject, InfoObject, LicenseObject, ContactObject, ExternalDocObject, ServerObject, SecurityRequirementObject, OpenAPISupportedVersion } from './openapi/definitions';
import { OpenAPIHelperInterface } from './openapi/helpers/interfaces';
import { BaseOpenAPIAuthUtil, BaseAuthUtil, BaseContextAuthUtil } from '../utils/auth/baseAuthUtils';
import { BaseOpenAPIResponseUtil, BaseResponseUtil } from '../utils/responses/baseResponseUtils';
export interface OpenAPIResult {
    openapi: OpenAPISupportedVersion;
    info: InfoObject;
    servers: ServerObject[];
    components: ComponentsObject;
    paths: Record<string, Record<string, unknown>>;
    security?: SecurityRequirementObject[];
    tags: TagObject[];
    externalDocs?: ExternalDocObject;
    [key: string]: unknown;
}
export declare enum GenerateComponentsRule {
    always = "always",
    ifUndefined = "ifUndefined",
    never = "never"
}
export type OpenAPIHelperClass = {
    new (args: {
        isRoot?: boolean;
        value: unknown;
    }): OpenAPIHelperInterface;
};
export type OpenAPIOptions = {
    version?: OpenAPISupportedVersion;
    helperClass?: OpenAPIHelperClass;
    helperSchemaProperty?: string;
};
/**
 * OpenAPI doc generator.
 *
 * {@include ../../typedocIncludes/openapi.md}
 *
 *
 * @note For now it is not possible to only
 * send files outside of object property (multipart).
 * Well, at least not tried yet
 * but it definitely doesn't work with alternatives.
 */
export declare class OpenAPI implements DocGenerator {
    #private;
    constructor(options?: OpenAPIOptions);
    setGenerateComponentsRule(v: GenerateComponentsRule): OpenAPI;
    getGenerateComponentsRule(): GenerateComponentsRule;
    setResponsesProperty(v: string): OpenAPI;
    getResponsesProperty(): string | undefined;
    setConsumes(consumes: string[]): OpenAPI;
    getConsumes(): string[];
    setCallbacks(callbacks: Record<string, unknown>): OpenAPI;
    getCallbacks(): Record<string, unknown> | undefined;
    removeCallback(name: string): unknown;
    hasCallback(name: string): boolean;
    addCallback(name: string, callback: unknown): OpenAPI;
    /**
     *
     * @returns removed callbacks
     */
    cleanupCallbacks(): Record<string, unknown>;
    setLinks(links: Record<string, ReferenceObject | LinkObject>): OpenAPI;
    getLinks(): Record<string, ReferenceObject | LinkObject> | undefined;
    removeLink(name: string): ReferenceObject | LinkObject | undefined;
    hasLink(name: string): boolean;
    addLink(name: string, link: ReferenceObject | LinkObject): OpenAPI;
    /**
     *
     * @returns removed links
     */
    cleanupLinks(): Record<string, ReferenceObject | LinkObject>;
    setExamples(examples: Record<string, ReferenceObject | ExampleObject>): OpenAPI;
    getExamples(): Record<string, ReferenceObject | ExampleObject> | undefined;
    removeExample(name: string): ReferenceObject | ExampleObject | undefined;
    hasExample(name: string): boolean;
    addExample(name: string, example: ReferenceObject | ExampleObject): OpenAPI;
    /**
     *
     * @returns removed examples
     */
    cleanupExamples(): Record<string, ReferenceObject | ExampleObject>;
    setSchemas(schemas: Record<string, SchemaObject | ReferenceObject>): OpenAPI;
    getSchemas(): Record<string, SchemaObject | ReferenceObject> | undefined;
    removeSchema(name: string): SchemaObject | ReferenceObject | undefined;
    hasSchema(name: string): boolean;
    addSchema(name: string, schema: SchemaObject | ReferenceObject): OpenAPI;
    /**
     *
     * @returns removed schemas
     */
    cleanupSchemas(): Record<string, SchemaObject | ReferenceObject>;
    setHeaders(headers: Record<string, ReferenceObject | HeaderObject>): OpenAPI;
    getHeaders(): Record<string, ReferenceObject | HeaderObject> | undefined;
    removeHeader(name: string): ReferenceObject | HeaderObject | undefined;
    hasHeader(name: string): boolean;
    addHeader(name: string, header: ReferenceObject | HeaderObject): OpenAPI;
    /**
     *
     * @returns removed headers
     */
    cleanupHeaders(): Record<string, ReferenceObject | HeaderObject>;
    setParameters(parameters: Record<string, ReferenceObject | ParameterObject>): OpenAPI;
    getParameters(): Record<string, ReferenceObject | ParameterObject> | undefined;
    removeParameter(name: string): ReferenceObject | ParameterObject | undefined;
    hasParameter(name: string): boolean;
    addParameter(name: string, param: ParameterObject): OpenAPI;
    /**
     *
     * @returns removed parameters
     */
    cleanupParameters(): Record<string, ReferenceObject | ParameterObject>;
    setRequestBodies(requestBodies: Record<string, ReferenceObject | RequestBodyObject>): OpenAPI;
    getRequestBodies(): Record<string, ReferenceObject | RequestBodyObject> | undefined;
    removeRequestBody(name: string): ReferenceObject | RequestBodyObject | undefined;
    hasRequestBody(name: string): boolean;
    addRequestBody(name: string, requestBody: ReferenceObject | RequestBodyObject): OpenAPI;
    /**
     *
     * @returns removed requestBodies
     */
    cleanupRequestBodies(): Record<string, ReferenceObject | RequestBodyObject>;
    setResponses(responses: Record<string, ReferenceObject | ResponseObject>): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.setResponses.md}
     */
    setResponses(responses: BaseOpenAPIResponseUtil | BaseResponseUtil): OpenAPI;
    getResponses(): Record<string, ReferenceObject | ResponseObject> | undefined;
    removeResponse(name: string): ReferenceObject | ResponseObject | undefined;
    hasResponse(name: string): boolean;
    /**
     * Example:
     * ```ts
     * openapi.addResponse('200', {
     *    "description": "A simple string response",
     *    "content": {
     *      "text/plain": {
     *        "schema": {
     *          "type": "string",
     *          "example": "whoa!"
     *        }
     *      }
     *    }
     * });
     * ```
     */
    addResponse(name: string, response: ReferenceObject | ResponseObject): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.addResponse.md}
     */
    addResponse(response: BaseOpenAPIResponseUtil | BaseResponseUtil): OpenAPI;
    /**
     *
     * @returns removed responses
     */
    cleanupResponses(): Record<string, ReferenceObject | ResponseObject>;
    /**
     * {@include ../../typedocIncludes/openapi.setSecuritySchemes.1.md}
     */
    setSecuritySchemes(schemes: Record<string, ReferenceObject | SecuritySchemeObject>): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.setSecuritySchemes.2.md}
     */
    setSecuritySchemes(schemes: BaseOpenAPIAuthUtil | BaseAuthUtil): OpenAPI;
    getSecuritySchemes(): Record<string, ReferenceObject | SecuritySchemeObject> | undefined;
    removeSecurityScheme(name: string): ReferenceObject | SecuritySchemeObject | undefined;
    hasSecurityScheme(name: string): boolean;
    /**
     * {@include ../../typedocIncludes/openapi.addSecuritySchemes.1.md}
     */
    addSecurityScheme(name: string, schema: ReferenceObject | SecuritySchemeObject): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.addSecuritySchemes.2.md}
     */
    addSecurityScheme(schema: BaseOpenAPIAuthUtil | BaseAuthUtil): OpenAPI;
    /**
     *
     * @returns removed securitySchemes
     */
    cleanupSecuritySchemes(): Record<string, SecuritySchemeObject | ReferenceObject>;
    setComponents(components: ComponentsObject): OpenAPI;
    getComponents(): ComponentsObject;
    /**
     * remove unused entities (possibly auto-generated) from components:
     * - headers
     * - responses
     * - requestBodies
     * - parameters
     * - schemas
     */
    cleanupComponents(): ComponentsObject;
    setTags(tags: TagObject[]): OpenAPI;
    getTags(): TagObject[];
    removeTag(tagName: string): TagObject | undefined;
    addTag(tag: TagObject): OpenAPI;
    addTags(tags: TagObject): OpenAPI;
    addTags(tags: TagObject[]): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.setDefaultSecurity.1.md}
     */
    setDefaultSecurity(security: BaseOpenAPIAuthUtil | BaseContextAuthUtil | BaseAuthUtil): OpenAPI;
    /**
     *
     */
    setDefaultSecurity(securityObjects: SecurityRequirementObject[]): OpenAPI;
    /**
     * Example:
     * ```ts
     * openapi.setDefaultSecurity({
     *  basicAuth: []
     * });
     * ```
     */
    setDefaultSecurity(securityObject: SecurityRequirementObject): OpenAPI;
    /**
     *
     */
    setDefaultSecurity(security: string[]): OpenAPI;
    /**
     * Example:
     * ```ts
     * openapi.setDefaultSecurity('basicAuth');
     * ```
     */
    setDefaultSecurity(security: string): OpenAPI;
    /**
     * {@include ../../typedocIncludes/openapi.addDefaultSecurity.1.md}
     */
    addDefaultSecurity(security: BaseOpenAPIAuthUtil | BaseContextAuthUtil | BaseAuthUtil): OpenAPI;
    /**
     * Example:
     * ```ts
     * openapi.addDefaultSecurity({
     *  basicAuth: []
     * });
     * ```
     */
    addDefaultSecurity(security: SecurityRequirementObject | string): OpenAPI;
    /**
     * Example:
     * ```ts
     * openapi.addDefaultSecurity({
     *  basicAuth: []
     * });
     * ```
     */
    addDefaultSecurity(security: SecurityRequirementObject): OpenAPI;
    /**
     * Example:
     * ```ts
     * openapi.addDefaultSecurity('basicAuth');
     * ```
     */
    addDefaultSecurity(security: string): OpenAPI;
    getDefaultSecurity(): SecurityRequirementObject[];
    setInfo(info: InfoObject): OpenAPI;
    getInfo(): InfoObject;
    setInfoProperty(prop: string, value: unknown): OpenAPI;
    setTitle(title: string): OpenAPI;
    getTitle(): string;
    setDescription(description: string): OpenAPI;
    getDescription(): string | undefined;
    setTermsOfService(termsOfService: string): OpenAPI;
    getTermsOfService(): string | undefined;
    setVersion(version: string): OpenAPI;
    getVersion(): string;
    setContact(contact: ContactObject): OpenAPI;
    getContact(): ContactObject | undefined;
    setLicense(license: string): OpenAPI;
    setLicense(license: LicenseObject): OpenAPI;
    getLicense(): LicenseObject | undefined;
    setServers(servers: ServerObject[]): OpenAPI;
    setServers(server: ServerObject): OpenAPI;
    getServers(): ServerObject[];
    addServer(server: ServerObject): OpenAPI;
    addServer(url: string): OpenAPI;
    /**
     *
     * OpenAPI.setServers({ url })
     */
    setHost(url: string): OpenAPI;
    setExternalDoc(externalDoc: ExternalDocObject): OpenAPI;
    setExternalDoc(url: string): OpenAPI;
    getExternalDoc(): ExternalDocObject | undefined;
    /**
     * @example
     * ```typescript
     * import routing from '@novice1/routing';
     * import { OpenAPI } from '@novice1/api-doc-generator';
     *
     * const router = routing().post(...);
     * const openapi = new OpenAPI();
     * const routes = openapi.add(router.getMeta());
     * const { path, method, schema } = routes[0];
     * ```
     * @returns The added/updated routes
     */
    add(routes: RouteMeta[]): ProcessedRoute[];
    add(routes: RouteMeta): ProcessedRoute[];
    remove(path: string, method?: string): ProcessedRoute[];
    /**
     * remove all routes
     * @returns The removed routes
     */
    removeAll(): ProcessedRoute[];
    private _getResponsesSchema;
    private _add;
    private _formatResponses;
    private _formatParameters;
    private _pushPathParameters;
    /**
     *
     * @param location path, query, header or cookie
     * @param helper
     * @param defaultParameterObject
     * @returns
     */
    private _createParameterObject;
    private _formatRequestBody;
    private _pushRequestBody;
    /**
     * create non-alternative schema
     * @param helper
     * @param parentProp used for required children/items
     * @param name used for required children
     * @param format used for 'binary' format
     * @returns
     */
    private _createBasicSchema;
    /**
     *
     * @param helper
     * @param parentProp used for required children/items
     * @param name used for required children
     * @param format used for 'binary' format
     * @returns
     */
    private _createSchema;
    /**
     *
     * @param helper
     * @param parentProp used for required children/items
     * @param name used for required children
     * @param format used for 'binary' format
     * @returns
     */
    private _createSchemaObject;
    private _createAlternativeSchema;
    private _createAlternativeSchemaObject;
    private _fillArraySchemaObject;
    private _fillObjectSchemaObject;
    private _autoSchemaObjectToRef;
    private _autoParameterObjectToRef;
    private _autoRequestBodyObjectToRef;
    private _getLocalRef;
    private _getRemoteRef;
    private _localRefToEntityName;
    result(): OpenAPIResult;
}