offstage - v0.7.0

offstage/openapi/openapi

Types

Components

</> 
pub type Components {
  Components(
    schemas: List(#(String, Schema)),
    responses: List(#(String, Response)),
    parameters: List(#(String, Parameter)),
    security_schemes: List(#(String, SecurityScheme)),
  )
}

Constructors

ComponentsNS

</> 
pub type ComponentsNS {
  ComponentsNS(
    to_spec: fn(Components) -> spec.Spec,
    schema: fn(OpenAPI, String, String, fn(Schema) -> Schema) -> OpenAPI,
    set_schema: fn(OpenAPI, String, Schema) -> OpenAPI,
    response: fn(OpenAPI, String, fn(Response) -> Response) -> OpenAPI,
    parameter: fn(
      OpenAPI,
      String,
      String,
      ParameterIn,
      fn(Parameter) -> Parameter,
    ) -> OpenAPI,
    security_scheme: fn(
      OpenAPI,
      String,
      String,
      fn(SecurityScheme) -> SecurityScheme,
    ) -> OpenAPI,
  )
}

Constructors

Contact

</> 
pub type Contact {
  Contact(
    name: option.Option(String),
    url: option.Option(uri.Uri),
    email: option.Option(String),
  )
}

Constructors

ContactNS

</> 
pub type ContactNS {
  ContactNS(to_spec: fn(Contact) -> spec.Spec)
}

Constructors

ExternalDocs

</> 
pub type ExternalDocs {
  ExternalDocs(description: option.Option(String), url: uri.Uri)
}

Constructors

Info

</> 
pub type Info {
  Info(
    title: String,
    summary: option.Option(String),
    description: option.Option(String),
    terms_of_service: option.Option(uri.Uri),
    contact: option.Option(Contact),
    license: option.Option(License),
    version: String,
  )
}

Constructors

InfoNS

</> 
pub type InfoNS {
  InfoNS(to_spec: fn(Info) -> spec.Spec)
}

Constructors

License

</> 
pub type License {
  License(
    name: String,
    identifier: option.Option(String),
    url: option.Option(uri.Uri),
  )
}

Constructors

LicenseNS

</> 
pub type LicenseNS {
  LicenseNS(to_spec: fn(License) -> spec.Spec)
}

Constructors

MediaType

</> 
pub type MediaType {
  MediaType(
    schema: option.Option(Schema),
    example: option.Option(String),
  )
}

Constructors

MediaTypeNS

</> 
pub type MediaTypeNS {
  MediaTypeNS(
    to_spec: fn(MediaType) -> spec.Spec,
    schema: fn(MediaType, String, fn(Schema) -> Schema) -> MediaType,
    set_schema: fn(MediaType, Schema) -> MediaType,
    example: fn(MediaType, String) -> MediaType,
  )
}

Constructors

OpenAPI

</> 
pub type OpenAPI {
  OpenAPI(
    version: String,
    info: Info,
    servers: List(Server),
    paths: List(PathItem),
    tags: List(Tag),
    components: Components,
  )
}

Constructors

Operation

</> 
pub type Operation {
  Operation(
    tags: List(String),
    summary: option.Option(String),
    description: option.Option(String),
    external_docs: option.Option(ExternalDocs),
    operation_id: option.Option(String),
    parameters: List(OrRef(Parameter)),
    responses: List(#(Int, OrRef(Response))),
    security: List(String),
    request_body: option.Option(RequestBody),
  )
}

Constructors

OperationNS

</> 
pub type OperationNS {
  OperationNS(
    to_spec: fn(Operation) -> spec.Spec,
    tag: fn(Operation, String) -> Operation,
    summary: fn(Operation, String) -> Operation,
    description: fn(Operation, String) -> Operation,
    parameter: fn(
      Operation,
      String,
      ParameterIn,
      fn(Parameter) -> Parameter,
    ) -> Operation,
    parameter_ref: fn(Operation, String) -> Operation,
    response: fn(Operation, Int, fn(Response) -> Response) -> Operation,
    response_ref: fn(Operation, Int, String) -> Operation,
    security: fn(Operation, String) -> Operation,
    request_body: fn(Operation, fn(RequestBody) -> RequestBody) -> Operation,
  )
}

Constructors

OrRef

</> 
pub type OrRef(a) {
  Ref(String)
  Value(a)
}

Constructors 

  • Ref(String)
  • Value(a)

Parameter

</> 
pub type Parameter {
  Parameter(
    name: String,
    in: ParameterIn,
    description: option.Option(String),
    required: Bool,
    deprecated: Bool,
    allow_empty_value: Bool,
    schema: option.Option(Schema),
  )
}

Constructors

ParameterIn

</> 
pub type ParameterIn {
  ParameterInQuery
  ParameterInQueryString
  ParameterInHeader
  ParameterInPath
  ParameterInCookie
}

Constructors 

  • ParameterInQuery
  • ParameterInQueryString
  • ParameterInHeader
  • ParameterInPath
  • ParameterInCookie

ParameterNS

</> 
pub type ParameterNS {
  ParameterNS(
    to_spec: fn(Parameter) -> spec.Spec,
    description: fn(Parameter, String) -> Parameter,
    required: fn(Parameter, Bool) -> Parameter,
    deprecated: fn(Parameter, Bool) -> Parameter,
    allow_empty_value: fn(Parameter, Bool) -> Parameter,
    schema: fn(Parameter, String, fn(Schema) -> Schema) -> Parameter,
    set_schema: fn(Parameter, Schema) -> Parameter,
  )
}

Constructors

PathItem

</> 
pub type PathItem {
  PathItem(
    path: String,
    summary: option.Option(String),
    description: option.Option(String),
    get: option.Option(Operation),
    put: option.Option(Operation),
    post: option.Option(Operation),
    delete: option.Option(Operation),
    patch: option.Option(Operation),
  )
}

Constructors

PathItemNS

</> 
pub type PathItemNS {
  PathItemNS(
    to_spec: fn(PathItem) -> spec.Spec,
    get: fn(PathItem, fn(Operation) -> Operation) -> PathItem,
    put: fn(PathItem, fn(Operation) -> Operation) -> PathItem,
    patch: fn(PathItem, fn(Operation) -> Operation) -> PathItem,
    post: fn(PathItem, fn(Operation) -> Operation) -> PathItem,
    delete: fn(PathItem, fn(Operation) -> Operation) -> PathItem,
  )
}

Constructors

RequestBody

</> 
pub type RequestBody {
  RequestBody(
    description: option.Option(String),
    content: List(#(String, OrRef(MediaType))),
    required: Bool,
  )
}

Constructors

RequestBodyNS

</> 
pub type RequestBodyNS {
  RequestBodyNS(
    to_spec: fn(RequestBody) -> spec.Spec,
    description: fn(RequestBody, String) -> RequestBody,
    content: fn(RequestBody, String, fn(MediaType) -> MediaType) -> RequestBody,
    content_ref: fn(RequestBody, String, String) -> RequestBody,
    required: fn(RequestBody, Bool) -> RequestBody,
  )
}

Constructors

Response

</> 
pub type Response {
  Response(
    summary: option.Option(String),
    description: option.Option(String),
    content: List(#(String, OrRef(MediaType))),
  )
}

Constructors

ResponseNS

</> 
pub type ResponseNS {
  ResponseNS(
    to_spec: fn(Response) -> spec.Spec,
    summary: fn(Response, String) -> Response,
    description: fn(Response, String) -> Response,
    content: fn(Response, String, fn(MediaType) -> MediaType) -> Response,
    content_ref: fn(Response, String, String) -> Response,
  )
}

Constructors

Schema

</> 
pub type Schema {
  Schema(
    type_: List(String),
    format: option.Option(String),
    default: option.Option(spec.Spec),
    items: option.Option(Schema),
    properties: List(#(String, Schema)),
    enum: List(String),
    required: List(String),
    pattern: option.Option(String),
    examples: List(spec.Spec),
    minimum: option.Option(spec.Spec),
    maximum: option.Option(spec.Spec),
  )
}

Constructors

SchemaNS

</> 
pub type SchemaNS {
  SchemaNS(
    to_spec: fn(Schema) -> spec.Spec,
    or: fn(Schema, String) -> Schema,
    format: fn(Schema, String) -> Schema,
    default: fn(Schema, spec.Spec) -> Schema,
    items: fn(Schema, String, fn(Schema) -> Schema) -> Schema,
    property: fn(Schema, String, String, fn(Schema) -> Schema) -> Schema,
    required: fn(Schema, String) -> Schema,
    enum: fn(Schema, String) -> Schema,
    pattern: fn(Schema, String) -> Schema,
    example: fn(Schema, spec.Spec) -> Schema,
  )
}

Constructors

SecurityScheme

</> 
pub type SecurityScheme {
  SecurityScheme(
    type_: String,
    description: option.Option(String),
    name: option.Option(String),
    in: option.Option(SecuritySchemeIn),
    scheme: option.Option(String),
    bearer_format: option.Option(String),
  )
}

Constructors

SecuritySchemeIn

</> 
pub type SecuritySchemeIn {
  SecuritySchemeInQuery
  SecuritySchemeInHeader
  SecuritySchemeInCookie
}

Constructors 

  • SecuritySchemeInQuery
  • SecuritySchemeInHeader
  • SecuritySchemeInCookie

SecuritySchemeNS

</> 
pub type SecuritySchemeNS {
  SecuritySchemeNS(
    to_spec: fn(SecurityScheme) -> spec.Spec,
    description: fn(SecurityScheme, String) -> SecurityScheme,
    type_: fn(SecurityScheme, String) -> SecurityScheme,
    name: fn(SecurityScheme, String) -> SecurityScheme,
    in: fn(SecurityScheme, SecuritySchemeIn) -> SecurityScheme,
    scheme: fn(SecurityScheme, String) -> SecurityScheme,
    bearer_format: fn(SecurityScheme, String) -> SecurityScheme,
  )
}

Constructors

Server

</> 
pub type Server {
  Server(
    url: uri.Uri,
    description: option.Option(String),
    name: option.Option(String),
    variables: List(#(String, ServerVariable)),
  )
}

Constructors

ServerNS

</> 
pub type ServerNS {
  ServerNS(
    to_spec: fn(Server) -> spec.Spec,
    description: fn(Server, String) -> Server,
    name: fn(Server, String) -> Server,
  )
}

Constructors

ServerVariable

</> 
pub type ServerVariable {
  ServerVariable(
    default: String,
    description: option.Option(String),
    enum: List(String),
  )
}

Constructors 

  • ServerVariable(
  default: String,
  description: option.Option(String),
  enum: List(String),
)

ServerVariableNS

</> 
pub type ServerVariableNS {
  ServerVariableNS(to_spec: fn(ServerVariable) -> spec.Spec)
}

Constructors

Tag

</> 
pub type Tag {
  Tag(
    name: String,
    summary: option.Option(String),
    description: option.Option(String),
    external_docs: option.Option(ExternalDocs),
    parent: option.Option(String),
    kind: option.Option(String),
  )
}

Constructors

TagNS

</> 
pub type TagNS {
  TagNS(
    to_spec: fn(Tag) -> spec.Spec,
    summary: fn(Tag, String) -> Tag,
    description: fn(Tag, String) -> Tag,
    kind: fn(Tag, String) -> Tag,
    parent: fn(Tag, String) -> Tag,
  )
}

Constructors

Values

add_path

</> 
pub fn add_path(
  openapi: OpenAPI,
  path: String,
  builder: fn(PathItem) -> PathItem,
) -> OpenAPI

add_server

</> 
pub fn add_server(
  openapi: OpenAPI,
  uri: uri.Uri,
  builder: fn(Server) -> Server,
) -> OpenAPI

add_tag

</> 
pub fn add_tag(
  openapi: OpenAPI,
  name: String,
  builder: fn(Tag) -> Tag,
) -> OpenAPI

components

</> 
pub const components: ComponentsNS

contact

</> 
pub const contact: ContactNS

info

</> 
pub const info: InfoNS

license

</> 
pub const license: LicenseNS

media_type

</> 
pub const media_type: MediaTypeNS

on_path

</> 
pub fn on_path(
  openapi: OpenAPI,
  path: String,
  builder: fn(PathItem) -> PathItem,
) -> OpenAPI

openapi

</> 
pub fn openapi() -> OpenAPI

operation

</> 
pub const operation: OperationNS

operation_description

</> 
pub fn operation_description(
  operation: Operation,
  description: String,
) -> Operation

operation_parameter

</> 
pub fn operation_parameter(
  operation: Operation,
  name: String,
  in: ParameterIn,
  builder: fn(Parameter) -> Parameter,
) -> Operation

operation_parameter_ref

</> 
pub fn operation_parameter_ref(
  operation: Operation,
  ref: String,
) -> Operation

operation_response

</> 
pub fn operation_response(
  operation: Operation,
  code: Int,
  builder: fn(Response) -> Response,
) -> Operation

operation_response_ref

</> 
pub fn operation_response_ref(
  operation: Operation,
  code: Int,
  ref: String,
) -> Operation

operation_security

</> 
pub fn operation_security(
  operation: Operation,
  security: String,
) -> Operation

operation_summary

</> 
pub fn operation_summary(
  operation: Operation,
  summary: String,
) -> Operation

operation_tag

</> 
pub fn operation_tag(
  operation: Operation,
  tag: String,
) -> Operation

opereation_request_body

</> 
pub fn opereation_request_body(
  operation: Operation,
  builder: fn(RequestBody) -> RequestBody,
) -> Operation

parameter

</> 
pub const parameter: ParameterNS

path

</> 
pub const path: PathItemNS

request_body

</> 
pub const request_body: RequestBodyNS

response

</> 
pub const response: ResponseNS

schema

</> 
pub const schema: SchemaNS

security_scheme

</> 
pub const security_scheme: SecuritySchemeNS

server

</> 
pub const server: ServerNS

server_variable

</> 
pub const server_variable: ServerVariableNS

tag

</> 
pub const tag: TagNS

tag_description

</> 
pub fn tag_description(tag: Tag, description: String) -> Tag

tag_kind

</> 
pub fn tag_kind(tag: Tag, kind: String) -> Tag

tag_parent

</> 
pub fn tag_parent(tag: Tag, parent: String) -> Tag

tag_summary

</> 
pub fn tag_summary(tag: Tag, summary: String) -> Tag

title

</> 
pub fn title(openapi: OpenAPI, title: String) -> OpenAPI

to_spec

</> 
pub fn to_spec(openapi: OpenAPI) -> spec.Spec

version

</> 
pub fn version(openapi: OpenAPI, version: String) -> OpenAPI
✨ Search Document