api.gen.go

// Package api provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.3.0 DO NOT EDIT.
package api

import (
	"bytes"
	"compress/gzip"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"path"
	"strings"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/gorilla/mux"
	"github.com/oapi-codegen/runtime"
)

const (
	DeveloperTokenScopes = "DeveloperToken.Scopes"
)

// Defines values for PublicModulePortType.
const (
	Source PublicModulePortType = "source"
	Target PublicModulePortType = "target"
)

// BuildPushOptions defines model for BuildPushOptions.
type BuildPushOptions struct {
	Password string `json:"password"`
	Repo     string `json:"repo"`
	Tag      string `json:"tag"`
	Username string `json:"username"`
}

// BundledDependency A Helm release the module offers to provision on install. Author-declared values cover the common case; exposedSchema lets the user override a subset via the install form.
type BundledDependency struct {
	// ChartName Chart name within the repo.
	ChartName string `json:"chartName"`

	// ChartRepo Helm repository URL.
	ChartRepo string `json:"chartRepo"`

	// ChartVersion Pinned chart version. Empty means use latest at install time (not recommended).
	ChartVersion *string `json:"chartVersion,omitempty"`

	// ConnectionHint Hint shown to the user about how the module reaches the bundle — typically the in-cluster Service URL (e.g. http://tei.tei.svc.cluster.local:80) and which module setting field receives it.
	ConnectionHint *string `json:"connectionHint,omitempty"`

	// DefaultEnabled Whether the install-form checkbox starts checked.
	DefaultEnabled *bool `json:"defaultEnabled,omitempty"`

	// Description Shown next to the checkbox in the install UI.
	Description *string `json:"description,omitempty"`

	// ExposedSchema JSON Schema fragment defining which value keys the install form exposes as user-editable fields. Same renderer the flow editor uses. Empty means the bundle is install-as-is, no user knobs.
	ExposedSchema *map[string]interface{} `json:"exposedSchema,omitempty"`

	// Name Stable identifier — becomes the bundle's Helm release name and the install-form checkbox label.
	Name string `json:"name"`

	// Values Author-supplied default values passed to the bundle's chart. Map of any-typed values. Merged on top of chart defaults at install time, then overlaid by user overrides.
	Values *map[string]interface{} `json:"values,omitempty"`

	// ValuesYAML Optional raw values.yaml content for complex bundles where the structured values map is awkward. Merged before values map (which takes precedence).
	ValuesYAML *string `json:"valuesYAML,omitempty"`
}

// HelmBundle Selector into the operator chart's curated subchart set. Name
// must match a registered subchart alias (e.g. "tei", "pgvector").
// When the user ticks the bundle's checkbox in the install UI,
// the bundle's set_flags get appended to the module helm command —
// one release, one upgrade unit, helm-tracked lifecycle.
type HelmBundle struct {
	// ConnectionHint Free-form note telling the module how to reach this bundle
	// once installed (e.g. "DATABASE_URL=postgres://...").
	ConnectionHint *string `json:"connection_hint,omitempty"`
	DefaultEnabled *bool   `json:"default_enabled,omitempty"`
	Description    *string `json:"description,omitempty"`

	// ExposedSchema JSON Schema fragment driving per-bundle form fields on the install page
	ExposedSchema *map[string]interface{} `json:"exposed_schema,omitempty"`
	Name          string                  `json:"name"`

	// SetFlags Author defaults rendered as --set flags (e.g.
	// "--set bundles.tei.image.tag=cpu-1.5"). UI appends these
	// for every ticked bundle, alongside "--set bundles.<name>.enabled=true".
	SetFlags *[]string `json:"set_flags,omitempty"`
}

// HelmConfigField defines model for HelmConfigField.
type HelmConfigField struct {
	DefaultValue *string   `json:"default_value,omitempty"`
	Description  *string   `json:"description,omitempty"`
	Label        *string   `json:"label,omitempty"`
	Name         *string   `json:"name,omitempty"`
	Options      *[]string `json:"options,omitempty"`
	Placeholder  *string   `json:"placeholder,omitempty"`
	Required     *bool     `json:"required,omitempty"`

	// Type text or select
	Type *string `json:"type,omitempty"`
}

// HelmInstallConfig Helm installation instructions the caller can render verbatim.
// The `command` field is a copy-pasteable template with placeholders
// (e.g. `<NAMESPACE>`) that map to entries in `fields`. Prerequisites
// and warnings are plain strings meant for display.
type HelmInstallConfig struct {
	// Bundles Self-contained helm install snippets for each third-party
	// release the module declared. UI renders a checkbox per
	// entry; checked bundles' commands get appended to the
	// module command before paste.
	Bundles   *[]HelmBundle `json:"bundles,omitempty"`
	ChartName *string       `json:"chart_name,omitempty"`
	ChartRepo *string       `json:"chart_repo,omitempty"`

	// Command Helm install command template with placeholders
	Command         *string            `json:"command,omitempty"`
	Fields          *[]HelmConfigField `json:"fields,omitempty"`
	Prerequisites   *[]string          `json:"prerequisites,omitempty"`
	RequiresIngress *bool              `json:"requires_ingress,omitempty"`
	RequiresStorage *bool              `json:"requires_storage,omitempty"`
	Warnings        *[]string          `json:"warnings,omitempty"`
}

// ModuleRequirements defines model for ModuleRequirements.
type ModuleRequirements struct {
	// Bundles Third-party Helm releases the module can install alongside itself (e.g. embedding-module ships TEI, database-extension ships pgvector). Install UI exposes one toggle per bundle; enabled bundles get their own helm install in the same namespace.
	Bundles *[]BundledDependency `json:"bundles,omitempty"`
	Rbac    *RBACRequirements    `json:"rbac,omitempty"`

	// Secrets Declares the k8s Secrets a module needs to read. Install UI
	// prompts the user to supply the actual Secret names; chart
	// Role's resourceNames is pinned to those values. Module code
	// resolves placeholders via pkg/secret.Resolve at OnSettings
	// time. Empty means the module consumes no Secrets and no
	// Role is created.
	Secrets *SecretRequirements `json:"secrets,omitempty"`

	// Storage Persistent storage needs declared by the module. When enabled, the install flow exposes storage-size / storage-class fields and the helm command includes the PVC switches.
	Storage *StorageRequirements `json:"storage,omitempty"`
}

// PublicModuleComponent A component inside a module: its name, the description and info
// the component author wrote, its tags, and the typed ports it
// exposes.
type PublicModuleComponent struct {
	Description *string `json:"description,omitempty"`

	// Info Author-written operational notes; the LLM should read this before wiring the component
	Info *string `json:"info,omitempty"`

	// Name Component identifier (e.g. "ticker", "http_server")
	Name  string              `json:"name"`
	Ports *[]PublicModulePort `json:"ports,omitempty"`
	Tags  *[]string           `json:"tags,omitempty"`
}

// PublicModuleDetails Full module payload returned by `/v1/modules/{name}`. Equivalent
// to the summary plus the full latest version, every component with
// port schemas, the RBAC permissions the module needs, and the helm
// install configuration that desktop/local installers use.
type PublicModuleDetails struct {
	Description string  `json:"description"`
	FullName    *string `json:"full_name,omitempty"`

	// HelmInstall Helm installation instructions the caller can render verbatim.
	// The `command` field is a copy-pasteable template with placeholders
	// (e.g. `<NAMESPACE>`) that map to entries in `fields`. Prerequisites
	// and warnings are plain strings meant for display.
	HelmInstall   *HelmInstallConfig          `json:"helm_install,omitempty"`
	LatestVersion *PublicModuleVersionDetails `json:"latest_version,omitempty"`
	Name          string                      `json:"name"`
	Verified      *bool                       `json:"verified,omitempty"`
}

// PublicModulePermission Kubernetes RBAC rule required by the module
type PublicModulePermission struct {
	ApiGroups *[]string `json:"api_groups,omitempty"`
	Resources *[]string `json:"resources,omitempty"`
	Verbs     *[]string `json:"verbs,omitempty"`
}

// PublicModulePort defines model for PublicModulePort.
type PublicModulePort struct {
	// DefaultData Sample data for the port, usable as example input
	DefaultData *map[string]interface{} `json:"default_data,omitempty"`
	Description *string                 `json:"description,omitempty"`
	Name        string                  `json:"name"`

	// Schema JSON Schema describing the port's data shape
	Schema *map[string]interface{} `json:"schema,omitempty"`

	// Type source or target
	Type PublicModulePortType `json:"type"`
}

// PublicModulePortType source or target
type PublicModulePortType string

// PublicModuleSearchResponse defines model for PublicModuleSearchResponse.
type PublicModuleSearchResponse struct {
	Results []PublicModuleSummary `json:"results"`
}

// PublicModuleSummary Lightweight module entry returned by `/v1/modules/search`. Carries
// enough for the caller to choose a module to install; follow up
// with `/v1/modules/{name}` for components and install instructions.
type PublicModuleSummary struct {
	Description string `json:"description"`

	// FullName Human-readable display name
	FullName      *string                     `json:"full_name,omitempty"`
	LatestVersion *PublicModuleVersionSummary `json:"latest_version,omitempty"`

	// Name Workspace-qualified module name (e.g. "tinysystems/common-module-v0")
	Name string `json:"name"`

	// Verified Whether the module has been verified by Tiny Systems
	Verified *bool `json:"verified,omitempty"`
}

// PublicModuleVersionDetails defines model for PublicModuleVersionDetails.
type PublicModuleVersionDetails struct {
	// Bundles Third-party Helm releases the module declares for install-time
	// provisioning. Same shape as ModuleRequirements.bundles. Empty
	// (or absent) for modules that don't bundle anything.
	Bundles      *[]BundledDependency      `json:"bundles,omitempty"`
	Components   []PublicModuleComponent   `json:"components"`
	Permissions  *[]PublicModulePermission `json:"permissions,omitempty"`
	ReleaseNotes *string                   `json:"release_notes,omitempty"`

	// Repo Container image repository
	Repo                     *string `json:"repo,omitempty"`
	RequiresKubernetesAccess *bool   `json:"requires_kubernetes_access,omitempty"`
	SdkVersion               *string `json:"sdk_version,omitempty"`

	// Tag Container image tag
	Tag     *string `json:"tag,omitempty"`
	Version string  `json:"version"`
}

// PublicModuleVersionSummary defines model for PublicModuleVersionSummary.
type PublicModuleVersionSummary struct {
	// RequiresKubernetesAccess Module needs RBAC access to the Kubernetes API
	RequiresKubernetesAccess *bool   `json:"requires_kubernetes_access,omitempty"`
	SdkVersion               *string `json:"sdk_version,omitempty"`
	Version                  string  `json:"version"`
}

// PublishComponent defines model for PublishComponent.
type PublishComponent struct {
	Description string                  `json:"description"`
	Info        *string                 `json:"info,omitempty"`
	Name        string                  `json:"name"`
	Ports       *[]PublishComponentPort `json:"ports,omitempty"`
	Tags        *[]string               `json:"tags,omitempty"`
}

// PublishComponentPort defines model for PublishComponentPort.
type PublishComponentPort struct {
	DefaultData *map[string]interface{} `json:"default_data,omitempty"`
	Label       *string                 `json:"label,omitempty"`
	Name        string                  `json:"name"`
	Position    *int                    `json:"position,omitempty"`
	Schema      *map[string]interface{} `json:"schema,omitempty"`
	Source      bool                    `json:"source"`
}

// PublishModuleRequest defines model for PublishModuleRequest.
type PublishModuleRequest struct {
	Components   []PublishComponent  `json:"components"`
	Description  *string             `json:"description,omitempty"`
	Info         *string             `json:"info,omitempty"`
	Name         string              `json:"name"`
	Requirements *ModuleRequirements `json:"requirements,omitempty"`

	// SdkVersion SDK version used to build this module
	SdkVersion *string `json:"sdk_version,omitempty"`
	Version    string  `json:"version"`
}

// PublishModuleResult defines model for PublishModuleResult.
type PublishModuleResult struct {
	Module  *PublishModuleVersion `json:"module,omitempty"`
	Options *BuildPushOptions     `json:"options,omitempty"`
}

// PublishModuleVersion defines model for PublishModuleVersion.
type PublishModuleVersion struct {
	Id      string `json:"id"`
	Name    string `json:"name"`
	Version string `json:"version"`
}

// RBACRequirements defines model for RBACRequirements.
type RBACRequirements struct {
	// EnableKubernetesResourceAccess Enable access to pods, services, deployments, ingresses
	EnableKubernetesResourceAccess *bool       `json:"enableKubernetesResourceAccess,omitempty"`
	ExtraRules                     *[]RBACRule `json:"extraRules,omitempty"`
}

// RBACRule defines model for RBACRule.
type RBACRule struct {
	ApiGroups *[]string `json:"apiGroups,omitempty"`
	Resources *[]string `json:"resources,omitempty"`
	Verbs     *[]string `json:"verbs,omitempty"`
}

// SecretRequirements Declares the k8s Secrets a module needs to read. Install UI
// prompts the user to supply the actual Secret names; chart
// Role's resourceNames is pinned to those values. Module code
// resolves placeholders via pkg/secret.Resolve at OnSettings
// time. Empty means the module consumes no Secrets and no
// Role is created.
type SecretRequirements struct {
	// Names List of Secret names the module may reference (pre-flight allowlist).
	Names *[]string `json:"names,omitempty"`
}

// SolutionDetails Full solution structure returned by `/v1/solutions/{uuid}`.
// Contains every flow with its nodes, edges, and configurations,
// plus any solution-level variables.
type SolutionDetails struct {
	Description string                    `json:"description"`
	Flows       []SolutionFlow            `json:"flows"`
	Tags        *[]string                 `json:"tags,omitempty"`
	Title       string                    `json:"title"`
	Uuid        string                    `json:"uuid"`
	Variables   *[]map[string]interface{} `json:"variables,omitempty"`
}

// SolutionEdge defines model for SolutionEdge.
type SolutionEdge struct {
	Configuration *map[string]interface{} `json:"configuration,omitempty"`
	Source        string                  `json:"source"`
	SourceHandle  string                  `json:"source_handle"`
	Target        string                  `json:"target"`
	TargetHandle  string                  `json:"target_handle"`
}

// SolutionFlow defines model for SolutionFlow.
type SolutionFlow struct {
	Edges []SolutionEdge `json:"edges"`
	Nodes []SolutionNode `json:"nodes"`
	Title string         `json:"title"`
}

// SolutionNode defines model for SolutionNode.
type SolutionNode struct {
	Component string                  `json:"component"`
	Id        string                  `json:"id"`
	Module    string                  `json:"module"`
	Position  *map[string]interface{} `json:"position,omitempty"`
	Settings  *map[string]interface{} `json:"settings,omitempty"`
}

// SolutionSearchResponse defines model for SolutionSearchResponse.
type SolutionSearchResponse struct {
	Results []SolutionSummary `json:"results"`
}

// SolutionSummary Brief overview of a solution returned by `/v1/solutions/search`.
// Carries enough for the caller to render a result row and decide
// whether to fetch the full details.
type SolutionSummary struct {
	Description string    `json:"description"`
	Tags        *[]string `json:"tags,omitempty"`
	Title       string    `json:"title"`

	// Uuid Stable solution identifier, used with `/v1/solutions/{uuid}`
	Uuid string `json:"uuid"`
}

// StorageRequirements Persistent storage needs declared by the module. When enabled, the install flow exposes storage-size / storage-class fields and the helm command includes the PVC switches.
type StorageRequirements struct {
	// Enabled True when the module requires a PVC to function (e.g. file-backed embedded stores).
	Enabled *bool `json:"enabled,omitempty"`

	// Size Default storage size suggestion (e.g. 1Gi, 10Gi). Author hint; UI lets the operator override.
	Size *string `json:"size,omitempty"`

	// StorageClassName Default storage class suggestion. Empty uses the cluster default.
	StorageClassName *string `json:"storageClassName,omitempty"`
}

// UpdateModuleVersionRequest defines model for UpdateModuleVersionRequest.
type UpdateModuleVersionRequest struct {
	// Id Module Version ID
	Id string `json:"id"`

	// Repo Image repo
	Repo string `json:"repo"`

	// Tag Image tag
	Tag string `json:"tag"`
}

// SearchPublicModulesParams defines parameters for SearchPublicModules.
type SearchPublicModulesParams struct {
	// Q Keyword query matched against module name and description
	Q *string `form:"q,omitempty" json:"q,omitempty"`

	// Limit Maximum results to return
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
}

// ExportSolutionParams defines parameters for ExportSolution.
type ExportSolutionParams struct {
	// Token One-time export token
	Token string `form:"token" json:"token"`
}

// SearchPublicSolutionsParams defines parameters for SearchPublicSolutions.
type SearchPublicSolutionsParams struct {
	// Q Keyword query matched against title, description, and tags
	Q *string `form:"q,omitempty" json:"q,omitempty"`

	// Tags Tag filter; repeat the parameter for multiple tags
	Tags *[]string `form:"tags,omitempty" json:"tags,omitempty"`

	// Limit Maximum results to return
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
}

// PublishModuleJSONRequestBody defines body for PublishModule for application/json ContentType.
type PublishModuleJSONRequestBody = PublishModuleRequest

// UpdateModuleVersionJSONRequestBody defines body for UpdateModuleVersion for application/json ContentType.
type UpdateModuleVersionJSONRequestBody = UpdateModuleVersionRequest

// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// PublishModuleWithBody request with any body
	PublishModuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PublishModule(ctx context.Context, body PublishModuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateModuleVersionWithBody request with any body
	UpdateModuleVersionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	UpdateModuleVersion(ctx context.Context, body UpdateModuleVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// HealthCheck request
	HealthCheck(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SearchPublicModules request
	SearchPublicModules(ctx context.Context, params *SearchPublicModulesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetPublicModule request
	GetPublicModule(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ExportSolution request
	ExportSolution(ctx context.Context, params *ExportSolutionParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SearchPublicSolutions request
	SearchPublicSolutions(ctx context.Context, params *SearchPublicSolutionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetPublicSolution request
	GetPublicSolution(ctx context.Context, uuid string, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) PublishModuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPublishModuleRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PublishModule(ctx context.Context, body PublishModuleJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPublishModuleRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateModuleVersionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateModuleVersionRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) UpdateModuleVersion(ctx context.Context, body UpdateModuleVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewUpdateModuleVersionRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) HealthCheck(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewHealthCheckRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SearchPublicModules(ctx context.Context, params *SearchPublicModulesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSearchPublicModulesRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetPublicModule(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetPublicModuleRequest(c.Server, name)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ExportSolution(ctx context.Context, params *ExportSolutionParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewExportSolutionRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SearchPublicSolutions(ctx context.Context, params *SearchPublicSolutionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSearchPublicSolutionsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetPublicSolution(ctx context.Context, uuid string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetPublicSolutionRequest(c.Server, uuid)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewPublishModuleRequest calls the generic PublishModule builder with application/json body
func NewPublishModuleRequest(server string, body PublishModuleJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPublishModuleRequestWithBody(server, "application/json", bodyReader)
}

// NewPublishModuleRequestWithBody generates requests for PublishModule with any type of body
func NewPublishModuleRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/devtools/publish-module")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewUpdateModuleVersionRequest calls the generic UpdateModuleVersion builder with application/json body
func NewUpdateModuleVersionRequest(server string, body UpdateModuleVersionJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewUpdateModuleVersionRequestWithBody(server, "application/json", bodyReader)
}

// NewUpdateModuleVersionRequestWithBody generates requests for UpdateModuleVersion with any type of body
func NewUpdateModuleVersionRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/devtools/update-module-version")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewHealthCheckRequest generates requests for HealthCheck
func NewHealthCheckRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/health")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSearchPublicModulesRequest generates requests for SearchPublicModules
func NewSearchPublicModulesRequest(server string, params *SearchPublicModulesParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/modules/search")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Q != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "q", runtime.ParamLocationQuery, *params.Q); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Limit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetPublicModuleRequest generates requests for GetPublicModule
func NewGetPublicModuleRequest(server string, name string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/modules/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewExportSolutionRequest generates requests for ExportSolution
func NewExportSolutionRequest(server string, params *ExportSolutionParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/solutions/export")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "token", runtime.ParamLocationQuery, params.Token); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSearchPublicSolutionsRequest generates requests for SearchPublicSolutions
func NewSearchPublicSolutionsRequest(server string, params *SearchPublicSolutionsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/solutions/search")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Q != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "q", runtime.ParamLocationQuery, *params.Q); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Tags != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "tags", runtime.ParamLocationQuery, *params.Tags); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Limit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetPublicSolutionRequest generates requests for GetPublicSolution
func NewGetPublicSolutionRequest(server string, uuid string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "uuid", runtime.ParamLocationPath, uuid)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/v1/solutions/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// PublishModuleWithBodyWithResponse request with any body
	PublishModuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PublishModuleResponse, error)

	PublishModuleWithResponse(ctx context.Context, body PublishModuleJSONRequestBody, reqEditors ...RequestEditorFn) (*PublishModuleResponse, error)

	// UpdateModuleVersionWithBodyWithResponse request with any body
	UpdateModuleVersionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateModuleVersionResponse, error)

	UpdateModuleVersionWithResponse(ctx context.Context, body UpdateModuleVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateModuleVersionResponse, error)

	// HealthCheckWithResponse request
	HealthCheckWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthCheckResponse, error)

	// SearchPublicModulesWithResponse request
	SearchPublicModulesWithResponse(ctx context.Context, params *SearchPublicModulesParams, reqEditors ...RequestEditorFn) (*SearchPublicModulesResponse, error)

	// GetPublicModuleWithResponse request
	GetPublicModuleWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*GetPublicModuleResponse, error)

	// ExportSolutionWithResponse request
	ExportSolutionWithResponse(ctx context.Context, params *ExportSolutionParams, reqEditors ...RequestEditorFn) (*ExportSolutionResponse, error)

	// SearchPublicSolutionsWithResponse request
	SearchPublicSolutionsWithResponse(ctx context.Context, params *SearchPublicSolutionsParams, reqEditors ...RequestEditorFn) (*SearchPublicSolutionsResponse, error)

	// GetPublicSolutionWithResponse request
	GetPublicSolutionWithResponse(ctx context.Context, uuid string, reqEditors ...RequestEditorFn) (*GetPublicSolutionResponse, error)
}

type PublishModuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PublishModuleResult
}

// Status returns HTTPResponse.Status
func (r PublishModuleResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PublishModuleResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type UpdateModuleVersionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r UpdateModuleVersionResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r UpdateModuleVersionResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type HealthCheckResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r HealthCheckResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r HealthCheckResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SearchPublicModulesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PublicModuleSearchResponse
}

// Status returns HTTPResponse.Status
func (r SearchPublicModulesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SearchPublicModulesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetPublicModuleResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *PublicModuleDetails
}

// Status returns HTTPResponse.Status
func (r GetPublicModuleResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetPublicModuleResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ExportSolutionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]interface{}
}

// Status returns HTTPResponse.Status
func (r ExportSolutionResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ExportSolutionResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SearchPublicSolutionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SolutionSearchResponse
}

// Status returns HTTPResponse.Status
func (r SearchPublicSolutionsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SearchPublicSolutionsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetPublicSolutionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SolutionDetails
}

// Status returns HTTPResponse.Status
func (r GetPublicSolutionResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetPublicSolutionResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// PublishModuleWithBodyWithResponse request with arbitrary body returning *PublishModuleResponse
func (c *ClientWithResponses) PublishModuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PublishModuleResponse, error) {
	rsp, err := c.PublishModuleWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePublishModuleResponse(rsp)
}

func (c *ClientWithResponses) PublishModuleWithResponse(ctx context.Context, body PublishModuleJSONRequestBody, reqEditors ...RequestEditorFn) (*PublishModuleResponse, error) {
	rsp, err := c.PublishModule(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePublishModuleResponse(rsp)
}

// UpdateModuleVersionWithBodyWithResponse request with arbitrary body returning *UpdateModuleVersionResponse
func (c *ClientWithResponses) UpdateModuleVersionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateModuleVersionResponse, error) {
	rsp, err := c.UpdateModuleVersionWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateModuleVersionResponse(rsp)
}

func (c *ClientWithResponses) UpdateModuleVersionWithResponse(ctx context.Context, body UpdateModuleVersionJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateModuleVersionResponse, error) {
	rsp, err := c.UpdateModuleVersion(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseUpdateModuleVersionResponse(rsp)
}

// HealthCheckWithResponse request returning *HealthCheckResponse
func (c *ClientWithResponses) HealthCheckWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthCheckResponse, error) {
	rsp, err := c.HealthCheck(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseHealthCheckResponse(rsp)
}

// SearchPublicModulesWithResponse request returning *SearchPublicModulesResponse
func (c *ClientWithResponses) SearchPublicModulesWithResponse(ctx context.Context, params *SearchPublicModulesParams, reqEditors ...RequestEditorFn) (*SearchPublicModulesResponse, error) {
	rsp, err := c.SearchPublicModules(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSearchPublicModulesResponse(rsp)
}

// GetPublicModuleWithResponse request returning *GetPublicModuleResponse
func (c *ClientWithResponses) GetPublicModuleWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*GetPublicModuleResponse, error) {
	rsp, err := c.GetPublicModule(ctx, name, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetPublicModuleResponse(rsp)
}

// ExportSolutionWithResponse request returning *ExportSolutionResponse
func (c *ClientWithResponses) ExportSolutionWithResponse(ctx context.Context, params *ExportSolutionParams, reqEditors ...RequestEditorFn) (*ExportSolutionResponse, error) {
	rsp, err := c.ExportSolution(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseExportSolutionResponse(rsp)
}

// SearchPublicSolutionsWithResponse request returning *SearchPublicSolutionsResponse
func (c *ClientWithResponses) SearchPublicSolutionsWithResponse(ctx context.Context, params *SearchPublicSolutionsParams, reqEditors ...RequestEditorFn) (*SearchPublicSolutionsResponse, error) {
	rsp, err := c.SearchPublicSolutions(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSearchPublicSolutionsResponse(rsp)
}

// GetPublicSolutionWithResponse request returning *GetPublicSolutionResponse
func (c *ClientWithResponses) GetPublicSolutionWithResponse(ctx context.Context, uuid string, reqEditors ...RequestEditorFn) (*GetPublicSolutionResponse, error) {
	rsp, err := c.GetPublicSolution(ctx, uuid, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetPublicSolutionResponse(rsp)
}

// ParsePublishModuleResponse parses an HTTP response from a PublishModuleWithResponse call
func ParsePublishModuleResponse(rsp *http.Response) (*PublishModuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PublishModuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PublishModuleResult
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseUpdateModuleVersionResponse parses an HTTP response from a UpdateModuleVersionWithResponse call
func ParseUpdateModuleVersionResponse(rsp *http.Response) (*UpdateModuleVersionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &UpdateModuleVersionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseHealthCheckResponse parses an HTTP response from a HealthCheckWithResponse call
func ParseHealthCheckResponse(rsp *http.Response) (*HealthCheckResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &HealthCheckResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseSearchPublicModulesResponse parses an HTTP response from a SearchPublicModulesWithResponse call
func ParseSearchPublicModulesResponse(rsp *http.Response) (*SearchPublicModulesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SearchPublicModulesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PublicModuleSearchResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetPublicModuleResponse parses an HTTP response from a GetPublicModuleWithResponse call
func ParseGetPublicModuleResponse(rsp *http.Response) (*GetPublicModuleResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetPublicModuleResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest PublicModuleDetails
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseExportSolutionResponse parses an HTTP response from a ExportSolutionWithResponse call
func ParseExportSolutionResponse(rsp *http.Response) (*ExportSolutionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ExportSolutionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]interface{}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseSearchPublicSolutionsResponse parses an HTTP response from a SearchPublicSolutionsWithResponse call
func ParseSearchPublicSolutionsResponse(rsp *http.Response) (*SearchPublicSolutionsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SearchPublicSolutionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SolutionSearchResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGetPublicSolutionResponse parses an HTTP response from a GetPublicSolutionWithResponse call
func ParseGetPublicSolutionResponse(rsp *http.Response) (*GetPublicSolutionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetPublicSolutionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SolutionDetails
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ServerInterface represents all server handlers.
type ServerInterface interface {

	// (POST /v1/devtools/publish-module)
	PublishModule(w http.ResponseWriter, r *http.Request)

	// (POST /v1/devtools/update-module-version)
	UpdateModuleVersion(w http.ResponseWriter, r *http.Request)

	// (GET /v1/health)
	HealthCheck(w http.ResponseWriter, r *http.Request)
	// Search the public module catalog
	// (GET /v1/modules/search)
	SearchPublicModules(w http.ResponseWriter, r *http.Request, params SearchPublicModulesParams)
	// Get full details of a public module
	// (GET /v1/modules/{name})
	GetPublicModule(w http.ResponseWriter, r *http.Request, name string)
	// Export solution using one-time token
	// (GET /v1/solutions/export)
	ExportSolution(w http.ResponseWriter, r *http.Request, params ExportSolutionParams)
	// Search public solutions catalog
	// (GET /v1/solutions/search)
	SearchPublicSolutions(w http.ResponseWriter, r *http.Request, params SearchPublicSolutionsParams)
	// Get full details of a public solution
	// (GET /v1/solutions/{uuid})
	GetPublicSolution(w http.ResponseWriter, r *http.Request, uuid string)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type MiddlewareFunc func(http.Handler) http.Handler

// PublishModule operation middleware
func (siw *ServerInterfaceWrapper) PublishModule(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	ctx = context.WithValue(ctx, DeveloperTokenScopes, []string{})

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.PublishModule(w, r)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// UpdateModuleVersion operation middleware
func (siw *ServerInterfaceWrapper) UpdateModuleVersion(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	ctx = context.WithValue(ctx, DeveloperTokenScopes, []string{})

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.UpdateModuleVersion(w, r)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// HealthCheck operation middleware
func (siw *ServerInterfaceWrapper) HealthCheck(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.HealthCheck(w, r)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// SearchPublicModules operation middleware
func (siw *ServerInterfaceWrapper) SearchPublicModules(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params SearchPublicModulesParams

	// ------------- Optional query parameter "q" -------------

	err = runtime.BindQueryParameter("form", true, false, "q", r.URL.Query(), &params.Q)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "q", Err: err})
		return
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", r.URL.Query(), &params.Limit)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.SearchPublicModules(w, r, params)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// GetPublicModule operation middleware
func (siw *ServerInterfaceWrapper) GetPublicModule(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var err error

	// ------------- Path parameter "name" -------------
	var name string

	err = runtime.BindStyledParameterWithOptions("simple", "name", mux.Vars(r)["name"], &name, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "name", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetPublicModule(w, r, name)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// ExportSolution operation middleware
func (siw *ServerInterfaceWrapper) ExportSolution(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ExportSolutionParams

	// ------------- Required query parameter "token" -------------

	if paramValue := r.URL.Query().Get("token"); paramValue != "" {

	} else {
		siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "token"})
		return
	}

	err = runtime.BindQueryParameter("form", true, true, "token", r.URL.Query(), &params.Token)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "token", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ExportSolution(w, r, params)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// SearchPublicSolutions operation middleware
func (siw *ServerInterfaceWrapper) SearchPublicSolutions(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params SearchPublicSolutionsParams

	// ------------- Optional query parameter "q" -------------

	err = runtime.BindQueryParameter("form", true, false, "q", r.URL.Query(), &params.Q)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "q", Err: err})
		return
	}

	// ------------- Optional query parameter "tags" -------------

	err = runtime.BindQueryParameter("form", true, false, "tags", r.URL.Query(), &params.Tags)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "tags", Err: err})
		return
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", r.URL.Query(), &params.Limit)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.SearchPublicSolutions(w, r, params)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

// GetPublicSolution operation middleware
func (siw *ServerInterfaceWrapper) GetPublicSolution(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var err error

	// ------------- Path parameter "uuid" -------------
	var uuid string

	err = runtime.BindStyledParameterWithOptions("simple", "uuid", mux.Vars(r)["uuid"], &uuid, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "uuid", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetPublicSolution(w, r, uuid)
	}))

	for i := len(siw.HandlerMiddlewares) - 1; i >= 0; i-- {
		handler = siw.HandlerMiddlewares[i](handler)
	}

	handler.ServeHTTP(w, r.WithContext(ctx))
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

func (e *UnescapedCookieParamError) Error() string {
	return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}

func (e *UnescapedCookieParamError) Unwrap() error {
	return e.Err
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

func (e *UnmarshalingParamError) Error() string {
	return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}

func (e *UnmarshalingParamError) Unwrap() error {
	return e.Err
}

type RequiredParamError struct {
	ParamName string
}

func (e *RequiredParamError) Error() string {
	return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

func (e *RequiredHeaderError) Error() string {
	return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}

func (e *RequiredHeaderError) Unwrap() error {
	return e.Err
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

func (e *InvalidParamFormatError) Error() string {
	return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}

func (e *InvalidParamFormatError) Unwrap() error {
	return e.Err
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

func (e *TooManyValuesForParamError) Error() string {
	return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}

// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
	return HandlerWithOptions(si, GorillaServerOptions{})
}

type GorillaServerOptions struct {
	BaseURL          string
	BaseRouter       *mux.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, r *mux.Router) http.Handler {
	return HandlerWithOptions(si, GorillaServerOptions{
		BaseRouter: r,
	})
}

func HandlerFromMuxWithBaseURL(si ServerInterface, r *mux.Router, baseURL string) http.Handler {
	return HandlerWithOptions(si, GorillaServerOptions{
		BaseURL:    baseURL,
		BaseRouter: r,
	})
}

// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options GorillaServerOptions) http.Handler {
	r := options.BaseRouter

	if r == nil {
		r = mux.NewRouter()
	}
	if options.ErrorHandlerFunc == nil {
		options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}
	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
		ErrorHandlerFunc:   options.ErrorHandlerFunc,
	}

	r.HandleFunc(options.BaseURL+"/v1/devtools/publish-module", wrapper.PublishModule).Methods("POST")

	r.HandleFunc(options.BaseURL+"/v1/devtools/update-module-version", wrapper.UpdateModuleVersion).Methods("POST")

	r.HandleFunc(options.BaseURL+"/v1/health", wrapper.HealthCheck).Methods("GET")

	r.HandleFunc(options.BaseURL+"/v1/modules/search", wrapper.SearchPublicModules).Methods("GET")

	r.HandleFunc(options.BaseURL+"/v1/modules/{name}", wrapper.GetPublicModule).Methods("GET")

	r.HandleFunc(options.BaseURL+"/v1/solutions/export", wrapper.ExportSolution).Methods("GET")

	r.HandleFunc(options.BaseURL+"/v1/solutions/search", wrapper.SearchPublicSolutions).Methods("GET")

	r.HandleFunc(options.BaseURL+"/v1/solutions/{uuid}", wrapper.GetPublicSolution).Methods("GET")

	return r
}

// Base64 encoded, gzipped, json marshaled Swagger object
var swaggerSpec = []string{

	"H4sIAAAAAAAC/+Rce48bN5L/KoTuAHsAPcbZ7GExRv4Yj53sZP0YzNgbHNLGiOouqZmhyA7JlqwLDORD",
	"5BPmkxyqSHa3JLZG48fiDvvHLqzpbj6KVb/61YP5bZDrZaUVKGcHZ78NbF7CktM/n9VCFle1Ld9UTmhF",
	"f6uMrsA4Af4Xt3atTYH/dpsKBmcD64xQi8HH4cBApZMPHF8k/15bMIovIfGQhvu1FgaKwdnP7ZvDdglh",
	"Qj/8+2EcQc9+gdzh8M9qVUgonkMFqgCVb3CeAmxuBO1vcDY4Z38HuWQGJHALzJXAlrqoJTA9n4OxzGlW",
	"Gb0SVmjFtGJCWcelHLPz2pXajArIJTdQsBWXNViW6xUYGifXy6VWLOcWnjL4UGkLxQ3Jmklwlt7BbTH8",
	"wogCGGe2nllwbCU4PQ6Tsbk2yzFufess8pIb9zqIb3tbF/iIocDYWrhSKBoOxYXD7J0DjXQdTm97pCCe",
	"SlvhtNmwd9cv+4f4JxhLn+2OciWUgoLRS2zl3xqzF8vKbdgSuLIoCSa5A+sYd83GnVgCe6y0YwZQnniO",
	"xUl6AVopyHG+vwvlEhsRyjFb6rXCM22Ez2e6dqzU6+7ZG+B5Cf6IZqRE7M/f/2BuU4mcS7kJhzPKZW0d",
	"GHYDZiVyQOGwxzBejFnpXHU2mTgQY/yfXeXj8PJY6pzLs7+dnjCuCrYuRV7GeS04J9SCzQXIArcMYgWW",
	"CZfccQFzXkv3QvGZhGJ/xz+V4MqgjEGgI9QklpeQ3830B2YdN87631B0JplpLYErP0tnzN0pbkieCj64",
	"KNRm7KBz8STfXSb3sGUX++P/ePPmNQtGMzd8sQTlWAFzoVBMXnZkeOwONnbPZoLZWcZJwcwICuFQWl7C",
	"dsxu0EQMqpUJkppLvWb4njb4jd1W045GCNtIlduRsEOmtNepO6VntrPdFpFU0lpv/JpEAcqJuQBD2jZD",
	"jd9Swkd2G63IvlGJ+k9Y8hnIpOQ9XiUQ0eOaratKCihY0LKIb4i+UMTTbtZFlj1mr3jF9JxxtRnhhBEV",
	"x+wVmAUUCKBO0yseCsLgdtfmhzi6ImSUXBRsttmGyrR0/WT/ff7q5f62vEfjkhm+jqva8KVkuVYOtWqu",
	"DUJ2JeFD2JZl6xKMdwrWmTp3dQfol7xCFeDruzU3RbPDGcy1ge5Lj72aOn6H4kOjRl8EKRTbcXrB4bXo",
	"POxgfsrhoXZ4p5dQMpCQo1ILFQ4PfQnHv9CgeIi14Q4K9EL+eCy4McPZMrWsrWNL7vKScWZgIRDLuu9y",
	"KbgN6JcNHIhsMGTZoFqsaNpscDLO1E94qg32OpHf2V096oOPYaa23rTgbueSLyxbgGO8Ih/fKGYA1BLN",
	"BR0HWsmfv/+RKa0g2s+Q4Y+6WhheAKuVcEP6YOQMRzxkUswh3+QSxpna976Nv7ktkw7newPgrVFpB8yB",
	"lAha3dWh19He2zBXCht2h6vMm71D0Uj1+fnb82fnNy9u312//K7S1i0M2LPJZDwee/kecBO30PqJe1G+",
	"D6dvbQPUvCiEN6mrrlx2x+qBcCNWKIwKzCjAKUnKwzLBROfwK76AQ2i6t9pGN/rgrQWegP0FuojRCMmX",
	"VyoSeaaygf9jQARy5mLJFzB2fPFdXtWjJ+O/ouzZu8ughKTRFjKFiAIrMBtSdMQGGmTIuNRqYZHx7Q6f",
	"1aenf8lxX/QvGIdD+86ZGrKBP2HhYGnTPNv/gRvDN2k06UONC63mYvE9in+f9EcNIlBLTnyf+pAbSj7p",
	"PUPdhiDHbng4qCTPodSyANMToUR5pIzA/2VXYxyyG22YJQBNgnZSpJdee71ke4h10HCOf6Mf6GVw255L",
	"ofUblnMV1BSp84w7sRxn6m0JbBqgbRoYI/ojlutqM6q4dUCswsGyQmJNgQDrCMhmyuPK1Gvd6/NXL26u",
	"zi9eeNWbnjBXckcuzGkGyhmBXFSxqbfS6ZhdGSCJWuHAZor4LDfIzSzjBnA2oZgXlCUG5f1sIWwl+SYF",
	"q8ESkv5rPkJnzQWGEmVHfMwqUVUYU5HJBTQ1xajixm0ylYjuYthGduuFS7KL7qcCk2GEbDZPIz2ORvoo",
	"OpSk58lUmCF6nUAI6EB27Pc/DcwHZ4P/mLQB+SRE45OOK0/oObnc217b8Y97w/GwtMM62WygX4FS3sbr",
	"xpbV3rfNLvakbLqrZA+Dg2Du9lYo9JQ2bfbNW9Zpg64m+VZU7IesIAUNr0g9rv2cy5iEOdII3rZqvRUK",
	"2K5uI17EQ2xdjXAW5DxQCVjOoCiEWoxi5FmKyrK3Ly6HrOCOz7iFEXxwoCjv4Z9GKncyZpcNLWtCLORS",
	"Ti8WEtB4grE8ZcGBNZQaTcaVIAzDyHHLigPlsxjVoGrbiucwPtZg9pM9KYWY8fy+ga6fnV9sHQ8RityA",
	"u3cNN/Ta3setWh382L+2/XVKg67qmRS516OLOE4qtdVMgiL2CSZ/3GeoDSRjCrRY50OKJ4Waa0+32yG4",
	"J05rox0M6XvHF3bYxJ8+3qu0cZYJl6mgFymMv48t4PS9genaCOcwNqToxcd0SLDtU1rGy5evmC11TfkT",
	"XgRa7TF4LUxk4M2+UhiWjtIvWmm2gXoT7yDDMz7kKZ2rbi2YFf7hJDUBSelojOye95U2LqXYjj8YmY7i",
	"ht25n4PjQiZQ6ftaygg+Fd9IzVH4rjboqGcbNp2snkz8czv5Def6OB2zF7/WYsUlKJfFiNTWyyU3G1bJ",
	"2iPaHEcOacGQNhwGTt1qJvqlTKFMWRCZ12o0ZMSipbC24VRhmQqg6Cgv4lCmWs+HDqn26uVZUAH2zulq",
	"Qsm7JjIzlFb6FBXHjfX7b1zObZjkGA+6TTWJb6PIbldtPvZYBQsp3HjWhxj6CgwaQZJMpzMZXancp21X",
	"zcHtK9w/6hkYBQ6sP2Tjk7Z+PtS49qT3ToZX4nZhdF09mEtYXZv8oRQEGftnc4Y9BOgN0dB5PyQ6v+HL",
	"Cukwd5zIMwoOLWnIakvhA7cMPviXhKpql4rD71P2/jj9s7IJ/sksQjou+5H1W7Elr5Ipg3SI508WgzzH",
	"zQJwk6DqJWquf0RFJnry/sikHb10n47fADd5eQ220srC/qkasLX8RE9x47H0XuiPc9y71jDenvBeikXp",
	"1oD/H9GVAqd+F2Bp29Mxu+AGg0qMtHS9KBsNDIGv0ywvtbYtccE/BVx8yuZaSr1mdZUpCk1SbqZJ63pJ",
	"BXYT+WYbb382hu8EUvWSqxESEDKiEO+yrm5sp0c+E647h51e0E/a3BGfHv1ac0mw3bhC5Nstj1Ebu7Go",
	"bBNfwAwRwmh12kNmum6gvwAVU54c2RgoFr9C5Xgr1Ibd+FkTNajP9yU7Tu0Lx1shl+CzD7EM48QSMtWU",
	"joVahGITQRPC6n4gOI5pQF9yytRjbRifWVDuhAYPyh0oiVaPYuaQcbVxJU5yfIbhqIBpu1XgwSDUhiep",
	"wL6lZp/GhVuGkPTXdFK3FBscbFfYpfk+xWQY5Xk7te+U8je5g7uGktzyPO/NNdjirmvmfZ0Sh5eEL6UN",
	"sWfcHQuKL24d75E21HEDu77qkCS2N/SqQ8I9g/NvxupNh9+dX10my9L3CfLBwujdvy23guxPC2WP50Sf",
	"EBt2Vvg148MjMXd3NZ/BVfcm+IQ6Alnv9vEI5WAB5lgGureKwAmPDnvC+wck1voCsAmJfSoKd1U3oRRf",
	"XnnNTlrz0AoTidB9u96JVp7/I6YBMPCmnPusFjKkeZqI79PRIJzYwxCyPT+k0vvHF9Z13Iltoe1OIeyw",
	"O9/p3euPJHcn2VuwKB527EeLVxSD4a6MU2Ldy8HuLdHnlVtHcR3C8/Mel+O7pDp+ptKFHTLrO7fskBVQ",
	"Sb2h2YYs1AvAJn0PfHCGX9cSjjdH2lCdKuZ87Nt+UJm97MUP/8+SF4mk+N7pPI8UGr3/3d8s8x/ZNvDz",
	"XMF3SxTdAgSR7GXVbah0mlH7ks8D8dzVXIYRfWHhqW95ydS1pl6SKJ7X+JAJyyrfr0h0BOPPpo0p1vYK",
	"yBR+JVdgt2pi1LtZ3S0mvmQwvvYvMe7YG3Xj+/tspjA82O8sa0qHyta4EqVbQaiCKe1XjCvMDXAHRSpu",
	"pS2m4nTrmJ5vCaI765JjyD4HAyoH9rgyMJpLiuo5xtlSWHcyflj7wb4uaFm77UgskUq24a2262o/lxDf",
	"sZPf6loUH6fjTAWebEOGmDr5KDNA1Q5doJlDsYCQ+N1K89phpijtzNWmWcBIwgokW3EjED0+LUsg9fp4",
	"nIgC+l7q9ZfgccOBE06mURvllobzuN+tmR5AkA5ySZo2rmubhERpvT+gOi+KBaQYUucsP5fOdRKU9Oi2",
	"5LGnLhGwUVqw/1H/xztyaTKN25M2U+wOeEhIpD77PhN1/8GqSAJPKBYZ1INHe60LeIia7ggpao2ffBi2",
	"dEgUNGE/o04T37RdtDzuYJTxENULDuFBn6U4VbeeGZZ5SChfOvHcjPsFks67Y+35iGdGwJxagVcC1tRv",
	"3LqMA44ipp0zFfLOrDftHNqtOPMLZUavyWUUkAt0/euY2dRsDo76jUKxsvCe7VM8xdfA9mSjeSOstpA9",
	"9PFUm0ff86/3disfwPXkMSfaHfbvjWCMYKk/O3RRBCLYXLvZKvaNGTUYh56T4fZ9AOrrD80qYbCRFf8D",
	"bNL8zCW3NjahdmvDTTOUULmsi0Ccrv55wexauLz0DempCCVxCm9NDWwdO6GbKyc+fcY4DYuKVSuqTYTc",
	"/FxIGM18Y7Jv34GCFg72JH1zAzeXotq+nz/Kk0Rg68UCbGe2Jz+IIXty+oM4iTedWCmUe8reXba3l5oG",
	"8tiWn7xoECa6QNmmbyvtLskfQ7umSJTrmHiP925CJml8XFPmu6rgDrZC396MS8p6AvkPn7LL5+mEcCqp",
	"fNmkklPfJJO+l/2p3pQDOHgVzncw1Ua4DdVO/R6fATdg8HSpBkK/vtdmyd3gbPDjT28HIT1GakVP26WU",
	"zlW49OdIkFFwb/UdqOY6Yf8nH3v7e3yymf3crQa9f4xf2bPJpFOYGgs9OWHnV5fjTGXqXEoGqqi0UM4y",
	"KVbAagJvVBSCsimrDMzFhzF7W0L4NwV53FBARF2b1vGZkMJt6EKI4bk7Y9SFz1UzPH3kEyhQhFn8DNQQ",
	"lamKu3LIluBKXQzJpME6X/HxIYcJHjdUgXKulHYYjKoFIhXjmZoZ4Hd0u4lvxuxZ/OXfsdSKF6bmTMGa",
	"Lfkv2sRdPZ5OVt9MpsNMgcvHJ532P7JXWVCbHvo7zgqoDOS+x2UtVKHX4QKBdyqD7jmENHyT5xmcjv86",
	"/i+fnQLFKzE4G/xlfDo+pfuZriT9QskUsHJaSzsJchu1HKrSNtG1dh2ulsRsXhAbOnUKesljcemLbVVt",
	"S1pz0wx2WURNikmugTcWsO6ZLjYhVnCB+fGqksLLYPKL1a0C8wdl6yKMkHYntNqWXZjHN7sW7EwNPkdD",
	"ukGy++b09GstlXKUiZXe1D511kWLwdnPv+3Z+M/vP76PbOXnQTzhwXv8cOvMawLcpoDcyTYmj97jc5RU",
	"zPP6AJ7AEHED4UlolTj1BLx/pbM/4EgSct1zG8P97RyrD1/pxErg0nuBEMvutoXjY98H34Dhnvz9Wxf4",
	"0uAzVt9ZqF8WTduudbuJpHfNPsLZai145ME7b/ukHZd6gRTyDjZrbYoxuw5I430C1eulyMFX3JF9Wdbj",
	"kWJt/s/f/2jq9L4zcRqm/Y7hyU4jsRRmp7OR3FlcgG+FFNRYLTfssW/W7exxuNcXOec5uEzR/aWTMXtn",
	"ob8lZideiW2bmfIElzxOo/hDtt1cudtY6X3bdg/lTnNNpt6Wwm55Uh9x+SPIda0cGPLITrOpFNbdhnVP",
	"w3WwTPnmy1cXV8x3157RGJI75IL4iW0kz6UBXmw6d+iECh3NFOQ9spFEDtm6FBJ8BQm9485AKy6kv0ij",
	"m92NE/DjFa5bMbfkDA1fAvozMsydNkavdezXGszGX66EgvEFx2m22nN87NlNlAkcgD6MFZWzwa+DbkFz",
	"jzTu8Vn+QSzrZYhxQ3Idta9neCmWwm1NEfj34Oyb0+Fg6YcbnD05xV9ChV/DvbIrgtHX9Xbp/rqU0/Mw",
	"EfMR+1hkYxYivkqthikcGbTAFZRnH7S8CfaCVgd9wl1kByzRgt10WXsmZ4VayObm0dlhlOg0w/kLPV3T",
	"zlTatps4uK9FGmKHdKZyKTBen7Rd0j5we+zvCWOgMgzXvz2o7V40GmZq687PsLlUNowh4iQU6Fi34HxC",
	"ODPFQadU6KucZSCaFrRZc2c+3HvbbXCbnjBtPEoQNq4TTXPd7w81y01xNVdGrFpKY4N5sW9Pv2UGFtwU",
	"Eveg5zHz5PMxbpPClx/AdTXhPmx51W3uo51rk9rQSTR2pO2trYca7TYpOYQu/yqTbhrT9225ew2haPvX",
	"vz39tr8DSTs217UqUDr4w1v2QRz4AdxWqs8nILcg4RAUtIk1+FCF/piDYNBk6/z77MebN6+RqDT5ohWX",
	"ggI7ajpkDjlfpvQs3JRcCc4W11cX7IJKhi9oFCKGKTXzj2MO9j4texMnDWujuXvcR3z2r9Op4zPq+34h",
	"IXSvTE8SqRoVjsDg63QHwW+2T/ua0Rv9O6hx/kxaRagR8HcOvKNyjYallO442txxcs2nCb6MvmFCXfML",
	"JHk93BUZcR3J6F5eeYuOZqot+bZMlIqCw1jBRVdBZR+Ce0r4ctXeaGRCFUD5nZa6ebo4sqKAIbOw5Mrh",
	"zmivmTK1smwujHVPmUZvsRbhsrAnZnMupSXyjxQpbt3/tzAwEqWEyQ43J3+GUmFvUAStEJfc3EHBQkxA",
	"9/qnmeLdEnfSNfDalegcvLLfR0BvGhX4LAp6aGdfhoO+5Qs2F9KBeYrMALjzuhfX7Nuea+lEJSHOCx8q",
	"SVU9DyBJsPFvtis5vqhi3YbyXxicD/5dWHNPYfCLMOY+IDkWsjxQPIw0T3c6TaY7lNmvKVNxlrOv1zOS",
	"RoAmLfBdSAqY2JwmqE9NabVZ6trKzVNWBRrZjJGplkke5IrH+vHGIb17R2WNBCMM5b3/G4xwt4+ojw02",
	"LvM+Prjvkb8UI7TtESS1fTd3163K+Lyd916pY9tN0QdHNxgOaiNDycWeTSa8EuPtdNXg4/uP/xsAAP//",
	"tInLmAlSAAA=",
}

// GetSwagger returns the content of the embedded swagger specification file
// or error if failed to decode
func decodeSpec() ([]byte, error) {
	zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
	if err != nil {
		return nil, fmt.Errorf("error base64 decoding spec: %w", err)
	}
	zr, err := gzip.NewReader(bytes.NewReader(zipped))
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}
	var buf bytes.Buffer
	_, err = buf.ReadFrom(zr)
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

// a naive cached of a decoded swagger spec
func decodeSpecCached() func() ([]byte, error) {
	data, err := decodeSpec()
	return func() ([]byte, error) {
		return data, err
	}
}

// Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
	res := make(map[string]func() ([]byte, error))
	if len(pathToFile) > 0 {
		res[pathToFile] = rawSpec
	}

	return res
}

// GetSwagger returns the Swagger specification corresponding to the generated code
// in this file. The external references of Swagger specification are resolved.
// The logic of resolving external references is tightly connected to "import-mapping" feature.
// Externally referenced files must be embedded in the corresponding golang packages.
// Urls can be supported but this task was out of the scope.
func GetSwagger() (swagger *openapi3.T, err error) {
	resolvePath := PathToRawSpec("")

	loader := openapi3.NewLoader()
	loader.IsExternalRefsAllowed = true
	loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
		pathToFile := url.String()
		pathToFile = path.Clean(pathToFile)
		getSpec, ok := resolvePath[pathToFile]
		if !ok {
			err1 := fmt.Errorf("path not found: %s", pathToFile)
			return nil, err1
		}
		return getSpec()
	}
	var specData []byte
	specData, err = rawSpec()
	if err != nil {
		return
	}
	swagger, err = loader.LoadFromData(specData)
	if err != nil {
		return
	}
	return
}