@azure-tools/codemodel-v3/dist/code-model/http-operation.d.ts

AutoRest code model library

import { Components, Example, ExternalDocumentation, ImplementationDetails, ImplementationLocation, IOperation, IOperationBase, IParameter, LanguageDetails, Link, ParameterDetails, ResponseDetails, SecurityRequirement, Server } from './components';
import { Extensions } from './extensions';
import { Schema } from './schema';
import { SecurityScheme } from './security-scheme';
import { DeepPartial } from '@azure-tools/codegen';
import { Dictionary } from '@azure-tools/linq';
export interface HttpOperationDetails extends ImplementationDetails {
}
/**
 * An encoding attribute is introduced to give you control over the serialization of parts of multipart request bodies.
 * This attribute is only applicable to multipart and application/x-www-form-urlencoded request bodies.
*/
export declare class Encoding extends Extensions implements Encoding {
    key: string;
    headers: Header[];
    constructor(key: string, initializer?: DeepPartial<Encoding>);
}
export declare class Header extends Extensions implements Header {
    content: MediaType[];
    constructor(initializer?: DeepPartial<Header>);
}
export declare class MediaType extends Extensions implements MediaType {
    key: string;
    encoding: Encoding[];
    accepts: string[];
    constructor(key: string, initializer?: DeepPartial<MediaType>);
}
export declare class RequestBody extends Extensions implements RequestBody {
    constructor(initializer?: DeepPartial<RequestBody>);
}
export declare class Response extends Extensions implements Response {
    description: string;
    content: Dictionary<MediaType>;
    links: Dictionary<Link>;
    headers: Header[];
    constructor(description: string, initializer?: DeepPartial<Response>);
}
export declare enum ParameterLocation {
    Uri = "uri",
    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 {
    key: string;
    contentType?: string;
    headers: Array<Header>;
    style?: QueryEncodingStyle;
    explode?: boolean;
    allowReserved?: boolean;
}
export interface Header extends Extensions {
    key: string;
    schema: Schema;
    explode?: boolean;
    examples: Dictionary<Example>;
    description?: string;
    required: boolean;
    deprecated: boolean;
    allowEmptyValue: boolean;
    allowReserved: boolean;
}
export interface MediaType extends Extensions {
    key: string;
    accepts: Array<string>;
    examples: Array<Example>;
    encoding: Array<Encoding>;
    schema?: Schema;
}
export interface RequestBody extends Extensions {
    description?: string;
    contentType: string;
    schema: Schema;
    required: boolean;
}
export interface Response extends Extensions {
    description: string;
    headers: Array<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: Array<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?: DeepPartial<NewResponse>);
}
export declare class HttpOperation extends Extensions implements HttpOperation {
    baseUrl: string;
    path: string;
    method: HttpMethod;
    details: LanguageDetails<HttpOperationDetails>;
    tags: string[];
    parameters: HttpOperationParameter[];
    responses: Dictionary<NewResponse[]>;
    callbacks: Dictionary<Callback>;
    security: SecurityRequirement[];
    servers: Server[];
    deprecated: boolean;
    constructor(operationId: string, baseUrl: string, path: string, method: HttpMethod, initializer?: DeepPartial<HttpOperation>);
}
export interface HttpOperation extends IOperation<HttpOperationParameter>, Extensions {
    details: LanguageDetails<HttpOperationDetails>;
    tags: Array<string>;
    summary?: string;
    externalDocs?: ExternalDocumentation;
    parameters: Array<HttpOperationParameter>;
    requestBody?: RequestBody;
    responses: Dictionary<Array<NewResponse>>;
    callbacks: Dictionary<Callback>;
    deprecated: boolean;
    security: Array<SecurityRequirement>;
    servers: Array<Server>;
    path: string;
    baseUrl: string;
    method: HttpMethod;
    pathDescription?: string;
    pathSummary?: string;
    pathExtensions?: Dictionary<any>;
}
export interface HttpOperationParameter extends IParameter {
    in: ParameterLocation;
    explode?: boolean;
    encoding?: Array<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?: DeepPartial<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> {
    examples: Dictionary<Example>;
    securitySchemes: Dictionary<SecurityScheme>;
    links: Dictionary<Link>;
    callbacks: Dictionary<Callback>;
}
export declare class HttpComponents extends Components<HttpOperation, HttpOperationParameter> implements HttpComponents {
    examples: Dictionary<Example>;
    securitySchemes: Dictionary<SecurityScheme>;
    links: Dictionary<Link>;
    callbacks: Dictionary<Callback>;
    constructor(initializer?: DeepPartial<HttpComponents>);
}
//# sourceMappingURL=http-operation.d.ts.map