### Basic Echo OpenAPI Docs Setup with GitHub API

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Complete minimal example showing how to set up Echo server with Stoplight Elements documentation for GitHub REST API. Creates Echo instance, registers documentation at /docs endpoint using ElementsConfig with SpecUrl, and starts server on port 8080.

```go
package main

import (
	"github.com/kohkimakimoto/echo-openapidocs"
	"github.com/labstack/echo/v4"
	"log"
)

func main() {
	e := echo.New()

	// Register the GitHub v3 REST API documentation at /docs
	openapidocs.ElementsDocuments(e, "/docs", openapidocs.ElementsConfig{
		SpecUrl:  "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/ghes-3.0/ghes-3.0.yaml",
		Title: "GitHub v3 REST API",
	})

	// Start the server
	if err := e.Start(":8080"); err != nil {
		log.Fatal(err)
	}
}
```

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

### Install Echo OpenAPI Docs Library

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Installation command to add the Echo OpenAPI Docs library to your Go project using the go get command.

```bash
go get github.com/kohkimakimoto/echo-openapidocs
```

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

### Stoplight Elements with OpenAPI Spec URL

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Configuration example for Stoplight Elements documentation generator using external OpenAPI specification URL. Demonstrates SpecUrl configuration for loading OpenAI API documentation from GitHub repository.

```go
// Register the Stoplight Elements documentation with OpenAPI Spec url.
openapidocs.ElementsDocuments(e, "/docs", openapidocs.ElementsConfig{
	// The following is the example for generating the OpenAI API documentation.
	// You can replace the SpecUrl with your OpenAPI Spec url.
	SpecUrl: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
})
```

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

### Host Multiple Documentation Generators in Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

This comprehensive example hosts multiple documentation generators (Elements, Scalar, Swagger UI, ReDoc) using the same embedded OpenAPI spec, with global middleware for logging, recovery, and CORS. It includes a redirect from the home page and lists available endpoints. Dependencies include echo-openapidocs and Echo; inputs are the spec and configs, outputs are multiple handlers. Limitations are the need for an embedded spec and suitable layouts/themes for each generator.

```go
package main

import (
    _ "embed"
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

//go:embed openapi-specification.yaml
var apiSpec string

func main() {
    e := echo.New()

    // Global middleware
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    e.Use(middleware.CORS())

    // Home page redirecting to documentation
    e.GET("/", func(c echo.Context) error {
        return c.Redirect(302, "/docs/elements")
    })

    // Stoplight Elements
    openapidocs.ElementsDocuments(e, "/docs/elements", openapidocs.ElementsConfig{
        Spec:   apiSpec,
        Title:  "API Docs - Elements",
        Layout: openapidocs.ElementsLayoutSidebar,
    })

    // Scalar
    openapidocs.ScalarDocuments(e, "/docs/scalar", openapidocs.ScalarConfig{
        Spec:   apiSpec,
        Title:  "API Docs - Scalar",
        Theme:  openapidocs.ScalarThemeDefault,
        Layout: openapidocs.ScalarLayoutModern,
    })

    // Swagger UI
    openapidocs.SwaggerUIDocuments(e, "/docs/swagger", openapidocs.SwaggerUIConfig{
        Spec:        apiSpec,
        Title:       "API Docs - Swagger UI",
        DeepLinking: true,
    })

    // ReDoc
    openapidocs.RedocDocuments(e, "/docs/redoc", openapidocs.RedocConfig{
        Spec:  apiSpec,
        Title: "API Docs - ReDoc",
    })

    e.Logger.Info("Documentation available at:")
    e.Logger.Info("  Elements:   http://localhost:8080/docs/elements")
    e.Logger.Info("  Scalar:     http://localhost:8080/docs/scalar")
    e.Logger.Info("  Swagger UI: http://localhost:8080/docs/swagger")
    e.Logger.Info("  ReDoc:      http://localhost:8080/docs/redoc")

    if err := e.Start(":8080"); err != nil {
        log.Fatal(err)
    }
}
```

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

### Scalar API Reference with OpenAPI Spec URL

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Configuration example for Scalar API Reference documentation generator using external OpenAPI specification URL. Shows SpecUrl configuration for loading OpenAI API documentation, similar to Elements but using ScalarDocuments function.

```go
// Register the Scalar documentation with OpenAPI Spec url.
openapidocs.ScalarDocuments(e, "/docs", openapidocs.ScalarConfig{
	// The following is the example for generating the OpenAI API documentation.
	// You can replace the SpecUrl with your OpenAPI Spec url.
	SpecUrl: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
})
```

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

### Create Custom Swagger UI Handler in Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

This example creates a custom Echo handler for Swagger UI with an embedded OpenAPI spec, protected by CORS and key authentication middleware. It allows secure access to API documentation at a protected endpoint. Dependencies include the echo-openapidocs library and Echo framework; inputs are the spec and config, outputs are the handler serving the UI. Limitations include requiring proper spec embedding and middleware setup for security.

```go
package main

import (
    _ "embed"
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

//go:embed swagger-spec.json
var swaggerSpec string

func main() {
    e := echo.New()

    // Create handler with embedded spec
    swaggerHandler := openapidocs.SwaggerUIDocumentsHandler(openapidocs.SwaggerUIConfig{
        Spec:               swaggerSpec,
        Title:              "Secure API Documentation",
        DeepLinking:        true,
        DisplayOperationId: true,
    })

    // Protected documentation with CORS
    secureGroup := e.Group("/secure")
    secureGroup.Use(middleware.CORSWithConfig(middleware.CORSConfig{
        AllowOrigins: []string{"https://trusted-domain.com"},
        AllowMethods: []string{echo.GET},
    }))
    secureGroup.Use(middleware.KeyAuth(func(key string, c echo.Context) (bool, error) {
        return key == "valid-api-key", nil
    }))
    secureGroup.GET("/swagger*", swaggerHandler)

    if err := e.Start(":4000"); err != nil {
        log.Fatal(err)
    }
    // Access with API key at http://localhost:4000/secure/swagger
}
```

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

### Stoplight Elements with Embedded OpenAPI Spec

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Example showing how to embed OpenAPI specification as a string using go:embed directive and register with Stoplight Elements. Uses ElementsConfig with Spec field for inline specification instead of external URL.

```go
// Using the `go:embed` directive is a great way to embed the OpenAPI Spec file as a string.
//go:embed openai-openapi.yaml
var OpenAIAPISpec string

// Register the Stoplight Elements documentation with OpenAPI Spec string.
openapidocs.ElementsDocuments(e, "/docs", openapidocs.ElementsConfig{
	Spec: OpenAIAPISpec,
})
```

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

### Create Custom ReDoc Handler in Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

This example sets up a custom Echo handler for ReDoc with a remote OpenAPI spec URL, integrated with logging, recovery, and Gzip middleware. It serves version-specific documentation and includes a health check endpoint. Dependencies are echo-openapidocs and Echo; inputs are the spec URL and config, outputs are the handler and additional endpoints. Limitations involve network access for the spec URL and middleware configuration.

```go
package main

import (
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

func main() {
    e := echo.New()

    // Create ReDoc handler
    redocHandler := openapidocs.RedocDocumentsHandler(openapidocs.RedocConfig{
        SpecUrl:                        "https://cdn.example.com/api-spec.yaml",
        Title:                          "Versioned API Documentation",
        DisableSearch:                  false,
        MinCharacterLengthToInitSearch: 2,
    })

    // Version-specific documentation with logging
    v1Docs := e.Group("/v1/docs")
    v1Docs.Use(middleware.Logger())
    v1Docs.Use(middleware.Recover())
    v1Docs.Use(middleware.Gzip())
    v1Docs.GET("*", redocHandler)

    // Additional health check endpoint
    e.GET("/v1/docs/health", func(c echo.Context) error {
        return c.JSON(200, map[string]string{"status": "healthy"})
    })

    if err := e.Start(":5000"); err != nil {
        log.Fatal(err)
    }
}
```

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

### Scalar API Reference with Embedded OpenAPI Spec

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Example showing how to embed OpenAPI specification as a string using go:embed directive and register with Scalar API Reference. Uses ScalarConfig with Spec field for inline specification instead of external URL.

```go
// Using the `go:embed` directive is a great way to embed the OpenAPI Spec file as a string.
//go:embed openai-openapi.yaml
var OpenAIAPISpec string

// Register the Scalar documentation with OpenAPI Spec string.
openapidocs.ScalarDocuments(e, "/docs", openapidocs.ScalarConfig{
	Spec: OpenAIAPISpec,
})
```

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

### ReDoc: Register OpenAPI Docs with URL

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Registers ReDoc documentation with a specified OpenAPI Spec URL. This provides a clean, responsive API reference documentation. The function takes the Echo instance, a route path, and a RedocConfig containing the SpecUrl.

```go
// Register the Redoc documentation with OpenAPI Spec url.
openapidocs.RedocDocuments(e, "/docs", openapidocs.RedocConfig{
	// The following is the example for generating the OpenAI API documentation.
	// You can replace the SpecUrl with your OpenAPI Spec url.
	SpecUrl: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
})
```

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

### Register ReDoc Documentation Handler - Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler to serve API documentation using ReDoc with configurable options like title, search settings, and specification source (embedded or remote).

```go
package main

import (
    _ "embed"
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
)

//go:embed specs/api.yaml
var embeddedSpec string

func main() {
    e := echo.New()

    // ReDoc with embedded specification
    openapidocs.RedocDocuments(e, "/redoc", openapidocs.RedocConfig{
        Spec:                           embeddedSpec,
        Title:                          "E-commerce API",
        DisableSearch:                  false,
        MinCharacterLengthToInitSearch: 3,
    })

    // ReDoc with remote specification
    openapidocs.RedocDocuments(e, "/redoc/public", openapidocs.RedocConfig{
        SpecUrl:                        "https://api.example.com/openapi.yaml",
        Title:                          "Public API",
        DisableSearch:                 true,
        MinCharacterLengthToInitSearch: 0,
    })

    if err := e.Start(":8000"); err != nil {
        log.Fatal(err)
    }
    // Documentation available at http://localhost:8000/redoc
}
```

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

### Create Custom Elements Handler - Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Creates an Echo handler function for Stoplight Elements with configurable layout, authentication, and display options.

```go
package main

import (
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

func main() {
    e := echo.New()

    // Create handler with full configuration
    elementsHandler := openapidocs.ElementsDocumentsHandler(openapidocs.ElementsConfig{
        SpecUrl:                "https://api.example.com/spec.yaml",
        Title:                  "Protected API Docs",
        Layout:                 openapidocs.ElementsLayoutResponsive,
        Router:                 openapidocs.ElementsRouterMemory,
        HideInternal:           true,
        HideExport:             true,
        TryItCredentialsPolicy: openapidocs.ElementsTryItCredentialsInclude,
        Logo:                   "https://example.com/logo.png",
    })

    // Apply authentication middleware to documentation
    docsGroup := e.Group("/docs")
    docsGroup.Use(middleware.BasicAuth(func(username, password string, c echo.Context) (bool, error) {
        return username == "admin" && password == "secret", nil
    }))
    docsGroup.GET("*", elementsHandler)

    if err := e.Start(":8080"); err != nil {
        log.Fatal(err)
    }
    // Access with basic auth at http://localhost:8080/docs
}
```

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

### Swagger UI: Register OpenAPI Docs with URL

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Registers Swagger UI documentation with a specified OpenAPI Spec URL. This allows dynamic generation of API documentation from a remote YAML file. It takes the Echo instance, a route path, and a SwaggerUIConfig with the SpecUrl.

```go
// Register the SwaggerUI documentation with OpenAPI Spec url.
openapidocs.SwaggerUIDocuments(e, "/docs", openapidocs.SwaggerUIConfig{
	// The following is the example for generating the OpenAI API documentation.
	// You can replace the SpecUrl with your OpenAPI Spec url.
	SpecUrl: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
})
```

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

### ElementsDocuments - Register Stoplight Elements Documentation

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler to serve interactive API documentation using Stoplight Elements. This function creates routes to display the documentation UI and optionally serves the OpenAPI specification file if embedded.

```APIDOC
## ElementsDocuments - Register Stoplight Elements Documentation

### Description
Registers a handler to serve interactive API documentation using Stoplight Elements. This function creates routes to display the documentation UI and optionally serves the OpenAPI specification file if embedded.

### Method
POST

### Endpoint
/docs

### Parameters
#### Query Parameters
None

#### Request Body
- **Spec** (string) - Required - The OpenAPI specification content as a string.
- **SpecUrl** (string) - Optional - The URL of the OpenAPI specification.
- **Title** (string) - Optional - The title to display for the documentation.
- **Layout** (string) - Optional - The layout for the documentation (e.g., `ElementsLayoutSidebar`).
- **Router** (string) - Optional - The router type for the documentation (e.g., `ElementsRouterHistory`).
- **HideTryIt** (bool) - Optional - Whether to hide the "Try It" functionality.
- **HideSchemas** (bool) - Optional - Whether to hide the schemas section.
- **TryItCorsProxy** (string) - Optional - The URL for a CORS proxy to use with the "Try It" functionality.

### Request Example
```json
{
  "Spec": "openapi.yaml content",
  "Title": "My API Documentation",
  "Layout": "ElementsLayoutSidebar",
  "Router": "ElementsRouterHistory",
  "HideTryIt": false,
  "HideSchemas": false,
  "TryItCorsProxy": "https://cors-proxy.example.com"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful registration of the documentation handler.

#### Response Example
```json
{
  "message": "Stoplight Elements documentation registered successfully at /docs"
}
```
```

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

### Create Custom Scalar Handler - Go

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Creates an Echo handler function for Scalar documentation with configurable theme, layout, and rate limiting middleware.

```go
package main

import (
    "log"
    "time"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

func main() {
    e := echo.New()

    // Create Scalar handler with custom configuration
    scalarHandler := openapidocs.ScalarDocumentsHandler(openapidocs.ScalarConfig{
        SpecUrl:      "https://api.example.com/openapi.json",
        Title:        "Rate Limited API Docs",
        Theme:        openapidocs.ScalarThemeDeepSpace,
        Layout:       openapidocs.ScalarLayoutClassic,
        DarkMode:     true,
        IsEditable:   false,
        HideSidebar:  false,
        SearchHotKey: "/",
    })

    // Apply rate limiting to documentation endpoint
    apiDocs := e.Group("/api/docs")
    apiDocs.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))
    apiDocs.Use(middleware.TimeoutWithConfig(middleware.TimeoutConfig{
        Timeout: 30 * time.Second,
    }))
    apiDocs.GET("*", scalarHandler)

    if err := e.Start(":9000"); err != nil {
        log.Fatal(err)
    }
}
```

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

### ReDoc: Register OpenAPI Docs with Embedded String

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Registers ReDoc documentation using an OpenAPI Spec embedded as a string. This method bundles the API specification directly into the application binary. It uses `go:embed` to load the spec and passes it via the Spec field in RedocConfig.

```go
// Using the `go:embed` directive is a great way to embed the OpenAPI Spec file as a string.
//go:embed openai-openapi.yaml
var OpenAIAPISpec string

// Register the Redoc documentation with OpenAPI Spec string.
openapidocs.RedocDocuments(e, "/docs", openapidocs.RedocConfig{
	Spec: OpenAIAPISpec,
})
```

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

### Register Stoplight Elements Documentation with Echo

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler for Stoplight Elements, an interactive API documentation generator. It supports both embedded OpenAPI specification strings and remote URLs, offering customization options for title, layout, router, and CORS proxy.

```go
package main

import (
    _ "embed"
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
)

//go:embed openapi.yaml
var apiSpec string

func main() {
    e := echo.New()

    // Using embedded OpenAPI spec
    openapidocs.ElementsDocuments(e, "/docs", openapidocs.ElementsConfig{
        Spec:           apiSpec,
        Title:          "My API Documentation",
        Layout:         openapidocs.ElementsLayoutSidebar,
        Router:         openapidocs.ElementsRouterHistory,
        HideTryIt:      false,
        HideSchemas:    false,
        TryItCorsProxy: "https://cors-proxy.example.com",
    })

    // Using remote OpenAPI spec URL
    openapidocs.ElementsDocuments(e, "/docs/github", openapidocs.ElementsConfig{
        SpecUrl: "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/ghes-3.0/ghes-3.0.yaml",
        Title:   "GitHub v3 REST API",
    })

    if err := e.Start(":8080"); err != nil {
        log.Fatal(err)
    }
    // Access documentation at http://localhost:8080/docs
}
```

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

### ScalarDocuments - Register Scalar API Reference

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler to serve API documentation using Scalar, a modern OpenAPI documentation renderer with customizable themes and layouts.

```APIDOC
## ScalarDocuments - Register Scalar API Reference

### Description
Registers a handler to serve API documentation using Scalar, a modern OpenAPI documentation renderer with customizable themes and layouts.

### Method
POST

### Endpoint
/api-docs

### Parameters
#### Query Parameters
None

#### Request Body
- **Spec** (string) - Required - The OpenAPI specification content as a string.
- **SpecUrl** (string) - Optional - The URL of the OpenAPI specification.
- **Title** (string) - Optional - The title for the API reference.
- **DarkMode** (bool) - Optional - Enables dark mode for the documentation.
- **Theme** (string) - Optional - The theme for Scalar (e.g., `ScalarThemeMoon`).
- **Layout** (string) - Optional - The layout for Scalar (e.g., `ScalarLayoutModern`).
- **IsEditable** (bool) - Optional - Enables an editable version of the API reference.
- **HideSidebar** (bool) - Optional - Hides the sidebar in the documentation.
- **SearchHotKey** (string) - Optional - The hotkey for search functionality.
- **ProxyUrl** (string) - Optional - A URL for a proxy to handle requests.

### Request Example
```json
{
  "Spec": "api-spec.yaml content",
  "Title": "Product API Reference",
  "DarkMode": true,
  "Theme": "ScalarThemeMoon",
  "Layout": "ScalarLayoutModern",
  "IsEditable": true,
  "HideSidebar": false,
  "SearchHotKey": "k",
  "ProxyUrl": "https://proxy.example.com"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful registration of the documentation handler.

#### Response Example
```json
{
  "message": "Scalar documentation registered successfully at /api-docs"
}
```
```

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

### SwaggerUIDocuments - Register Swagger UI Documentation

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler to serve API documentation using the classic Swagger UI interface, widely recognized and feature-rich for exploring APIs.

```APIDOC
## SwaggerUIDocuments - Register Swagger UI Documentation

### Description
Registers a handler to serve API documentation using the classic Swagger UI interface, widely recognized and feature-rich for exploring APIs.

### Method
POST

### Endpoint
/swagger

### Parameters
#### Query Parameters
None

#### Request Body
- **SpecUrl** (string) - Required - The URL of the OpenAPI specification.
- **Title** (string) - Optional - The title to display in Swagger UI.
- **DeepLinking** (bool) - Optional - Enables deep linking within Swagger UI.
- **DisplayOperationId** (bool) - Optional - Displays the operation ID for each endpoint.

### Request Example
```json
{
  "SpecUrl": "https://petstore3.swagger.io/api/v3/openapi.json",
  "Title": "Petstore API",
  "DeepLinking": true,
  "DisplayOperationId": true
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful registration of the documentation handler.

#### Response Example
```json
{
  "message": "Swagger UI documentation registered successfully at /swagger"
}
```
```

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

### Swagger UI: Register OpenAPI Docs with Embedded String

Source: https://github.com/kohkimakimoto/echo-openapidocs/blob/main/README.md

Registers Swagger UI documentation using an OpenAPI Spec embedded as a string within the Go application. This is useful for including the specification directly in the binary. It utilizes the `go:embed` directive and passes the spec as a string in SwaggerUIConfig.

```go
// Using the `go:embed` directive is a great way to embed the OpenAPI Spec file as a string.
//go:embed openai-openapi.yaml
var OpenAIAPISpec string

// Register the SwaggerUI documentation with OpenAPI Spec string.
openapidocs.SwaggerUIDocuments(e, "/docs", openapidocs.SwaggerUIConfig{
	Spec: OpenAIAPISpec,
})
```

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

### Register Swagger UI Documentation with Echo

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler for Swagger UI, a widely used interface for visualizing and interacting with APIs. It supports remote OpenAPI specification URLs and allows configuration of options like deep linking and displaying operation IDs.

```go
package main

import (
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
)

func main() {
    e := echo.New()

    // Basic Swagger UI setup with remote spec
    openapidocs.SwaggerUIDocuments(e, "/swagger", openapidocs.SwaggerUIConfig{
        SpecUrl:            "https://petstore3.swagger.io/api/v3/openapi.json",
        Title:              "Petstore API",
        DeepLinking:        true,
        DisplayOperationId: true,
    })

    // Custom configuration for internal API
    openapidocs.SwaggerUIDocuments(e, "/internal/swagger", openapidocs.SwaggerUIConfig{
        SpecUrl:            "https://internal-api.company.com/spec.yaml",
        Title:              "Internal Services API",
        DeepLinking:        false,
        DisplayOperationId: false,
    })

    e.Logger.Info("Swagger UI available at http://localhost:8080/swagger")

    if err := e.Start(":8080"); err != nil {
        log.Fatal(err)
    }
}
```

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

### Register Scalar API Reference Documentation with Echo

Source: https://context7.com/kohkimakimoto/echo-openapidocs/llms.txt

Registers a handler for Scalar, a modern OpenAPI documentation renderer. This function allows configuration of OpenAPI specifications (embedded or remote), titles, themes, layouts, and UI elements like dark mode and editable fields.

```go
package main

import (
    _ "embed"
    "log"

    openapidocs "github.com/kohkimakimoto/echo-openapidocs"
    "github.com/labstack/echo/v4"
)

//go:embed api-spec.yaml
var apiSpecification string

func main() {
    e := echo.New()

    // Configure Scalar with custom theme and layout
    openapidocs.ScalarDocuments(e, "/api-docs", openapidocs.ScalarConfig{
        Spec:         apiSpecification,
        Title:        "Product API Reference",
        DarkMode:     true,
        Theme:        openapidocs.ScalarThemeMoon,
        Layout:       openapidocs.ScalarLayoutModern,
        IsEditable:   true,
        HideSidebar:  false,
        SearchHotKey: "k",
        ProxyUrl:     "https://proxy.example.com",
    })

    // Multiple documentation endpoints
    openapidocs.ScalarDocuments(e, "/api-docs/v2", openapidocs.ScalarConfig{
        SpecUrl: "https://api.example.com/openapi-v2.yaml",
        Title:   "API v2",
    })

    if err := e.Start(":3000"); err != nil {
        log.Fatal(err)
    }
    // Access at http://localhost:3000/api-docs
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.