@microsoft.azure/autorest.incubator/dist/common/code-model/http-operation.d.ts

AutoRest incubator project

import { Components, ImplementationDetails, Example, ExternalDocumentation, ImplementationLocation, IOperation, IOperationBase, IParameter, Link, ParameterDetails, SecurityRequirement, Server, LanguageDetails, ResponseDetails } from '#common/code-model/components';
import { Extensions } from '#common/code-model/extensions';
import { Schema } from '#common/code-model/schema';
import { SecurityScheme } from '#common/code-model/security-scheme';
import { Dictionary } from '#common/dictionary';
export interface HttpOperationDetails extends ImplementationDetails {
}
export declare class Encoding extends Extensions implements Encoding {
    headers: Dictionary<Header>;
    constructor(initializer?: Partial<Encoding>);
}
export declare class Header extends Extensions implements Header {
    content: Dictionary<MediaType>;
    constructor(initializer?: Partial<Header>);
}
export declare class MediaType extends Extensions implements MediaType {
    encoding: Dictionary<Encoding>;
    accepts: string[];
    constructor(initializer?: Partial<MediaType>);
}
export declare class RequestBody extends Extensions implements RequestBody {
    constructor(initializer?: Partial<RequestBody>);
}
export declare class Response extends Extensions implements Response {
    description: string;
    content: Dictionary<MediaType>;
    links: Dictionary<Link>;
    headers: Dictionary<Header>;
    constructor(description: string, initializer?: Partial<Response>);
}
export declare enum ParameterLocation {
    Query = "query",
    Header = "header",
    Cookie = "cookie",
    Path = "path"
}
export declare enum EncodingStyle {
    Matrix = "matrix",
    Label = "label",
    Simple = "simple",
    Form = "form",
    SpaceDelimited = "spaceDelimited",
    PipeDelimited = "pipeDelimited",
    DeepObject = "deepObject"
}
export declare type QueryEncodingStyle = EncodingStyle.Form | EncodingStyle.SpaceDelimited | EncodingStyle.PipeDelimited | EncodingStyle.DeepObject;
export declare type PathEncodingStyle = EncodingStyle.Matrix | EncodingStyle.Label | EncodingStyle.Simple;
export interface Encoding extends Extensions {
    contentType?: string;
    headers: Dictionary<Header>;
    style?: QueryEncodingStyle;
    explode?: boolean;
    allowReserved?: boolean;
}
export interface Header extends Extensions {
    schema: Schema;
    explode?: boolean;
    examples: Dictionary<Example>;
    description?: string;
    required: boolean;
    deprecated: boolean;
    allowEmptyValue: boolean;
    allowReserved: boolean;
}
export interface MediaType extends Extensions {
    accepts: Array<string>;
    examples: Dictionary<Example>;
    encoding: Dictionary<Encoding>;
    schema?: Schema;
}
export interface RequestBody extends Extensions {
    description?: string;
    contentType: string;
    schema: Schema;
    required: boolean;
}
export interface Response extends Extensions {
    description: string;
    headers: Dictionary<Header>;
    content: Dictionary<MediaType>;
    links: Dictionary<Link>;
}
export interface HttpParameterDetails extends ParameterDetails {
    location: ImplementationLocation;
}
export declare enum HttpMethod {
    Get = "get",
    Put = "put",
    Post = "post",
    Delete = "delete",
    Options = "options",
    Head = "head",
    Patch = "patch",
    Trace = "trace"
}
export interface NewResponse {
    details: LanguageDetails<ResponseDetails>;
    responseCode: string;
    description: string;
    headers: Dictionary<Header>;
    headerSchema?: Schema;
    mimeTypes: Array<string>;
    schema?: Schema;
}
export declare class NewResponse extends Extensions implements NewResponse {
    responseCode: string;
    description: string;
    mimeTypes: Array<string>;
    details: LanguageDetails<ResponseDetails>;
    constructor(responseCode: string, description: string, mimeTypes: Array<string>, objectInitializer?: Partial<NewResponse>);
}
export declare class HttpOperation extends Extensions implements HttpOperation {
    path: string;
    method: HttpMethod;
    details: LanguageDetails<HttpOperationDetails>;
    tags: string[];
    parameters: HttpOperationParameter[];
    responses_new: Dictionary<NewResponse[]>;
    callbacks: Dictionary<Callback>;
    security: SecurityRequirement[];
    servers: Server[];
    deprecated: boolean;
    constructor(operationId: string, path: string, method: HttpMethod, initializer?: Partial<HttpOperation>);
}
export interface HttpOperation extends IOperation<HttpOperationParameter>, Extensions {
    details: LanguageDetails<HttpOperationDetails>;
    tags: Array<string>;
    summary?: string;
    externalDocs?: ExternalDocumentation;
    parameters: Array<HttpOperationParameter>;
    requestBody?: RequestBody;
    responses_new: Dictionary<Array<NewResponse>>;
    callbacks: Dictionary<Callback>;
    deprecated: boolean;
    security: Array<SecurityRequirement>;
    servers: Array<Server>;
    path: string;
    method: HttpMethod;
    pathDescription?: string;
    pathSummary?: string;
    pathExtensions?: Dictionary<any>;
}
export interface HttpOperationParameter extends IParameter {
    in: ParameterLocation;
    explode?: boolean;
    encoding?: Dictionary<Encoding>;
    mediaType?: string;
    style: EncodingStyle;
    examples?: Dictionary<any>;
    allowReserved?: boolean;
}
export declare class HttpOperationParameter extends Extensions implements HttpOperationParameter {
    name: string;
    details: LanguageDetails<HttpParameterDetails>;
    deprecated: boolean;
    required: boolean;
    allowEmptyValue: boolean;
    constructor(name: string, inWhere: ParameterLocation, implementation: ImplementationLocation, initializer?: Partial<HttpOperationParameter>);
}
export declare function isHttpOperation(operation: IOperationBase): operation is HttpOperation;
export declare class Callback implements Callback {
    constructor();
}
export interface Callback extends Dictionary<HttpOperation> {
}
export interface HttpComponents extends Components<HttpOperation, HttpOperationParameter> {
    responses: Dictionary<Response>;
    examples: Dictionary<Example>;
    requestBodies: Dictionary<RequestBody>;
    headers: Dictionary<Header>;
    securitySchemes: Dictionary<SecurityScheme>;
    links: Dictionary<Link>;
    callbacks: Dictionary<Callback>;
}
export declare class HttpComponents extends Components<HttpOperation, HttpOperationParameter> implements HttpComponents {
    responses: Dictionary<Response>;
    examples: Dictionary<Example>;
    requestBodies: Dictionary<RequestBody>;
    headers: Dictionary<Header>;
    securitySchemes: Dictionary<SecurityScheme>;
    links: Dictionary<Link>;
    callbacks: Dictionary<Callback>;
    constructor(initializer?: Partial<HttpComponents>);
}
//# sourceMappingURL=http-operation.d.ts.map