client.gen.go

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

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

	"github.com/deepmap/oapi-codegen/pkg/runtime"
	"github.com/getkin/kin-openapi/openapi3"
	"github.com/go-chi/chi/v5"
)

// Defines values for NewScanType.
const (
	PortScan                       NewScanType = "port_scan"
	ServiceDiscovery               NewScanType = "service_discovery"
	ServiceDiscoveryDefaultScripts NewScanType = "service_discovery_default_scripts"
)

// Defines values for ScanStatus.
const (
	Complete   ScanStatus = "complete"
	Failed     ScanStatus = "failed"
	InProgress ScanStatus = "in_progress"
	Scheduled  ScanStatus = "scheduled"
)

// Error defines model for Error.
type Error struct {
	Body *map[string]interface{} `json:"body,omitempty"`

	// Code Error code
	Code int32 `json:"code"`

	// Status Error message
	Status string `json:"status"`
}

// Healthz Healthcheck endpoint response.
type Healthz struct {
	Status  string `json:"status"`
	Version string `json:"version"`
}

// NewScan Request body for creating a new scan.
type NewScan struct {
	// Description user entered description for easier identification
	Description string   `json:"description"`
	Hosts       []string `json:"hosts"`

	// Ports ports to scan. must be supplied in an array
	Ports []string `json:"ports"`

	// Timeout time in seconds
	Timeout *int `json:"timeout,omitempty"`

	// Type type of scan. must be one of the allowed types
	Type NewScanType `json:"type"`
}

// NewScanType type of scan. must be one of the allowed types
type NewScanType string

// Scan Successful scans contain information about the scan, and each host.
//
// Failed scans will be have empty values in the Scan response.
//
// The `data` object is the result of the Scan. `host` information is provided as an array of `hosts`.
//
// Each `hosts` object contains all the information about the host, and is where the majority of your time should be spent when digesting the response data.
//
// Empty fields are not omitted but will return their empty values. This is done to prevent errors due missing indexes during parsing.
type Scan struct {
	// Data The entire response object for a single scan.
	Data        ScanData   `json:"data"`
	Description string     `json:"description"`
	HostsArray  []string   `json:"hosts_array"`
	Id          string     `json:"id"`
	Ports       []string   `json:"ports"`
	ScanType    string     `json:"scan_type"`
	Status      ScanStatus `json:"status"`
	Summary     string     `json:"summary"`

	// Timeout time in seconds
	Timeout *int `json:"timeout,omitempty"`
}

// ScanStatus defines model for Scan.Status.
type ScanStatus string

// ScanData The entire response object for a single scan.
type ScanData struct {
	// Args nmap command equivalent
	Args     *string           `json:"args,omitempty"`
	Hosts    *[]ScanHostsArray `json:"hosts,omitempty"`
	Runstats *struct {
		Finished *struct {
			Elapsed  *float32 `json:"elapsed,omitempty"`
			ErrorMsg *string  `json:"error_msg,omitempty"`
			Exit     *string  `json:"exit,omitempty"`
			Summary  *string  `json:"summary,omitempty"`
			Time     *int64   `json:"time,omitempty"`
			TimeStr  *string  `json:"time_str,omitempty"`
		} `json:"finished,omitempty"`
		Hosts *struct {
			Down  *int `json:"down,omitempty"`
			Total *int `json:"total,omitempty"`
			Up    *int `json:"up,omitempty"`
		} `json:"hosts,omitempty"`
	} `json:"runstats,omitempty"`
	ScanInfo *struct {
		NumServices *int32  `json:"num_services,omitempty"`
		Protocol    *string `json:"protocol,omitempty"`
		ScanFlags   *string `json:"scan_flags,omitempty"`
		Services    *string `json:"services,omitempty"`
		Type        *string `json:"type,omitempty"`
	} `json:"scan_info,omitempty"`
	Scanner *string  `json:"scanner,omitempty"`
	Start   *float32 `json:"start,omitempty"`

	// StartStr scan start time
	StartStr *string `json:"start_str,omitempty"`
	Verbose  *struct {
		Level *int `json:"level,omitempty"`
	} `json:"verbose,omitempty"`

	// Version nmap version on server
	Version *string `json:"version,omitempty"`
}

// ScanHostsArray The detailed response from a single host during the scan event. Each host will have their own object within the hosts array.
type ScanHostsArray struct {
	Addresses *[]struct {
		Addr     *string `json:"addr,omitempty"`
		AddrType *string `json:"addr_type,omitempty"`
		Vendor   *string `json:"vendor,omitempty"`
	} `json:"addresses,omitempty"`
	Comment  *string `json:"comment,omitempty"`
	Distance *struct {
		Value *int32 `json:"value,omitempty"`
	} `json:"distance,omitempty"`
	EndTime    *int64 `json:"end_time,omitempty"`
	ExtraPorts *[]struct {
		Count   *int32 `json:"count,omitempty"`
		Reasons *[]struct {
			Count  *int32  `json:"count,omitempty"`
			Reason *string `json:"reason,omitempty"`
		} `json:"reasons,omitempty"`
		State *string `json:"state,omitempty"`
	} `json:"extra_ports,omitempty"`
	HostScripts *string `json:"host_scripts,omitempty"`
	Hostnames   *[]struct {
		Name *string `json:"name,omitempty"`
		Type *string `json:"type,omitempty"`
	} `json:"hostnames,omitempty"`
	IpIdSequence *struct {
		Class  *string `json:"class,omitempty"`
		Values *string `json:"values,omitempty"`
	} `json:"ip_id_sequence,omitempty"`
	Os *struct {
		OsFingerprints *string `json:"os_fingerprints,omitempty"`
		OsMatches      *string `json:"os_matches,omitempty"`
		PortsUsed      *string `json:"ports_used,omitempty"`
	} `json:"os,omitempty"`
	Ports *[]struct {
		Id    *int32 `json:"id,omitempty"`
		Owner *struct {
			Name *string `json:"name,omitempty"`
		} `json:"owner,omitempty"`
		Protocol *string `json:"protocol,omitempty"`
		Scripts  *[]struct {
			Id     *string `json:"id,omitempty"`
			Output *string `json:"output,omitempty"`
			Tables *[]struct {
				Elements *[]struct {
					Key   *string `json:"key,omitempty"`
					Value *string `json:"value,omitempty"`
				} `json:"elements,omitempty"`
			} `json:"tables,omitempty"`
		} `json:"scripts,omitempty"`
		Service *struct {
			Confidence  *int32    `json:"confidence,omitempty"`
			Cpes        *[]string `json:"cpes,omitempty"`
			DeviceType  *string   `json:"device_type,omitempty"`
			ExtraInfo   *string   `json:"extra_info,omitempty"`
			HighVersion *string   `json:"high_version,omitempty"`
			Hostname    *string   `json:"hostname,omitempty"`
			LowVersion  *string   `json:"low_version,omitempty"`
			Method      *string   `json:"method,omitempty"`
			Name        *string   `json:"name,omitempty"`
			OsType      *string   `json:"os_type,omitempty"`
			Product     *string   `json:"product,omitempty"`
			Proto       *string   `json:"proto,omitempty"`
			RpcNum      *string   `json:"rpc_num,omitempty"`
			ServiceFp   *string   `json:"service_fp,omitempty"`
			Tunnel      *string   `json:"tunnel,omitempty"`
			Version     *string   `json:"version,omitempty"`
		} `json:"service,omitempty"`
		State *struct {
			Reason    *string `json:"reason,omitempty"`
			ReasonIp  *string `json:"reason_ip,omitempty"`
			ReasonTtl *int32  `json:"reason_ttl,omitempty"`
			State     *string `json:"state,omitempty"`
		} `json:"state,omitempty"`
	} `json:"ports,omitempty"`
	StartTime *int64 `json:"start_time,omitempty"`
	Status    *struct {
		Reason    *string `json:"reason,omitempty"`
		ReasonTtl *int32  `json:"reason_ttl,omitempty"`
		State     *string `json:"state,omitempty"`
	} `json:"status,omitempty"`
	TcpSequence *struct {
		Difficulty *string `json:"difficulty,omitempty"`
		Index      *int32  `json:"index,omitempty"`
		Values     *string `json:"values,omitempty"`
	} `json:"tcp_sequence,omitempty"`
	TcpTsSequence *struct {
		Class  *string `json:"class,omitempty"`
		Values *string `json:"values,omitempty"`
	} `json:"tcp_ts_sequence,omitempty"`
	TimedOut *bool `json:"timed_out,omitempty"`
	Times    *struct {
		Rttv *string `json:"rttv,omitempty"`
		Srtt *string `json:"srtt,omitempty"`
		To   *string `json:"to,omitempty"`
	} `json:"times,omitempty"`
	Trace *struct {
		Hops  *string `json:"hops,omitempty"`
		Port  *int32  `json:"port,omitempty"`
		Proto *string `json:"proto,omitempty"`
	} `json:"trace,omitempty"`
	Uptime *struct {
		LastBoot *string `json:"last_boot,omitempty"`
		Seconds  *int32  `json:"seconds,omitempty"`
	} `json:"uptime,omitempty"`
}

// PageParam defines model for PageParam.
type PageParam = string

// PageSizeParam defines model for PageSizeParam.
type PageSizeParam = string

// PageSortParam defines model for PageSortParam.
type PageSortParam = string

// ScanBody Request body for creating a new scan.
type ScanBody = NewScan

// ListScansParams defines parameters for ListScans.
type ListScansParams struct {
	// Page page number for pagination
	Page *PageParam `form:"page,omitempty" json:"page,omitempty"`

	// PageSize page size for pagination. default is 20
	PageSize *PageSizeParam `form:"page_size,omitempty" json:"page_size,omitempty"`

	// Sort sort results by 'asc' or 'desc'. default is 'asc'
	Sort *PageSortParam `form:"sort,omitempty" json:"sort,omitempty"`
}

// CreateScanJSONRequestBody defines body for CreateScan for application/json ContentType.
type CreateScanJSONRequestBody = NewScan

// 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 {
	// Healthz request
	Healthz(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	CreateScan(ctx context.Context, body CreateScanJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

func (c *Client) Healthz(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewHealthzRequest(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) ListScans(ctx context.Context, params *ListScansParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewListScansRequest(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) CreateScanWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateScanRequestWithBody(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) CreateScan(ctx context.Context, body CreateScanJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCreateScanRequest(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) RetrieveScan(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewRetrieveScanRequest(c.Server, id)
	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)
}

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

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

	operationPath := fmt.Sprintf("/healthz")
	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
}

// NewListScansRequest generates requests for ListScans
func NewListScansRequest(server string, params *ListScansParams) (*http.Request, error) {
	var err error

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

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

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

	queryValues := queryURL.Query()

	if params.Page != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "page", runtime.ParamLocationQuery, *params.Page); 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.PageSize != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "page_size", runtime.ParamLocationQuery, *params.PageSize); 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.Sort != nil {

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "sort", runtime.ParamLocationQuery, *params.Sort); 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
}

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

// NewCreateScanRequestWithBody generates requests for CreateScan with any type of body
func NewCreateScanRequestWithBody(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("/scans")
	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
}

// NewRetrieveScanRequest generates requests for RetrieveScan
func NewRetrieveScanRequest(server string, id string) (*http.Request, error) {
	var err error

	var pathParam0 string

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

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

	operationPath := fmt.Sprintf("/scans/%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 {
	// Healthz request
	HealthzWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthzResponse, error)

	// ListScans request
	ListScansWithResponse(ctx context.Context, params *ListScansParams, reqEditors ...RequestEditorFn) (*ListScansResponse, error)

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

	CreateScanWithResponse(ctx context.Context, body CreateScanJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateScanResponse, error)

	// RetrieveScan request
	RetrieveScanWithResponse(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*RetrieveScanResponse, error)
}

type HealthzResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *interface{}
}

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

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

type ListScansResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Scan
}

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

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

type CreateScanResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *NewScan
	JSONDefault  *Error
}

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

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

type RetrieveScanResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Scan
	JSONDefault  *Error
}

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

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

// HealthzWithResponse request returning *HealthzResponse
func (c *ClientWithResponses) HealthzWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*HealthzResponse, error) {
	rsp, err := c.Healthz(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseHealthzResponse(rsp)
}

// ListScansWithResponse request returning *ListScansResponse
func (c *ClientWithResponses) ListScansWithResponse(ctx context.Context, params *ListScansParams, reqEditors ...RequestEditorFn) (*ListScansResponse, error) {
	rsp, err := c.ListScans(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseListScansResponse(rsp)
}

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

func (c *ClientWithResponses) CreateScanWithResponse(ctx context.Context, body CreateScanJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateScanResponse, error) {
	rsp, err := c.CreateScan(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCreateScanResponse(rsp)
}

// RetrieveScanWithResponse request returning *RetrieveScanResponse
func (c *ClientWithResponses) RetrieveScanWithResponse(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*RetrieveScanResponse, error) {
	rsp, err := c.RetrieveScan(ctx, id, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseRetrieveScanResponse(rsp)
}

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

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

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

	}

	return response, nil
}

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

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

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

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSONDefault = &dest

	}

	return response, nil
}

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

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

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

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true:
		var dest Error
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSONDefault = &dest

	}

	return response, nil
}

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Healthcheck
	// (GET /healthz)
	Healthz(w http.ResponseWriter, r *http.Request)
	// List Scans
	// (GET /scans)
	ListScans(w http.ResponseWriter, r *http.Request, params ListScansParams)
	// Create Scan
	// (POST /scans)
	CreateScan(w http.ResponseWriter, r *http.Request)
	// Retrieve Scan
	// (GET /scans/{id})
	RetrieveScan(w http.ResponseWriter, r *http.Request, id 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

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

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

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

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

// ListScans operation middleware
func (siw *ServerInterfaceWrapper) ListScans(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 ListScansParams

	// ------------- Optional query parameter "page" -------------

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

	// ------------- Optional query parameter "page_size" -------------

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

	// ------------- Optional query parameter "sort" -------------

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

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

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

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

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

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

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

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

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

	err = runtime.BindStyledParameterWithLocation("simple", false, "id", runtime.ParamLocationPath, chi.URLParam(r, "id"), &id)
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "id", Err: err})
		return
	}

	var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.RetrieveScan(w, r, id)
	})

	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 UnmarshallingParamError struct {
	ParamName string
	Err       error
}

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

func (e *UnmarshallingParamError) 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, ChiServerOptions{})
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.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 chi.Router) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{
		BaseRouter: r,
	})
}

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

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

	if r == nil {
		r = chi.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.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/healthz", wrapper.Healthz)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/scans", wrapper.ListScans)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/scans", wrapper.CreateScan)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/scans/{id}", wrapper.RetrieveScan)
	})

	return r
}

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

	"H4sIAAAAAAAC/+Rb/2/bOLL/VwZ6D2i78BfFjh0n91Nv28P2vb1u0bw7HNAtbFocWdxIpJak4noX+d8f",
	"hpRsyaITZ7d7OGB/aROJGs4MZz7zITn5NUpUUSqJ0pro5tcoQ8ZRux//NfzILOaiEHb4Pf1LDzmaRIvS",
	"CiWjm0hWxRo1qBQ0/lyhsQZK1IWwFjlshc2EBJshbIXkahsNIpNkWDASZHclRjeRkBY3qKOHh0Fnwo9Y",
	"MCGF3Jw1qW5GwxpTpRHwS4LI6QFN70Q+b3aDAXOtKBCEhEqKL7DN0Bunma2nqO0ETZ+bxyd8GEQl06xA",
	"W7v7A9vgB3rSn7dkG4Ta7FRpKNlGSOZeDiL8wooyx+hmMogEjf65Qr2LBpFkBdYfh1QxVpN7SRGa+lb8",
	"8uj0RvyCR5OPgGPKqtyCMDCJ27rM4tPKLEnUORopbU9oZJS25OUqtwbWO3jBTPIClIYXNO5FRzH3rq1b",
	"xEwShdUjuY9q9jCI6qD7q+IC3cLdJkz+VfEd/ZwoaVG60GFlmYvEOWr8kyG1f20J/m+NaXQT/df4kH5j",
	"/9aM3+OWZPrpuoZ/9JPDWvHdj/JHucqUsWYFBdvBGoFJYFqzHbnCCLnJEWjAiIa+ZUkGKzJoBRkzwIAL",
	"jYmFlSxYuQL8uRL3LEdpgUkOTNdBjRyscoGeqjxXW0qqH6s4niZV7v7H+tdc+F9XpdJ2aRImV+R/Jx6G",
	"ZT2KXprOd5Wu5az87+NG0LFcg/peJLjkwiTqHvXuKflD88/fPceyDqWlXwZzzpxD8+2Z844bH/4oV4Qu",
	"qrJuAuUWnOUORGmpvBIjoMAwYDNm3QrhlxKTZonYHQKDXBHqEVKZTFU5B4MWbCYM3LO8QhcLbonMCrhC",
	"A1JZMFVJj2A1XA1IFq0esDwHNxAqg7C6GM5ns+lsBUIai4yP4NaHmB9DQaOZ3KBxmtUSkfsJW2G8ahRb",
	"I5TMmLpUAKNp0ioHwVFakYoa7dLKVhpBY4oaZYIj+L8MweyMxeJgAanYsjLyiSo08ujG6gopl+oEo/x7",
	"q7XS9EOpVYna1rm8rvO4znu1/gkTGz0MokRx7OOQkwLu3SBKlS6Y9SA/nUSDHuYPImOZrcwpOQUa48G6",
	"D4gHYz5F9Xy1sM+DvrbfIctt9kt/Iv8iyTC5A5S8VEI6IC2VNM5pXXcc9D2g5w//21dwEN2jNsKD3GFo",
	"nEyuLmfXl8l8FuMsns6mMbtcT3FyGa85zuNkvp7NOD5tca3HYZqQ0Q1s9oxug6aLqEQjs4RjDCRuXbD3",
	"be/IOBZZGdSA0qJGDq1XTjwyQ7HbhHHSq9TRm/e3YJPS5UzFS6dByKsO3Ts+/RRtlNrkOEpUQXULbS7S",
	"nfvt8yASFgsTqFt70a460O8uZwOl3qVyDQAjKCpym0/mXCAn8tPUmLZBn6IJBfxsGg2ieRzH8XA+jeP4",
	"eSrV+HeadhlMlOSmPTHNEko0/6QnaFci8caucUq6h1ThGBU4QtNdiW4eWRVk3b6iUdodV4jQs+Oq0QrY",
	"EyHul7pZmG7dr799NOXDoX9bJQkaQ6hqXOUggsKEBCE9XFHMsrWqrLOfxgxcVCKxhT13+BsTOfJaxFbk",
	"OfktY/cIWJR25zHXQM32SZUDqND3BNgrzixbgdeYapzjzo7DNe6/deviOM2qo6EwUGp1LzhyIOqypzkp",
	"1AyoRXFqSlRPVBtsXDWjScKW00fecmGI2mt0jwv2k9LCupl2qtKdwkqJURJfclsBLjZobLPlaMwHstor",
	"5zyVCsy5r5BUtVS9V1pX1vtVo620c6PQHedS1ROGtOMUsFZBqfGeZkcqHgZ4hVAIQ7QPhOT4BekZxRqU",
	"TNPjAMYx+yQbpUV5Q+OOyWgb6YsdBAK2B2VLn+x/BKAJ3tXoyZQcxtfz6eI6mYW03cNjAOKepRalzLJB",
	"o4N2bUDpyWhV3Rp/aFlytM2uiVc5creFWZZabTQaQozUJSmpd5in9WF/mqoomN4dua0LGKHvvh5OH0Gg",
	"IJvacXJAw0bXtkOPMXJPElxUn8LIN3XId1UngKJqrVuZWwMIVXTW7KbCVIHpTaCWuj1CoorC4el+d9Uh",
	"AuPK6PFayHGzobgYzuN4v4kYqn/BEDoJcpoj7IPyqWz+jr54vS+7RxGrK0meNH1ynAopTIa8/wZzVhrs",
	"ZuBkMZrspfvDCxLv0GpZmE0wffCLP2bqBeTZAfyeHOkgklm4ZRb+p5IAU5hMbybTm9kCJvFk+heYwLsP",
	"wDin3EEDLyeuAhioyldukaUnO2RE3AroYDJ0FBjOJxfT2ex6vqCIb+8J5pfBPQFJWBqru2ac0jxIlXuB",
	"vo+JI7hXWxk6jBpEVlmWh19V5YkDs6NZQ3q4ZKWC29dFVsWyxugu0Dr+eNZuqtTKqkTlXc/ZpAwGC6mS",
	"5mwTxu2gKpHLxjgOLnwP0xMlJdl91gr5GNNhXSzTtvXmkDzuTRMsR0diRLrce8dROijTDaY4vpldnQgm",
	"t8NaK4P9BcvxHvPzQqGzHQyAYv0WFNUKfY+6o+3V6PrMMD8CsyCqc7SevO5xPdWqOCA6pUrDkxoKDI5Y",
	"jeBtQ4I9N3OE1zMztZVNfWgdc3sIcUgaKBIN2HSwuj/mKAKv4tH8cnQxnYwuJpPQgtE3AYYhyvvL8PpK",
	"rnT41LXn4OPaQNWsPt7sCebCWCaTQOQ4AtvR7pz8DumDki9/P+LiF6vZck/xTqxFoirZrUWz69lZuKSR",
	"GSX/SNndpXbXDedlTI+eWmaPYSxXxrHL3yCOEmC/5SXG0Bgkqzxn6xxPERjJikcTw5/Pt9VM5YgzSbvH",
	"kSlZgudhdGUc2PwG00S5FHxp8OcKg0Ge5MyES4vfv52ZcSpgvDLLVMgN6lIL+QzHKrMsmE0yPP8TlxTL",
	"quZyZ3wSsuGpzDraqk0mZ0W+2tb1MhwZ5+j1PL6wj+LzzIiMyYYUy3e4C65GZcvqiNxO46sJXOGULxbX",
	"7OJqwabzS8aSi/R6tkBc8PjiIuHw8uPt61cwmc0hTTm/mKTx1WTN4im/ni1muJ4t5skCZ1fT6Rpevv32",
	"TTP4ah7H7CpdzPGScb7GqylfXF3GfJLOF1fzyTW8fPtmMptdXL8K5g6t92PmY45Fc2t8Ygh5outrv28L",
	"p0jfm9qw35KsX2PEnhGGwFumgjcosNf44jzSmpRHXm0hb4k3Y3ajSpRrw93/xmQ3i9GkvDgNbweNOboT",
	"jwb1ApsrqnsNHT/M+491JW0F3wtZffkLNFkCk1GQ+GZiky1b/O4kngdf5mr76McF2kwdJVap1TpUkQaB",
	"smBMdgIK+8XAGRxEQa14lRzl6g8lytvb706Mtypoji6TpTvDOb3lWKZl+CSpkrJDuJ+4bHFhAvVaXlbu",
	"/3g0O3M70vCAbqiH2IbZySFL7kJ+8MOXImxQ/dbaLgBfTs6+OjtaP0qQc8w7kwhp+xW45eHs7mt48uv5",
	"qirPRNKkfITkcJGmIqlyuwuusDt2fjbRfyZDIg2t+eOZGMUCX9YHnfXbtVI5Mtm8Dq2ztfcdD1xdXYXY",
	"hbZdeJnMJ9P5PATy6mjc7PLq8ryl1CzknkyVz+ODv2FBTwFiSM2qbLLu6LyBGbtcK2VPgKc/kvv9u8rA",
	"ExfKvkp2DxR+kPBBJHfo7q+YhE9vv1jUkuXw2lqW3MFtpVOWIPydSbZx/Ojzy8za0tyMx9vtdpSx5A61",
	"ku40d3wn1TZHvsFh4u6Sx9uM2SHWMofMyRwaL3NY7GUOkZniFVilckhVUrk7HyWBVVYVzNY3da4frrm3",
	"aoRCiVq4prNR3YKy1p2OlP2ve1tfGFAy39XHohqMgpTpfRvMagT/RL2DFLdNK1F96H3UCOKvB4Vpjn9G",
	"8Hel0R+t+NYiYP5WsNU6BRoZ7WBAkB6p0MaCxhyZwacM+Oab98riN98cP3f3aO0phLu5fJ2XGQOO95ir",
	"smjaoAq28+c+qev7khbWGtkduTbJfLdLqYXS+x4pp6EimBQsP1fVXlwR2YBbVekEiZBRXB4CaSNsVq1d",
	"BHEmBeaFSDKGuRn/IL2YV0/M9+k7VeBBoJKl+4xE0mYgFwlKfwZYN8a9LmkVakpY6Ty6idphzdzrkdKb",
	"cf2tGX//7tu372/fDiejeJTZIvegaT2XqvWE1x/etbo6bqJ4FI8uHGErUbJS0B5pFLtZS2Yzl+/j7NDd",
	"sgm1aQabXFxjRpMEhZLCKl3fiRLquEh4x/df/+IaiPyJoZt1EsfPavA76zammesh0Op3605GKSAq3yji",
	"1eEEgIMn+3RDs9bfjPsfPNZ8e66kw0enmmnPl0QfeJ/s73jaq+pAe+y6EU4GwffCWHfn7zvm3KEvJShn",
	"lq2Z60v4m8gtuoNfYVowpfxhbhM5/Qgh0U5q1O3h/RQ28TBkfOjxfRicNfjQlXvuB/um2YfP/44I9o2q",
	"vf11P5oTJiEX5tBt9qcMYheVPnYcuzKByP1WI7NY96atXB9t0/dJ9dTdbdYXDmuW3G20qqTvIHH3F24D",
	"AuTuNYJLF+Sw3jnnty85DCgNGq0WeO974dzVx3rnRqwEX/Vbf7hyXStSWZH6cQnLc0Kpbmkn2rGvaf0E",
	"8hbe+v6CQz/17pR/Oy3X432/9UMvwC/+HT3YdXvT/k8PXMMOg/qL+lro0PYk+Mp3/bTahirj6dDqo/e/",
	"88WKOMQG/TLur638seHoz5It5GzXpvPVVtJ3+gbW8R9y3z2N9Zh2qtZpWEdBU2/Gvwr+cLLoNMvZbRhp",
	"bgrXOxDWuIjopUQ7EPplJRCA7940f8NAxOjwJwyuiabb+vzYHzT8ZxWJQ/PRn61K/OfE/T6GD/jnL+lD",
	"ofjBn5T6BqzuvqC9qRgTlScGc8TRVMLy9parI+RmPM5pQKaMvbleXC+8lM8P/x8AAP//3J4aOLQ2AAA=",
}

// 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: %s", err)
	}
	zr, err := gzip.NewReader(bytes.NewReader(zipped))
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %s", err)
	}
	var buf bytes.Buffer
	_, err = buf.ReadFrom(zr)
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %s", 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) {
	var 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) {
	var resolvePath = PathToRawSpec("")

	loader := openapi3.NewLoader()
	loader.IsExternalRefsAllowed = true
	loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
		var 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
}