Aide

https://docs.rs/aide/latest/aide/
Admin
Aide is a code-first OpenAPI documentation generator library for Rust that provides tight framework...
Tokens:127,379
Snippets:1,011
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example Struct

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Details the fields and their descriptions for the Example struct.

```APIDOC
## Struct Example

### Description
Represents an example, potentially with a summary, description, value, or external value.

### Fields
- **summary** (Option<String>) - Short description for the example.
- **description** (Option<String>) - Long description for the example. CommonMark syntax MAY be used for rich text representation.
- **value** (Option<Value>) - Embedded literal example. The `value` field and `externalValue` field are mutually exclusive. To represent examples of media types that cannot naturally represented in JSON or YAML, use a string value to contain the example, escaping where necessary.
- **external_value** (Option<String>) - A URI that points to the literal example. This provides the capability to reference examples that cannot easily be included in JSON or YAML documents. The `value` field and `externalValue` field are mutually exclusive. See the rules for resolving Relative References.
- **extensions** (IndexMap<String, Value>) - Inline extensions to this object.
```

--------------------------------

### aide::openapi Struct Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Defines the structure for an example, including optional summary, description, embedded value, external value URI, and extensions. Use this struct to represent examples in OpenAPI specifications.

```rust
pub struct Example {
    pub summary: Option<String>,
    pub description: Option<String>,
    pub value: Option<Value>,
    pub external_value: Option<String>,
    pub extensions: IndexMap<String, Value>,
}
```

--------------------------------

### Example Trait Implementations

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Lists and describes the trait implementations available for the Example struct.

```APIDOC
## Trait Implementations for Example

### Clone
- `clone(&self) -> Example`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.

### Debug
- `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the value using the given formatter.

### Default
- `default() -> Example`: Returns the “default value” for a type.

### Deserialize<'de>
- `deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>`: Deserialize this value from the given Serde deserializer.

### JsonSchema
- `schema_name() -> Cow<'static, str>`: The name of the generated JSON Schema.
- `schema_id() -> Cow<'static, str>`: Returns a string that uniquely identifies the schema produced by this type.
- `json_schema(generator: &mut SchemaGenerator) -> Schema`: Generates a JSON Schema for this type.
- `inline_schema() -> bool`: Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the `$ref` keyword.
- `always_inline_schema() -> bool`: Deprecated: Use `inline_schema()` instead.

### PartialEq
- `eq(&self, other: &Example) -> bool`: Tests for `self` and `other` values to be equal, and is used by `==`.
- `ne(&self, other: &Rhs) -> bool`: Tests for `!=`.

### Serialize
- `serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>`: Serialize this value into the given Serde serializer.

### StructuralPartialEq
```

--------------------------------

### Implement PartialEq for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Provides methods for comparing Example structs for equality. `eq` tests for equality, while `ne` tests for inequality.

```rust
impl PartialEq for Example
Source
#### fn eq(&self, other: &Example) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source
#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source
```

--------------------------------

### Implement StructuralPartialEq for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Provides structural partial equality comparison for the Example struct.

```rust
impl StructuralPartialEq for Example
```

--------------------------------

### Implement Clone for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Provides methods for cloning the Example struct. The `clone` method returns a duplicate, while `clone_from` performs copy-assignment.

```rust
impl Clone for Example
Source
#### fn clone(&self) -> Example
Returns a duplicate of the value. Read more
1.0.0 · Source
#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
Source
```

--------------------------------

### Implement Default for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Provides a default value for the Example struct, allowing instantiation without explicit field values.

```rust
impl Default for Example
Source
#### fn default() -> Example
Returns the “default value” for a type. Read more
Source
```

--------------------------------

### Implement Serialize for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Allows the Example struct to be serialized into a Serde serializer, enabling data to be written to various formats like JSON or YAML.

```rust
impl Serialize for Example
Source
#### fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,
Serialize this value into the given Serde serializer. Read more
Source
```

--------------------------------

### Implement Debug for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Enables debugging capabilities for the Example struct, allowing it to be formatted for debugging output.

```rust
impl Debug for Example
Source
#### fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Source
```

--------------------------------

### Example Auto Trait Implementations

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Lists the auto-generated trait implementations for the Example struct.

```APIDOC
## Auto Trait Implementations for Example

- `Freeze`
- `RefUnwindSafe`
- `Send`
- `Sync`
- `Unpin`
- `UnwindSafe`
```

--------------------------------

### Standard Axum Router Setup

Source: https://docs.rs/aide/latest/aide/axum/index.html

A standard axum implementation without aide integration.

```rust
use axum::{response::IntoResponse, routing::post, Json, Router};
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
    name: String,
}

async fn hello_user(Json(user): Json<User>) -> impl IntoResponse {
    format!("hello {}", user.name)
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/hello", post(hello_user));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    axum::serve(listener, app).await.unwrap();
}
```

--------------------------------

### Example Blanket Implementations

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Lists the blanket trait implementations for the Example struct.

```APIDOC
## Blanket Implementations for Example

### Any
- `type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.

### Borrow<T>
- `borrow(&self) -> &T`: Immutably borrows from an owned value.

### BorrowMut<T>
- `borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.

### CloneToUninit
- `clone_to_uninit(&self, dest: *mut u8)`: Performs copy-assignment from `self` to `dest`.

### DynClone
- `__clone_box(&self, _: Private) -> *mut ()`

### From<T>
- `from(t: T) -> T`: Returns the argument unchanged.

### FromRef<T>
- `from_ref(input: &T) -> T`: Converts to this type from a reference to the input type.

### Instrument
- `instrument(self, span: Span) -> Instrumented<Self>`: Instruments this type with the provided `Span`, returning an `Instrumented` wrapper.
```

--------------------------------

### Implement JsonSchema for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Enables the generation of JSON Schemas for the Example struct, useful for validating data structures.

```rust
impl JsonSchema for Example
Source
#### fn schema_name() -> Cow<'static, str>
The name of the generated JSON Schema. Read more
Source
#### fn schema_id() -> Cow<'static, str>
Returns a string that uniquely identifies the schema produced by this type. Read more
Source
#### fn json_schema(generator: &mut SchemaGenerator) -> Schema
Generates a JSON Schema for this type. Read more
Source
#### fn inline_schema() -> bool
Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the `$ref` keyword. Read more
Source
#### fn always_inline_schema() -> bool
👎Deprecated: Use `inline_schema()` instead
Only included for backward-compatibility - use `inline_schema()` instead“. Read more
Source
```

--------------------------------

### Implement Deserialize for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Allows the Example struct to be deserialized from a Serde deserializer, typically used for parsing data formats like JSON or YAML.

```rust
impl<'de> Deserialize<'de> for Example
Source
#### fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Source
```

--------------------------------

### Auto Trait Implementations for Example

Source: https://docs.rs/aide/latest/aide/openapi/struct.Example.html

Lists the auto-trait implementations for the Example struct, including Freeze, RefUnwindSafe, Send, Sync, Unpin, and UnwindSafe.

```rust
impl Freeze for Example
impl RefUnwindSafe for Example
impl Send for Example
impl Sync for Example
impl Unpin for Example
impl UnwindSafe for Example
```

--------------------------------

### TransformResponse::example

Source: https://docs.rs/aide/latest/aide/transform/struct.TransformResponse.html

Provides or overrides an example for the response, which must be serializable.

```APIDOC
## impl<'t, T> TransformResponse<'t, T>

### pub fn example(self, example: impl Into<T>) -> Self

#### Description
Provide or override an example for the response.

#### Parameters
- **example** (impl Into<T>) - An example value that can be converted into type T, where T must implement `Serialize`.

#### Returns
- Self - The modified TransformResponse instance.
```

--------------------------------

### GET /

Source: https://docs.rs/aide/latest/aide/axum/routing/fn.get.html

Route GET requests to the given handler. This function is available only when the `axum` feature is enabled.

```APIDOC
## GET /

### Description
Routes `GET` requests to the given handler. This is a convenience function that wraps `axum::routing::get`.

### Method
GET

### Endpoint
/

### Parameters
This endpoint does not have explicit path or query parameters defined in this context.

### Request Body
Not applicable for a GET request.

### Response
#### Success Response (200)
- **(type)** - Description of the response body. The specific type and description depend on the handler implementation.

#### Response Example
```json
{
  "example": "response body"
}
```

### Notes
- Available on crate feature `axum` only.
- See `axum::routing::get` for more details.
```

--------------------------------

### GET /

Source: https://docs.rs/aide/latest/aide/axum/routing/fn.get_with.html

Routes GET requests to a handler with an optional transformation function. This feature is available only when the `axum` feature is enabled.

```APIDOC
## GET /

### Description
Routes `get` requests to the given handler. This method additionally accepts a transform function.

### Method
GET

### Endpoint
/

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Depends on the handler and transform function.

#### Response Example
None
```

--------------------------------

### Adding Operation Metadata

Source: https://docs.rs/aide/latest/aide/axum/index.html

Extending an operation with IDs, descriptions, and response examples.

```rust
// ...
.api_route(
    "/hello",
    post_with(hello_user, |o| {
        o.id("helloUser")
            .description("says hello to the given user")
            .response_with::<200, String, _>(|res| {
                res.description("a simple message saying hello to the user")
                    .example(String::from("hello Tom"))
            })
    }),
)
// ...
```

--------------------------------

### Generate Swagger UI with Axum

Source: https://docs.rs/aide/latest/aide/swagger/index.html

This example demonstrates how to integrate Swagger UI generation into an Axum application. It requires deriving `JsonSchema` for all API types and setting up routes for both the API and the Swagger UI. The OpenAPI document is cloned on each request; consider using `Arc` or a serialized string for efficiency.

```rust
// Replace some of the `axum::` types with `aide::axum::` ones.
use aide::{
    axum::{
        routing::{get, post},
        ApiRouter,
        IntoApiResponse,
    },
    openapi::{Info, OpenApi},
    swagger::Swagger,
};
use axum::{Extension, Json};
use schemars::JsonSchema;
use serde::Deserialize;

// We'll need to derive `JsonSchema` for
// all types that appear in the api documentation.
#[derive(Deserialize, JsonSchema)]
struct User {
    name: String,
}

async fn hello_user(Json(user): Json<User>) -> impl IntoApiResponse {
    format!("hello {}", user.name)
}

// Note that this clones the document on each request.
// To be more efficient, we could wrap it into an Arc,
// or even store it as a serialized string.
async fn serve_api(Extension(api): Extension<OpenApi>) -> impl IntoApiResponse {
    Json(api)
}

#[tokio::main]
async fn main() {
    let app = ApiRouter::new()
        // generate swagger-ui using the openapi spec route
        .route("/swagger", Swagger::new("/api.json").axum_route())
        // Change `route` to `api_route` for the route
        // we'd like to expose in the documentation.
        .api_route("/hello", post(hello_user))
        // We'll serve our generated document here.
        .route("/api.json", get(serve_api));

    let mut api = OpenApi {
        info: Info {
            description: Some("an example API".to_string()),
            ..Info::default()
        },
        ..OpenApi::default()
    };

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    axum::serve(
        listener,
        app
            // Generate the documentation.
            .finish_api(&mut api)
            // Expose the documentation to the handlers.
            .layer(Extension(api))
            .into_make_service(),
    )
    .await
    .unwrap();
}

```

--------------------------------

### entry

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Gets an entry for a key, allowing for in-place manipulation or insertion. Computes in O(1) amortized average time.

```APIDOC
## GET /indexmap/entry/{key}

### Description
Retrieves an entry for the specified key, allowing for insertion or in-place modification of its associated value. Computes in O(1) amortized average time.

### Method
GET

### Endpoint
/indexmap/entry/{key}

### Parameters
#### Path Parameters
- **key** (K) - Required - The key to get the entry for.

### Response
#### Success Response (200)
- **Entry<'_, K, V>** - An entry object that can be used for further operations (e.g., insert, modify).

#### Response Example
(The response for an 'entry' operation is typically a handle or an object that allows subsequent operations, rather than a simple JSON payload. In a RESTful context, this might return a status indicating success and potentially a reference for further actions.)
```json
{
  "status": "entry_retrieved",
  "message": "Entry for key 'example_key' is ready for manipulation."
}
```
```

--------------------------------

### Adding Response Metadata

Source: https://docs.rs/aide/latest/aide/axum/index.html

Examples of adding response status codes and default responses to the API documentation.

```rust
// ...
.api_route(
    "/hello",
    post_with(hello_user, |op| op.response::<200, String>()),
)
// ...
```

```rust
// ...
app.finish_api_with(&mut api, |api| api.default_response::<String>())
// ...
```

--------------------------------

### Define a GET route with aide::axum::routing::get

Source: https://docs.rs/aide/latest/aide/axum/routing/fn.get.html

This function routes GET requests to a handler. It requires the axum feature flag to be enabled.

```rust
pub fn get<H, I, O, T, S>(handler: H) -> ApiMethodRouter<S, Infallible>
where
    H: Handler<T, S> + OperationHandler<I, O>,
    I: OperationInput,
    O: OperationOutput,
    S: Clone + Send + Sync + 'static,
    T: 'static,
```

--------------------------------

### Generate Scalar API References with Axum

Source: https://docs.rs/aide/latest/aide/scalar/index.html

This example demonstrates how to integrate Scalar API References into an Axum application. It requires the 'scalar' and 'axum' features of the aide crate. Ensure all types used in the API documentation derive `JsonSchema`.

```rust
// Replace some of the `axum::` types with `aide::axum::` ones.
use aide::
    axum::
        routing::{get, post},
        ApiRouter,
        IntoApiResponse,
    };
use aide::openapi::{Info, OpenApi};
use aide::scalar::Scalar;
use axum::{Extension, Json};
use schemars::JsonSchema;
use serde::Deserialize;

// We'll need to derive `JsonSchema` for
// all types that appear in the api documentation.
#[derive(Deserialize, JsonSchema)]
struct User {
    name: String,
}

async fn hello_user(Json(user): Json<User>) -> impl IntoApiResponse {
    format!("hello {}", user.name)
}

// Note that this clones the document on each request.
// To be more efficient, we could wrap it into an Arc,
// or even store it as a serialized string.
async fn serve_api(Extension(api): Extension<OpenApi>) -> impl IntoApiResponse {
    Json(api)
}

#[tokio::main]
async fn main() {
    let app = ApiRouter::new()
        // generate Scalar API References using the openapi spec route
        .route("/scalar", Scalar::new("/api.json").axum_route())
        // Change `route` to `api_route` for the route
        // we'd like to expose in the documentation.
        .api_route("/hello", post(hello_user))
        // We'll serve our generated document here.
        .route("/api.json", get(serve_api));

    let mut api = OpenApi {
        info: Info {
            description: Some("an example API".to_string()),
            ..Info::default()
        },
        ..OpenApi::default()
    };

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    axum::serve(
        listener,
        app
            // Generate the documentation.
            .finish_api(&mut api)
            // Expose the documentation to the handlers.
            .layer(Extension(api))
            .into_make_service(),
    )
    .await
    .unwrap();
}

```

--------------------------------

### Redoc Struct and Constructor

Source: https://docs.rs/aide/latest/aide/redoc/struct.Redoc.html

Information about the Redoc struct and how to create a new instance.

```APIDOC
## Struct Redoc

### Description
A wrapper to embed Redoc in your app.

### Methods
#### pub fn new(spec_url: impl Into<String>) -> Self
Create a new `Redoc` wrapper with the given spec url.

#### pub fn with_title(self, title: &str) -> Self
Set the title of the Redoc page.
```

--------------------------------

### Use NoApi in an aide Handler

Source: https://docs.rs/aide/latest/aide/struct.NoApi.html

Example of using NoApi to wrap a transaction type for input and a result type for output in an aide handler. This allows usage of the TX and hides the API of the return type.

```rust
pub async fn my_sqlx_tx_endpoint(
    NoApi(mut tx): NoApi<Tx<sqlx::Any>> // allows usage of the TX
) -> NoApi<Json<YourResult>> // Hides the API of the return type
```

--------------------------------

### Create a new Redoc instance

Source: https://docs.rs/aide/latest/aide/redoc/struct.Redoc.html

Instantiates a new Redoc wrapper. Provide the URL to your OpenAPI specification file. This is a fundamental step before configuring routes or handlers.

```rust
Redoc::new(spec_url: impl Into<String>)
```

--------------------------------

### Expose Redoc UI with axum_route

Source: https://docs.rs/aide/latest/aide/redoc/struct.Redoc.html

Use this method to expose the Redoc UI via an axum route. Requires the 'axum' crate feature. The route will serve the Redoc documentation at the specified path.

```rust
ApiRouter::<()>::new()
    .route("/docs", Redoc::new("/openapi.json").axum_route());
```

--------------------------------

### Swagger Struct and Initialization

Source: https://docs.rs/aide/latest/aide/swagger/struct.Swagger.html

Information about the Swagger struct and how to create a new instance.

```APIDOC
## Struct Swagger

### Description
A wrapper to embed Swagger in your app.

### Methods
#### pub fn new(spec_url: impl Into<String>) -> Self
Create a new `Swagger` wrapper with the given spec url.

#### pub fn with_title(self, title: &str) -> Self
Set the title of the Swagger page.
```

--------------------------------

### Constructor: ApiMethodDocs::new

Source: https://docs.rs/aide/latest/aide/axum/routing/struct.ApiMethodDocs.html

Creates a new instance of ApiMethodDocs to associate documentation with an API method.

```APIDOC
## pub fn new(method: &'static str, operation: Operation) -> Self

### Description
Creates a new API method documentation instance. This is used to define the HTTP method and the associated OpenAPI operation details.

### Parameters
- **method** (&'static str) - Required - The HTTP method (e.g., "GET", "POST").
- **operation** (Operation) - Required - The OpenAPI operation object containing documentation details.
```

--------------------------------

### Add Typed GET Route

Source: https://docs.rs/aide/latest/aide/axum/struct.ApiRouter.html

Adds a typed GET route to the ApiRouter. The path is inferred from the handler's first argument, which must implement TypedPath. Requires the 'axum-extra-typed-routing' feature.

```rust
pub fn typed_get<H, I, O, T, P>(self, handler: H) -> Self
where H: Handler<T, S> + OperationHandler<I, O>, T: SecondElementIs<P> + 'static, I: OperationInput, O: OperationOutput, P: TypedPath + JsonSchema + OperationInput,
```

--------------------------------

### New Router

Source: https://docs.rs/aide/latest/aide/axum/struct.ApiRouter.html

Creates a new `ApiRouter` instance. See `axum::Router::new` for details.

```APIDOC
## POST /api/users

### Description
Creates a new router.

### Method
POST

### Endpoint
/

### Parameters
(None)

### Request Body
(None)

### Response
#### Success Response (200)
- **ApiRouter** (ApiRouter) - The newly created router.
```

--------------------------------

### Add Typed GET Route with Transform

Source: https://docs.rs/aide/latest/aide/axum/struct.ApiRouter.html

Adds a typed GET route with an optional transform function. The path is inferred from the handler's first argument, which must implement TypedPath. Requires the 'axum-extra-typed-routing' feature.

```rust
pub fn typed_get_with<H, I, O, T, P, F>(self, handler: H, transform: F) -> Self
where H: Handler<T, S> + OperationHandler<I, O>, T: SecondElementIs<P> + 'static, I: OperationInput, O: OperationOutput, P: TypedPath + JsonSchema + OperationInput, F: FnOnce(TransformOperation<'_>) -> TransformOperation<'_>,
```

--------------------------------

### Route Registration with Documentation

Source: https://docs.rs/aide/latest/aide/axum/struct.ApiRouter.html

Methods for registering routes that automatically include generated OpenAPI documentation.

```APIDOC
## POST api_route

### Description
Create a route to the given method router and include it in the API documentation.

### Parameters
#### Path Parameters
- **path** (str) - Required - The path for the route.
- **method_router** (ApiMethodRouter<S>) - Required - The router containing the method handlers.

## POST api_route_with_tsr

### Description
Create a route to the given method router with trailing slash removal and include it in the API documentation.

### Parameters
#### Path Parameters
- **path** (str) - Required - The path for the route.
- **method_router** (ApiMethodRouter<S>) - Required - The router containing the method handlers.
```

--------------------------------

### Implement Any Trait for T

Source: https://docs.rs/aide/latest/aide/generate/struct.GenContext.html

Provides the `type_id` method to get the `TypeId` of a type.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Create IndexMap from Array

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Demonstrates initializing an IndexMap from a fixed-size array.

```rust
use indexmap::IndexMap;

let map1 = IndexMap::from([(1, 2), (3, 4)]);
let map2: IndexMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);
```

--------------------------------

### Get IndexMap Entry by Index

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Retrieves key-value pairs or entries by their numeric index.

```rust
pub fn get_index(&self, index: usize) -> Option<(&K, &V)>
```

```rust
pub fn get_index_mut(&mut self, index: usize) -> Option<(&K, &mut V)>
```

```rust
pub fn get_index_entry( &mut self, index: usize, ) -> Option<IndexedEntry<'_, K, V>>
```

--------------------------------

### IndexMap Get Methods

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Provides methods to retrieve values associated with keys in an IndexMap.

```APIDOC
## GET /indexmap/get

### Description
Retrieves values from the IndexMap based on a provided key.

### Method
GET

### Endpoint
`/indexmap/get`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **value** (any) - The value associated with the key, if found.

#### Response Example
```json
{
  "value": "some_value"
}
```
```

```APIDOC
## GET /indexmap/get_key_value

### Description
Retrieves the key-value pair associated with a given key.

### Method
GET

### Endpoint
`/indexmap/get_key_value`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **key** (string) - The key found in the map.
- **value** (any) - The value associated with the key.

#### Response Example
```json
{
  "key": "some_key",
  "value": "some_value"
}
```
```

```APIDOC
## GET /indexmap/get_full

### Description
Retrieves the index, key, and value for a given key.

### Method
GET

### Endpoint
`/indexmap/get_full`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **index** (integer) - The index of the key-value pair.
- **key** (string) - The key found in the map.
- **value** (any) - The value associated with the key.

#### Response Example
```json
{
  "index": 0,
  "key": "some_key",
  "value": "some_value"
}
```
```

```APIDOC
## GET /indexmap/get_index_of

### Description
Retrieves the index of a key in the map.

### Method
GET

### Endpoint
`/indexmap/get_index_of`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to find the index for.

### Response
#### Success Response (200)
- **index** (integer) - The index of the key, if found.

#### Response Example
```json
{
  "index": 0
}
```
```

```APIDOC
## GET /indexmap/get_mut

### Description
Retrieves a mutable reference to the value associated with a key.

### Method
GET

### Endpoint
`/indexmap/get_mut`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to look up.

### Response
#### Success Response (200)
- **value** (any) - A mutable reference to the value, if found.

#### Response Example
```json
{
  "value": "mutable_reference_to_value"
}
```
```

```APIDOC
## GET /indexmap/get_full_mut

### Description
Retrieves the index, key, and a mutable reference to the value for a given key.

### Method
GET

### Endpoint
`/indexmap/get_full_mut`

### Parameters
#### Query Parameters
- **key** (string) - Required - The key to look up.

### Response
#### Success Response (200)
- **index** (integer) - The index of the key-value pair.
- **key** (string) - The key found in the map.
- **value** (any) - A mutable reference to the value.

#### Response Example
```json
{
  "index": 0,
  "key": "some_key",
  "value": "mutable_reference_to_value"
}
```
```

--------------------------------

### Get IndexMap Range

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Retrieves a slice of key-value pairs within a specified index range.

```rust
pub fn get_range<R>(&self, range: R) -> Option<&Slice<K, V>>
where R: RangeBounds<usize>,
```

```rust
pub fn get_range_mut<R>(&mut self, range: R) -> Option<&mut Slice<K, V>>
where R: RangeBounds<usize>,
```

--------------------------------

### Create a new Swagger instance

Source: https://docs.rs/aide/latest/aide/swagger/struct.Swagger.html

Instantiate the Swagger wrapper with the URL of the OpenAPI specification.

```rust
Swagger::new("/openapi.json")
```

--------------------------------

### Aide Axum Router Integration

Source: https://docs.rs/aide/latest/aide/axum/index.html

An implementation using ApiRouter to expose OpenAPI documentation alongside standard axum routes.

```rust
// Replace some of the `axum::` types with `aide::axum::` ones.
use aide::{
    axum::{
        routing::{get, post},
        ApiRouter, IntoApiResponse,
    },
    openapi::{Info, OpenApi},
};
use axum::{Extension, Json};
use schemars::JsonSchema;
use serde::Deserialize;

// We'll need to derive `JsonSchema` for
// all types that appear in the api documentation.
#[derive(Deserialize, JsonSchema)]
struct User {
    name: String,
}

async fn hello_user(Json(user): Json<User>) -> impl IntoApiResponse {
    format!("hello {}", user.name)
}

// Note that this clones the document on each request.
// To be more efficient, we could wrap it into an Arc,
// or even store it as a serialized string.
async fn serve_api(Extension(api): Extension<OpenApi>) -> impl IntoApiResponse {
    Json(api)
}

#[tokio::main]
async fn main() {
    let app = ApiRouter::new()
        // Change `route` to `api_route` for the route
        // we'd like to expose in the documentation.
        .api_route("/hello", post(hello_user))
        // We'll serve our generated document here.
        .route("/api.json", get(serve_api));

    let mut api = OpenApi {
        info: Info {
            description: Some("an example API".to_string()),
            ..Info::default()
        },
        ..OpenApi::default()
    };

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    axum::serve(
        listener,
        app
            // Generate the documentation.
            .finish_api(&mut api)
            // Expose the documentation to the handlers.
            .layer(Extension(api))
            .into_make_service(),
    )
    .await
    .unwrap();
}
```

--------------------------------

### Get Disjoint Indices from IndexMap

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Retrieves multiple unique key-value pairs by index as an array.

```rust
pub fn get_disjoint_indices_mut<const N: usize>( &mut self, indices: [usize; N], ) -> Result<[(&K, &mut V); N], GetDisjointMutError>
```

```rust
let mut map = indexmap::IndexMap::from([(1, 'a'), (3, 'b'), (2, 'c')]);
assert_eq!(map.get_disjoint_indices_mut([2, 0]), Ok([(&2, &mut 'c'), (&1, &mut 'a')]));
```

--------------------------------

### Axum Integration for Redoc

Source: https://docs.rs/aide/latest/aide/redoc/struct.Redoc.html

Methods for integrating Redoc with the Axum web framework.

```APIDOC
## Implementations for Redoc

### impl Redoc

#### pub fn axum_route<S>(&self) -> ApiMethodRouter<S>
where S: Clone + Send + Sync + 'static,

Returns an `ApiMethodRouter` to expose the Redoc UI.

##### Examples
```rust
ApiRouter::<()>::new()
    .route("/docs", Redoc::new("/openapi.json").axum_route());
```

#### pub fn axum_handler<S>(
    &self,
) -> impl AxumOperationHandler<(), Html<&'static str>, ((),), S>

Returns an axum `Handler` that can be used with API routes.

##### Examples
```rust
ApiRouter::<()>::new().api_route(
    "/docs",
    get_with(Redoc::new("/openapi.json").axum_handler(), |op| {
        op.description("This documentation page.")
    }),
);
```
```

--------------------------------

### Default Implementation for Responses

Source: https://docs.rs/aide/latest/aide/openapi/struct.Responses.html

Provides a `default` function to get the default value for the Responses type.

```rust
fn default() -> Responses
```

--------------------------------

### OperationInput for Host (axum-extra feature)

Source: https://docs.rs/aide/latest/aide/operation/trait.OperationInput.html

Implementation of OperationInput for Host, requiring 'axum-extra' and 'axum' features.

```rust
impl OperationInput for Host
Available on **crate features`axum-extra` and `axum`** only.
Source
```

--------------------------------

### Get Mutable Key-Value Pair at Index

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Retrieves mutable references to the key and value at a specific index.

```rust
fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)>
```

--------------------------------

### IndexMap Get Disjoint Mut Method

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves mutable references to values for multiple keys simultaneously.

```APIDOC
## GET /indexmap/get_disjoint_mut

### Description
Retrieves mutable references to values for a fixed number of keys. This method will panic if any of the provided keys are duplicated.

### Method
GET

### Endpoint
`/indexmap/get_disjoint_mut`

### Parameters
#### Query Parameters
- **keys** (array of strings) - Required - An array of keys for which to retrieve mutable value references.

### Response
#### Success Response (200)
- **values** (array of options) - An array where each element is an `Option` containing a mutable reference to the value if the corresponding key was found, or `None` otherwise.

#### Response Example
```json
{
  "values": [
    "mutable_ref_to_value1",
    null
  ]
}
```
```

--------------------------------

### Insert and Retrieve Key-Value Pairs

Source: https://docs.rs/aide/latest/aide/openapi/type.Callback.html

Demonstrates inserting key-value pairs into an IndexMap and retrieving values by key. Panics if the key is not present.

```rust
use indexmap::IndexMap;

let mut map = IndexMap::new();
for word in "Lorem ipsum dolor sit amet".split_whitespace() {
    map.insert(word.to_lowercase(), word.to_uppercase());
}
assert_eq!(map["lorem"], "LOREM");
assert_eq!(map["ipsum"], "IPSUM");
```

```rust
use indexmap::IndexMap;

let mut map = IndexMap::new();
map.insert("foo", 1);
println!("{:?}", map["bar"]); // panics!
```

--------------------------------

### CloneToUninit Blanket Implementation

Source: https://docs.rs/aide/latest/aide/openapi/enum.VariantOrUnknown.html

Provides a nightly-only experimental API for cloning to uninitialized memory.

```rust
impl<T> CloneToUninit for T
where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8)
    // ...
}
```

--------------------------------

### Get Last Key-Value Pair

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the last key-value pair from the map. Returns None if the map is empty.

```rust
pub fn last(&self) -> Option<(&K, &V)>
```

--------------------------------

### PartialEq Implementation for Server

Source: https://docs.rs/aide/latest/aide/openapi/struct.Server.html

Enables equality comparison between Server instances.

```rust
fn eq(&self, other: &Server) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Get First Key-Value Pair

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the first key-value pair from the map. Returns None if the map is empty.

```rust
pub fn first(&self) -> Option<(&K, &V)>
```

--------------------------------

### Get Slice View of IndexMap

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Provides a read-only slice view of all key-value pairs in the IndexMap. Access is O(1).

```rust
pub fn as_slice(&self) -> &Slice<K, V>
```

--------------------------------

### Generate Redoc UI with Axum

Source: https://docs.rs/aide/latest/aide/redoc/index.html

Integrates Redoc UI into an Axum router by defining an OpenAPI specification route and serving the documentation.

```rust
// Replace some of the `axum::` types with `aide::axum::` ones.
use aide::{
    axum::{
        routing::{get, post},
        ApiRouter, IntoApiResponse,
    },
    openapi::{Info, OpenApi},
    redoc::Redoc,
};
use axum::{Extension, Json};
use schemars::JsonSchema;
use serde::Deserialize;

// We'll need to derive `JsonSchema` for
// all types that appear in the api documentation.
#[derive(Deserialize, JsonSchema)]
struct User {
    name: String,
}

async fn hello_user(Json(user): Json<User>) -> impl IntoApiResponse {
    format!("hello {}", user.name)
}

// Note that this clones the document on each request.
// To be more efficient, we could wrap it into an Arc,
// or even store it as a serialized string.
async fn serve_api(Extension(api): Extension<OpenApi>) -> impl IntoApiResponse {
    Json(api)
}

#[tokio::main]
async fn main() {
    let app = ApiRouter::new()
        // generate redoc-ui using the openapi spec route
        .route("/redoc", Redoc::new("/api.json").axum_route())
        // Change `route` to `api_route` for the route
        // we'd like to expose in the documentation.
        .api_route("/hello", post(hello_user))
        // We'll serve our generated document here.
        .route("/api.json", get(serve_api));

    let mut api = OpenApi {
        info: Info {
            description: Some("an example API".to_string()),
            ..Info::default()
        },
        ..OpenApi::default()
    };

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    axum::serve(
        listener,
        app
            // Generate the documentation.
            .finish_api(&mut api)
            // Expose the documentation to the handlers.
            .layer(Extension(api))
            .into_make_service(),
    )
    .await
    .unwrap();
}
```

--------------------------------

### Conversion Traits (Into, From, TryFrom, TryInto)

Source: https://docs.rs/aide/latest/aide/openapi/struct.Header.html

Documentation for traits related to type conversions.

```APIDOC
## impl<T, U> Into<U> for T

### Description
Provides a way to convert a type `T` into a type `U` where `U` implements `From<T>`.

### Method
`into`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **U** (type) - The target type `U` after conversion.

#### Response Example
None
```

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a fallible way to convert a type `U` into a type `T`.

### Method
`try_from`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Result<T, <T as TryFrom<U>>::Error>** (type) - A `Result` containing either the converted type `T` or an error.

#### Response Example
None
```

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides a fallible way to convert a type `T` into a type `U`.

### Method
`try_into`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Result<U, <U as TryFrom<T>>::Error>** (type) - A `Result` containing either the converted type `U` or an error.

#### Response Example
None
```

--------------------------------

### Get Last Entry for Manipulation

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the last entry in the map for in-place manipulation. Returns None if the map is empty.

```rust
pub fn last_entry(&mut self) -> Option<IndexedEntry<'_, K, V>>
```

--------------------------------

### Get First Entry for Manipulation

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the first entry in the map for in-place manipulation. Returns None if the map is empty.

```rust
pub fn first_entry(&mut self) -> Option<IndexedEntry<'_, K, V>>
```

--------------------------------

### Get Mutable Slice View of IndexMap

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Provides a mutable slice view of all key-value pairs in the IndexMap. Access is O(1).

```rust
pub fn as_mut_slice(&mut self) -> &mut Slice<K, V>
```

--------------------------------

### OperationIo Derive Macro Usage

Source: https://docs.rs/aide/latest/aide/derive.OperationIo.html

Examples of using the OperationIo derive macro to implement OperationInput and OperationOutput traits for custom types.

```APIDOC
## OperationIo Derive Macro

### Description
A helper macro to reduce boilerplate for implementing `OperationInput` and `OperationOutput` for common use-cases. Available when the `macros` feature is enabled.

### Usage
- **Default**: Implements both `OperationInput` and `OperationOutput`.
- **Restrict**: Use `#[aide(input)]` or `#[aide(output)]` to implement only one.
- **Delegation**: Use `input_with` or `output_with` to use implementations from another type.
- **Constraints**: Use `json_schema` to add a `JsonSchema` bound to generic parameters.

### Examples
#### Basic Implementation
```rust
use aide::{OperationInput, OperationOutput};

#[derive(OperationIo)]
struct MyExtractor;
```

#### Restricting to Output Only
```rust
#[derive(OperationIo)]
#[aide(output)]
struct MyExtractor;
```

#### Delegation and Schema Bounds
```rust
#[derive(OperationIo)]
#[aide(
    input_with = "some_other::Json<T>",
    output_with = "some_other::Json<T>",
    json_schema
)]
struct Json<T>(pub T);
```
```

--------------------------------

### Create Swagger UI Router with axum

Source: https://docs.rs/aide/latest/aide/swagger/struct.Swagger.html

Use this to expose the Swagger UI at a specific route when using the axum web framework. Requires the 'swagger' and 'axum' crate features.

```rust
ApiRouter::<()>::new()
    .route("/docs", Swagger::new("/openapi.json").axum_route());
```

--------------------------------

### Clone Implementation for Server

Source: https://docs.rs/aide/latest/aide/openapi/struct.Server.html

Provides the ability to create a duplicate of a Server instance.

```rust
fn clone(&self) -> Server
```

--------------------------------

### Get Mutable Key-Value Pair with Index

Source: https://docs.rs/aide/latest/aide/openapi/type.SecurityRequirement.html

Retrieves the index, a mutable reference to the key, and a mutable reference to the value for a given key.

```rust
fn get_full_mut2<Q>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
where Q: Hash + Equivalent<K> + ?Sized,
```

--------------------------------

### License Implementations

Source: https://docs.rs/aide/latest/aide/openapi/struct.License.html

Details the various trait implementations for the License struct, including Clone, Debug, Default, Deserialize, JsonSchema, PartialEq, and Serialize.

```APIDOC
## Trait Implementations for License

### impl Clone for License
- `clone(&self) -> License`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.

### impl Debug for License
- `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the value using the given formatter.

### impl Default for License
- `default() -> License`: Returns the “default value” for a type.

### impl<'de> Deserialize<'de> for License
- `deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>`: Deserialize this value from the given Serde deserializer.

### impl JsonSchema for License
- `schema_name() -> Cow<'static, str>`: The name of the generated JSON Schema.
- `schema_id() -> Cow<'static, str>`: Returns a string that uniquely identifies the schema produced by this type.
- `json_schema(generator: &mut SchemaGenerator) -> Schema`: Generates a JSON Schema for this type.
- `inline_schema() -> bool`: Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the `$ref` keyword.
- `always_inline_schema() -> bool`: Deprecated: Use `inline_schema()` instead.

### impl PartialEq for License
- `eq(&self, other: &License) -> bool`: Tests for `self` and `other` values to be equal.
- `ne(&self, other: &Rhs) -> bool`: Tests for `!=`.

### impl Serialize for License
- `serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>`: Serialize this value into the given Serde serializer.
```

--------------------------------

### Get Last Key-Value Pair Mutably

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the last key-value pair with mutable access to the value. Returns None if the map is empty.

```rust
pub fn last_mut(&mut self) -> Option<(&K, &mut V)>
```

--------------------------------

### Modify OpenApi operations with method chaining

Source: https://docs.rs/aide/latest/aide/transform/index.html

Demonstrates how to chain configuration methods to define operation descriptions and multiple response types.

```rust
op.description("An example operation.")
    .response_with::<200, Json<String>, _>(|res| {
        res.description(
            "Something was probably successful, we don't know \
                    what this returns, but it's at least JSON.",
        )
    })
    .response_with::<500, Html<String>, _>(|res| {
        res.description("Sometimes arbitrary 500 is returned with randomized HTML.")
    })
    .default_response::<String>()
```

--------------------------------

### Get First Key-Value Pair Mutably

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves the first key-value pair with mutable access to the value. Returns None if the map is empty.

```rust
pub fn first_mut(&mut self) -> Option<(&K, &mut V)>
```

--------------------------------

### Get Key-Value Pair by Index

Source: https://docs.rs/aide/latest/aide/openapi/type.Content.html

Retrieves a key-value pair using its index. Valid indices are within the bounds of the map's length.

```rust
pub fn get_index(&self, index: usize) -> Option<(&K, &V)>
```

--------------------------------

### Serialization

Source: https://docs.rs/aide/latest/aide/openapi/type.Callback.html

Serialization support for IndexMap using Serde.

```APIDOC
## fn serialize<T>

### Description
Serialize this value into the given Serde serializer.
```
Tokens:
Raw