import type { CallbackExamples } from './operation/get-callback-examples';
import type { RequestBodyExamples } from './operation/get-requestbody-examples';
import type { ResponseExamples } from './operation/get-response-examples';
import * as RMOAS from './rmoas.types';
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.
     *
     */
    getOperationId(opts?: {
        /**
         * Generate a JS method-friendly operation ID when one isn't present.
         */
        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.
     *
     */
    getParametersAsJSONSchema(opts?: {
        /**
         * Contains an object of user defined schema defaults.
         */
        globalDefaults?: Record<string, unknown>;
        /**
         * If you wish to include discriminator mapping `$ref` components alongside your
         * `discriminator` in schemas. Defaults to `true`.
         */
        includeDiscriminatorMappingRefs?: boolean;
        /**
         * If you want the output to be two objects: body (contains `body` and `formData` JSON
         * Schema) and metadata (contains `path`, `query`, `cookie`, and `header`).
         */
        mergeIntoBodyAndMetadata?: boolean;
        /**
         * If you wish to **not** split out deprecated properties into a separate `deprecatedProps`
         * object.
         */
        retainDeprecatedProperties?: boolean;
        /**
         * With a transformer you can transform any data within a given schema, like say if you want
         * to rewrite a potentially unsafe `title` that might be eventually used as a JS variable
         * name, just make sure to return your transformed schema.
         */
        transformer?: (schema: RMOAS.SchemaObject) => RMOAS.SchemaObject;
    }): import("./operation/get-parameters-as-json-schema").SchemaWrapper[];
    /**
     * Get a single response for this status code, formatted as JSON schema.
     *
     * @param statusCode Status code to pull a JSON Schema response for.
     */
    getResponseAsJSONSchema(statusCode: string | number, opts?: {
        /**
         * If you wish to include discriminator mapping `$ref` components alongside your
         * `discriminator` in schemas. Defaults to `true`.
         */
        includeDiscriminatorMappingRefs?: boolean;
        /**
         * With a transformer you can transform any data within a given schema, like say if you want
         * to rewrite a potentially unsafe `title` that might be eventually used as a JS variable
         * name, just make sure to return your transformed schema.
         */
        transformer?: (schema: RMOAS.SchemaObject) => RMOAS.SchemaObject;
    }): {
        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, ...string[]];
    /**
     * 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 Status code to pull a response object for.
     */
    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 {};
