import type { RequestBodyExamples } from './operation/get-requestbody-examples';
import type { CallbackExamples } from './operation/get-callback-examples';
import type { ResponseExamples } from './operation/get-response-examples';
import * as RMOAS from './rmoas.types';
declare type SecurityType = 'Basic' | 'Bearer' | 'Query' | 'Header' | 'Cookie' | 'OAuth2' | 'http' | 'apiKey';
export default class Operation {
    /**
     * Schema of the operation from the API Definition.
     */
    schema: RMOAS.OperationObject;
    /**
     * OpenAPI API Definition that this operation originated from.
     */
    api: RMOAS.OASDocument;
    /**
     * Path that this operation is targeted towards.
     */
    path: string;
    /**
     * HTTP Method that this operation is targeted towards.
     */
    method: RMOAS.HttpMethods;
    /**
     * The primary Content Type that this operation accepts.
     */
    contentType: string;
    /**
     * Request body examples for this operation.
     */
    requestBodyExamples: RequestBodyExamples;
    /**
     * Response examples for this operation.
     */
    responseExamples: ResponseExamples;
    /**
     * Callback examples for this operation (if it has callbacks).
     */
    callbackExamples: CallbackExamples;
    /**
     * Flattened out arrays of both request and response headers that are utilized on this operation.
     */
    headers: {
        request: string[];
        response: string[];
    };
    constructor(api: RMOAS.OASDocument, path: string, method: RMOAS.HttpMethods, operation: RMOAS.OperationObject);
    getSummary(): string;
    getDescription(): string;
    getContentType(): string;
    isFormUrlEncoded(): boolean;
    isMultipart(): boolean;
    isJson(): boolean;
    isXml(): boolean;
    /**
     * Returns an array of all security requirements associated wtih this operation. If none are
     * defined at the operation level, the securities for the entire API definition are returned
     * (with an empty array as a final fallback).
     *
     */
    getSecurity(): RMOAS.SecurityRequirementObject[];
    /**
     * Retrieve a collection of grouped security schemes. The inner array determines and-grouped
     * security schemes, the outer array determines or-groups.
     *
     * @see {@link https://swagger.io/docs/specification/authentication/#multiple}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#security-requirement-object}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#securityRequirementObject}
     * @param filterInvalid Optional flag that, when set to `true`, filters out invalid/nonexistent
     *    security schemes, rather than returning `false`.
     */
    getSecurityWithTypes(filterInvalid?: boolean): (false | (false | {
        security: RMOAS.KeyedSecuritySchemeObject;
        type: SecurityType;
    })[])[];
    /**
     * Retrieve an object where the keys are unique scheme types, and the values are arrays
     * containing each security scheme of that type.
     *
     */
    prepareSecurity(): Record<SecurityType, RMOAS.KeyedSecuritySchemeObject[]>;
    getHeaders(): Operation['headers'];
    /**
     * Determine if the operation has an operation present in its schema. Note that if one is present
     * in the schema but is an empty string then this will return false.
     *
     */
    hasOperationId(): boolean;
    /**
     * Get an `operationId` for this operation. If one is not present (it's not required by the spec!)
     * a hash of the path and method will be returned instead.
     *
     * @param opts
     * @param opts.camelCase Generate a JS method-friendly operation ID when one isn't present.
     */
    getOperationId(opts?: {
        camelCase: boolean;
    }): string;
    /**
     * Return an array of all tags, and their metadata, that exist on this operation.
     *
     */
    getTags(): RMOAS.TagObject[];
    /**
     * Return is the operation is flagged as `deprecated` or not.
     *
     */
    isDeprecated(): boolean;
    /**
     * Determine if the operation has any (non-request body) parameters.
     *
     */
    hasParameters(): boolean;
    /**
     * Return the parameters (non-request body) on the operation.
     *
     */
    getParameters(): RMOAS.ParameterObject[];
    /**
     * Determine if this operation has any required parameters.
     *
     */
    hasRequiredParameters(): boolean;
    /**
     * Convert the operation into an array of JSON Schema schemas for each available type of
     * parameter available on the operation.
     *
     * @param opts
     * @param opts.globalDefaults Contains an object of user defined schema defaults.
     * @param opts.mergeIntoBodyAndMetadata If you want the output to be two objects: body (contains
     *    `body` and `formData` JSON Schema) and metadata (contains `path`, `query`, `cookie`, and
     *    `header`).
     * @param opts.retainDeprecatedProperties If you wish to **not** split out deprecated properties
     *    into a separate `deprecatedProps` object.
     */
    getParametersAsJsonSchema(opts?: {
        globalDefaults?: Record<string, unknown>;
        mergeIntoBodyAndMetadata?: boolean;
        retainDeprecatedProperties?: boolean;
    }): import("./operation/get-parameters-as-json-schema").SchemaWrapper[];
    /**
     * Get a single response for this status code, formatted as JSON schema.
     *
     * @param statusCode
     */
    getResponseAsJsonSchema(statusCode: string | number): {
        type: string | string[];
        schema: RMOAS.SchemaObject;
        label: string;
        description?: string;
    }[];
    /**
     * Get an array of all valid response status codes for this operation.
     *
     */
    getResponseStatusCodes(): string[];
    /**
     * Determine if the operation has any request bodies.
     *
     */
    hasRequestBody(): boolean;
    /**
     * Retrieve the list of all available media types that the operations request body can accept.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#mediaTypeObject}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#mediaTypeObject}
     */
    getRequestBodyMediaTypes(): string[];
    /**
     * Determine if this operation has a required request body.
     *
     */
    hasRequiredRequestBody(): boolean;
    /**
     * Retrieve a specific request body content schema off this operation.
     *
     * If no media type is supplied this will return either the first available JSON-like request
     * body, or the first available if there are no JSON-like media types present. When this return
     * comes back it's in the form of an array with the first key being the selected media type,
     * followed by the media type object in question.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#mediaTypeObject}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#mediaTypeObject}
     * @param mediaType Specific request body media type to retrieve if present.
     */
    getRequestBody(mediaType?: string): false | RMOAS.MediaTypeObject | [string, RMOAS.MediaTypeObject];
    /**
     * Retrieve an array of request body examples that this operation has.
     *
     */
    getRequestBodyExamples(): RequestBodyExamples;
    /**
     * Return a specific response out of the operation by a given HTTP status code.
     *
     * @param statusCode
     */
    getResponseByStatusCode(statusCode: string | number): boolean | RMOAS.ResponseObject;
    /**
     * Retrieve an array of response examples that this operation has.
     *
     */
    getResponseExamples(): ResponseExamples;
    /**
     * Determine if the operation has callbacks.
     *
     */
    hasCallbacks(): boolean;
    /**
     * Retrieve a specific callback.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#callbackObject}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callbackObject}
     * @param identifier Callback identifier to look for.
     * @param expression Callback expression to look for.
     * @param method HTTP Method on the callback to look for.
     */
    getCallback(identifier: string, expression: string, method: RMOAS.HttpMethods): false | Callback;
    /**
     * Retrieve an array of operations created from each callback.
     *
     */
    getCallbacks(): false | (false | Callback)[];
    /**
     * Retrieve an array of callback examples that this operation has.
     *
     */
    getCallbackExamples(): CallbackExamples;
    /**
     * Determine if a given a custom specification extension exists within the operation.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specificationExtensions}
     * @param extension Specification extension to lookup.
     */
    hasExtension(extension: string): boolean;
    /**
     * Retrieve a custom specification extension off of the operation.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specificationExtensions}
     * @param extension Specification extension to lookup.
     */
    getExtension(extension: string): unknown;
}
export declare class Callback extends Operation {
    /**
     * The identifier that this callback is set to.
     */
    identifier: string;
    /**
     * The parent path item object that this Callback exists within.
     */
    parentSchema: RMOAS.PathItemObject;
    constructor(oas: RMOAS.OASDocument, path: string, method: RMOAS.HttpMethods, operation: RMOAS.OperationObject, identifier: string, parentPathItem: RMOAS.PathItemObject);
    /**
     * Return the primary identifier for this callback.
     *
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#callback-object}
     * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#callbackObject}
     */
    getIdentifier(): string;
    getSummary(): string;
    getDescription(): string;
    getParameters(): RMOAS.ParameterObject[];
}
export declare class Webhook extends Operation {
}
export {};