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

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/go-chi/chi/v5"
	"github.com/oapi-codegen/runtime"
	strictnethttp "github.com/oapi-codegen/runtime/strictmiddleware/nethttp"
)

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Create Registry.
	// (POST /registry)
	CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams)
	// Delete a Registry
	// (DELETE /registry/{registry_ref})
	DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
	// Returns Registry Details
	// (GET /registry/{registry_ref})
	GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
	// Updates a Registry
	// (PUT /registry/{registry_ref})
	ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
	// List Artifact Labels
	// (GET /registry/{registry_ref}/artifact/labels)
	ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams)
	// Get Artifact Stats
	// (GET /registry/{registry_ref}/artifact/stats)
	GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams)
	// Delete Artifact
	// (DELETE /registry/{registry_ref}/artifact/{artifact})
	DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
	// Update Artifact Labels
	// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
	UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
	// Get Artifact Stats
	// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
	GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams)
	// Get Artifact Summary
	// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
	GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam)
	// Delete an Artifact Version
	// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
	DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
	// Describe Artifact Details
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/details)
	GetArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactDetailsParams)
	// Describe Docker Artifact Detail
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
	GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams)
	// Describe Docker Artifact Layers
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
	GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams)
	// Describe Docker Artifact Manifest
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
	GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams)
	// Describe Docker Artifact Manifests
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
	GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
	// Describe Artifact files
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/files)
	GetArtifactFiles(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactFilesParams)
	// Describe Helm Artifact Detail
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
	GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
	// Describe Helm Artifact Manifest
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
	GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
	// Get Artifact Version Summary
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
	GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam)
	// List Artifact Versions
	// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
	GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams)
	// List Artifacts for Registry
	// (GET /registry/{registry_ref}/artifacts)
	GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams)
	// Returns CLI Client Setup Details
	// (GET /registry/{registry_ref}/client-setup-details)
	GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams)
	// ListWebhooks
	// (GET /registry/{registry_ref}/webhooks)
	ListWebhooks(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListWebhooksParams)
	// CreateWebhook
	// (POST /registry/{registry_ref}/webhooks)
	CreateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam)
	// DeleteWebhook
	// (DELETE /registry/{registry_ref}/webhooks/{webhook_identifier})
	DeleteWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam)
	// GetWebhook
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier})
	GetWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam)
	// UpdateWebhook
	// (PUT /registry/{registry_ref}/webhooks/{webhook_identifier})
	UpdateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam)
	// ListWebhookExecutions
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions)
	ListWebhookExecutions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, params ListWebhookExecutionsParams)
	// GetWebhookExecution
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id})
	GetWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam)
	// ReTriggerWebhookExecution
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id}/retrigger)
	ReTriggerWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam)
	// List replication rules
	// (GET /replication/rules)
	ListReplicationRules(w http.ResponseWriter, r *http.Request, params ListReplicationRulesParams)
	// Create a replication rule
	// (POST /replication/rules)
	CreateReplicationRule(w http.ResponseWriter, r *http.Request, params CreateReplicationRuleParams)
	// Delete a replication rule
	// (DELETE /replication/rules/{id})
	DeleteReplicationRule(w http.ResponseWriter, r *http.Request, id string)
	// Get a replication rule
	// (GET /replication/rules/{id})
	GetReplicationRule(w http.ResponseWriter, r *http.Request, id string)
	// Update a replication rule
	// (PUT /replication/rules/{id})
	UpdateReplicationRule(w http.ResponseWriter, r *http.Request, id string)
	// List migration images
	// (GET /replication/rules/{id}/migration/images)
	ListMigrationImages(w http.ResponseWriter, r *http.Request, id string, params ListMigrationImagesParams)
	// Get migration logs for an image
	// (GET /replication/rules/{id}/migration/images/{image_id}/logs)
	GetMigrationLogsForImage(w http.ResponseWriter, r *http.Request, id string, imageId string)
	// Start migration
	// (POST /replication/rules/{id}/migration/start)
	StartMigration(w http.ResponseWriter, r *http.Request, id string)
	// Stop migration
	// (POST /replication/rules/{id}/migration/stop)
	StopMigration(w http.ResponseWriter, r *http.Request, id string)
	// Get artifact stats
	// (GET /spaces/{space_ref}/artifact/stats)
	GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams)
	// List artifacts
	// (GET /spaces/{space_ref}/artifacts)
	GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams)
	// List registries
	// (GET /spaces/{space_ref}/registries)
	GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams)
}

// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.

type Unimplemented struct{}

// Create Registry.
// (POST /registry)
func (_ Unimplemented) CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete a Registry
// (DELETE /registry/{registry_ref})
func (_ Unimplemented) DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Returns Registry Details
// (GET /registry/{registry_ref})
func (_ Unimplemented) GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Updates a Registry
// (PUT /registry/{registry_ref})
func (_ Unimplemented) ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List Artifact Labels
// (GET /registry/{registry_ref}/artifact/labels)
func (_ Unimplemented) ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get Artifact Stats
// (GET /registry/{registry_ref}/artifact/stats)
func (_ Unimplemented) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete Artifact
// (DELETE /registry/{registry_ref}/artifact/{artifact})
func (_ Unimplemented) DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Update Artifact Labels
// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
func (_ Unimplemented) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get Artifact Stats
// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
func (_ Unimplemented) GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get Artifact Summary
// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
func (_ Unimplemented) GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete an Artifact Version
// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
func (_ Unimplemented) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Artifact Details
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/details)
func (_ Unimplemented) GetArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactDetailsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Docker Artifact Detail
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
func (_ Unimplemented) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Docker Artifact Layers
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
func (_ Unimplemented) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Docker Artifact Manifest
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
func (_ Unimplemented) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Docker Artifact Manifests
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
func (_ Unimplemented) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Artifact files
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/files)
func (_ Unimplemented) GetArtifactFiles(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactFilesParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Helm Artifact Detail
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
func (_ Unimplemented) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Describe Helm Artifact Manifest
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
func (_ Unimplemented) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get Artifact Version Summary
// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
func (_ Unimplemented) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List Artifact Versions
// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
func (_ Unimplemented) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List Artifacts for Registry
// (GET /registry/{registry_ref}/artifacts)
func (_ Unimplemented) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Returns CLI Client Setup Details
// (GET /registry/{registry_ref}/client-setup-details)
func (_ Unimplemented) GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// ListWebhooks
// (GET /registry/{registry_ref}/webhooks)
func (_ Unimplemented) ListWebhooks(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListWebhooksParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// CreateWebhook
// (POST /registry/{registry_ref}/webhooks)
func (_ Unimplemented) CreateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// DeleteWebhook
// (DELETE /registry/{registry_ref}/webhooks/{webhook_identifier})
func (_ Unimplemented) DeleteWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// GetWebhook
// (GET /registry/{registry_ref}/webhooks/{webhook_identifier})
func (_ Unimplemented) GetWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// UpdateWebhook
// (PUT /registry/{registry_ref}/webhooks/{webhook_identifier})
func (_ Unimplemented) UpdateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// ListWebhookExecutions
// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions)
func (_ Unimplemented) ListWebhookExecutions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, params ListWebhookExecutionsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// GetWebhookExecution
// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id})
func (_ Unimplemented) GetWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// ReTriggerWebhookExecution
// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id}/retrigger)
func (_ Unimplemented) ReTriggerWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List replication rules
// (GET /replication/rules)
func (_ Unimplemented) ListReplicationRules(w http.ResponseWriter, r *http.Request, params ListReplicationRulesParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Create a replication rule
// (POST /replication/rules)
func (_ Unimplemented) CreateReplicationRule(w http.ResponseWriter, r *http.Request, params CreateReplicationRuleParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Delete a replication rule
// (DELETE /replication/rules/{id})
func (_ Unimplemented) DeleteReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get a replication rule
// (GET /replication/rules/{id})
func (_ Unimplemented) GetReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Update a replication rule
// (PUT /replication/rules/{id})
func (_ Unimplemented) UpdateReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List migration images
// (GET /replication/rules/{id}/migration/images)
func (_ Unimplemented) ListMigrationImages(w http.ResponseWriter, r *http.Request, id string, params ListMigrationImagesParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get migration logs for an image
// (GET /replication/rules/{id}/migration/images/{image_id}/logs)
func (_ Unimplemented) GetMigrationLogsForImage(w http.ResponseWriter, r *http.Request, id string, imageId string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Start migration
// (POST /replication/rules/{id}/migration/start)
func (_ Unimplemented) StartMigration(w http.ResponseWriter, r *http.Request, id string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Stop migration
// (POST /replication/rules/{id}/migration/stop)
func (_ Unimplemented) StopMigration(w http.ResponseWriter, r *http.Request, id string) {
	w.WriteHeader(http.StatusNotImplemented)
}

// Get artifact stats
// (GET /spaces/{space_ref}/artifact/stats)
func (_ Unimplemented) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List artifacts
// (GET /spaces/{space_ref}/artifacts)
func (_ Unimplemented) GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// List registries
// (GET /spaces/{space_ref}/registries)
func (_ Unimplemented) GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams) {
	w.WriteHeader(http.StatusNotImplemented)
}

// 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

// CreateRegistry operation middleware
func (siw *ServerInterfaceWrapper) CreateRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

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

	// ------------- Optional query parameter "space_ref" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteRegistry operation middleware
func (siw *ServerInterfaceWrapper) DeleteRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetRegistry operation middleware
func (siw *ServerInterfaceWrapper) GetRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ModifyRegistry operation middleware
func (siw *ServerInterfaceWrapper) ModifyRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListArtifactLabels operation middleware
func (siw *ServerInterfaceWrapper) ListArtifactLabels(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactStatsForRegistry operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "from" -------------

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

	// ------------- Optional query parameter "to" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteArtifact operation middleware
func (siw *ServerInterfaceWrapper) DeleteArtifact(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// UpdateArtifactLabels operation middleware
func (siw *ServerInterfaceWrapper) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactStats operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactStats(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

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

	// ------------- Optional query parameter "from" -------------

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

	// ------------- Optional query parameter "to" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactSummary operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactSummary(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteArtifactVersion operation middleware
func (siw *ServerInterfaceWrapper) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.DeleteArtifactVersion(w, r, registryRef, artifact, version)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactDetails operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactDetails(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

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

	// ------------- Optional query parameter "childVersion" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetDockerArtifactDetails operation middleware
func (siw *ServerInterfaceWrapper) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

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

	// ------------- Required query parameter "digest" -------------

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

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetDockerArtifactLayers operation middleware
func (siw *ServerInterfaceWrapper) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

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

	// ------------- Required query parameter "digest" -------------

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

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetDockerArtifactManifest operation middleware
func (siw *ServerInterfaceWrapper) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

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

	// ------------- Required query parameter "digest" -------------

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

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetDockerArtifactManifests operation middleware
func (siw *ServerInterfaceWrapper) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetDockerArtifactManifests(w, r, registryRef, artifact, version)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactFiles operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactFiles(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetHelmArtifactDetails operation middleware
func (siw *ServerInterfaceWrapper) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetHelmArtifactDetails(w, r, registryRef, artifact, version)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetHelmArtifactManifest operation middleware
func (siw *ServerInterfaceWrapper) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetHelmArtifactManifest(w, r, registryRef, artifact, version)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactVersionSummary operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

	// ------------- Path parameter "version" -------------
	var version VersionPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "version", chi.URLParam(r, "version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "version", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetArtifactVersionSummary(w, r, registryRef, artifact, version)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetAllArtifactVersions operation middleware
func (siw *ServerInterfaceWrapper) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "artifact" -------------
	var artifact ArtifactPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "artifact", chi.URLParam(r, "artifact"), &artifact, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artifact", Err: err})
		return
	}

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetAllArtifactsByRegistry operation middleware
func (siw *ServerInterfaceWrapper) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "label" -------------

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetClientSetupDetails operation middleware
func (siw *ServerInterfaceWrapper) GetClientSetupDetails(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "artifact" -------------

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

	// ------------- Optional query parameter "version" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListWebhooks operation middleware
func (siw *ServerInterfaceWrapper) ListWebhooks(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CreateWebhook operation middleware
func (siw *ServerInterfaceWrapper) CreateWebhook(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteWebhook operation middleware
func (siw *ServerInterfaceWrapper) DeleteWebhook(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetWebhook operation middleware
func (siw *ServerInterfaceWrapper) GetWebhook(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// UpdateWebhook operation middleware
func (siw *ServerInterfaceWrapper) UpdateWebhook(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListWebhookExecutions operation middleware
func (siw *ServerInterfaceWrapper) ListWebhookExecutions(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

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

	// ------------- 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 "size" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetWebhookExecution operation middleware
func (siw *ServerInterfaceWrapper) GetWebhookExecution(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

	// ------------- Path parameter "webhook_execution_id" -------------
	var webhookExecutionId WebhookExecutionIdPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_execution_id", chi.URLParam(r, "webhook_execution_id"), &webhookExecutionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_execution_id", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetWebhookExecution(w, r, registryRef, webhookIdentifier, webhookExecutionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ReTriggerWebhookExecution operation middleware
func (siw *ServerInterfaceWrapper) ReTriggerWebhookExecution(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "registry_ref" -------------
	var registryRef RegistryRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "registry_ref", chi.URLParam(r, "registry_ref"), &registryRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "registry_ref", Err: err})
		return
	}

	// ------------- Path parameter "webhook_identifier" -------------
	var webhookIdentifier WebhookIdentifierPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_identifier", chi.URLParam(r, "webhook_identifier"), &webhookIdentifier, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_identifier", Err: err})
		return
	}

	// ------------- Path parameter "webhook_execution_id" -------------
	var webhookExecutionId WebhookExecutionIdPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "webhook_execution_id", chi.URLParam(r, "webhook_execution_id"), &webhookExecutionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "webhook_execution_id", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ReTriggerWebhookExecution(w, r, registryRef, webhookIdentifier, webhookExecutionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListReplicationRules operation middleware
func (siw *ServerInterfaceWrapper) ListReplicationRules(w http.ResponseWriter, r *http.Request) {

	var err error

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

	// ------------- Optional query parameter "space_ref" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CreateReplicationRule operation middleware
func (siw *ServerInterfaceWrapper) CreateReplicationRule(w http.ResponseWriter, r *http.Request) {

	var err error

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

	// ------------- Optional query parameter "space_ref" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DeleteReplicationRule operation middleware
func (siw *ServerInterfaceWrapper) DeleteReplicationRule(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetReplicationRule operation middleware
func (siw *ServerInterfaceWrapper) GetReplicationRule(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// UpdateReplicationRule operation middleware
func (siw *ServerInterfaceWrapper) UpdateReplicationRule(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListMigrationImages operation middleware
func (siw *ServerInterfaceWrapper) ListMigrationImages(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetMigrationLogsForImage operation middleware
func (siw *ServerInterfaceWrapper) GetMigrationLogsForImage(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

	// ------------- Path parameter "image_id" -------------
	var imageId string

	err = runtime.BindStyledParameterWithOptions("simple", "image_id", chi.URLParam(r, "image_id"), &imageId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "image_id", Err: err})
		return
	}

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// StartMigration operation middleware
func (siw *ServerInterfaceWrapper) StartMigration(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// StopMigration operation middleware
func (siw *ServerInterfaceWrapper) StopMigration(w http.ResponseWriter, r *http.Request) {

	var err error

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

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetArtifactStatsForSpace operation middleware
func (siw *ServerInterfaceWrapper) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "space_ref" -------------
	var spaceRef SpaceRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "from" -------------

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

	// ------------- Optional query parameter "to" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetAllArtifacts operation middleware
func (siw *ServerInterfaceWrapper) GetAllArtifacts(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "space_ref" -------------
	var spaceRef SpaceRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "reg_identifier" -------------

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

	// ------------- Optional query parameter "latest_version" -------------

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

	// ------------- Optional query parameter "package_type" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetAllRegistries operation middleware
func (siw *ServerInterfaceWrapper) GetAllRegistries(w http.ResponseWriter, r *http.Request) {

	var err error

	// ------------- Path parameter "space_ref" -------------
	var spaceRef SpaceRefPathParam

	err = runtime.BindStyledParameterWithOptions("simple", "space_ref", chi.URLParam(r, "space_ref"), &spaceRef, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "space_ref", Err: err})
		return
	}

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

	// ------------- Optional query parameter "package_type" -------------

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

	// ------------- Optional query parameter "type" -------------

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

	// ------------- 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 "size" -------------

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

	// ------------- Optional query parameter "sort_order" -------------

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

	// ------------- Optional query parameter "sort_field" -------------

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

	// ------------- Optional query parameter "search_term" -------------

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

	// ------------- Optional query parameter "recursive" -------------

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

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

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

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, 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.Post(options.BaseURL+"/registry", wrapper.CreateRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/registry/{registry_ref}", wrapper.DeleteRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}", wrapper.GetRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/registry/{registry_ref}", wrapper.ModifyRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/labels", wrapper.ListArtifactLabels)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/stats", wrapper.GetArtifactStatsForRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}", wrapper.DeleteArtifact)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/labels", wrapper.UpdateArtifactLabels)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/stats", wrapper.GetArtifactStats)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/summary", wrapper.GetArtifactSummary)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}", wrapper.DeleteArtifactVersion)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/details", wrapper.GetArtifactDetails)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details", wrapper.GetDockerArtifactDetails)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers", wrapper.GetDockerArtifactLayers)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest", wrapper.GetDockerArtifactManifest)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests", wrapper.GetDockerArtifactManifests)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/files", wrapper.GetArtifactFiles)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details", wrapper.GetHelmArtifactDetails)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest", wrapper.GetHelmArtifactManifest)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/version/{version}/summary", wrapper.GetArtifactVersionSummary)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifact/{artifact}/versions", wrapper.GetAllArtifactVersions)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/artifacts", wrapper.GetAllArtifactsByRegistry)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/client-setup-details", wrapper.GetClientSetupDetails)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/webhooks", wrapper.ListWebhooks)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/registry/{registry_ref}/webhooks", wrapper.CreateWebhook)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}", wrapper.DeleteWebhook)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}", wrapper.GetWebhook)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}", wrapper.UpdateWebhook)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}/executions", wrapper.ListWebhookExecutions)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id}", wrapper.GetWebhookExecution)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id}/retrigger", wrapper.ReTriggerWebhookExecution)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/replication/rules", wrapper.ListReplicationRules)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/replication/rules", wrapper.CreateReplicationRule)
	})
	r.Group(func(r chi.Router) {
		r.Delete(options.BaseURL+"/replication/rules/{id}", wrapper.DeleteReplicationRule)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/replication/rules/{id}", wrapper.GetReplicationRule)
	})
	r.Group(func(r chi.Router) {
		r.Put(options.BaseURL+"/replication/rules/{id}", wrapper.UpdateReplicationRule)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/replication/rules/{id}/migration/images", wrapper.ListMigrationImages)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/replication/rules/{id}/migration/images/{image_id}/logs", wrapper.GetMigrationLogsForImage)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/replication/rules/{id}/migration/start", wrapper.StartMigration)
	})
	r.Group(func(r chi.Router) {
		r.Post(options.BaseURL+"/replication/rules/{id}/migration/stop", wrapper.StopMigration)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/spaces/{space_ref}/artifact/stats", wrapper.GetArtifactStatsForSpace)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/spaces/{space_ref}/artifacts", wrapper.GetAllArtifacts)
	})
	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/spaces/{space_ref}/registries", wrapper.GetAllRegistries)
	})

	return r
}

type ArtifactDetailResponseJSONResponse struct {
	// Data Artifact Detail
	Data ArtifactDetail `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ArtifactLabelResponseJSONResponse struct {
	// Data Harness Artifact Summary
	Data ArtifactSummary `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ArtifactStatsResponseJSONResponse struct {
	// Data Harness Artifact Stats
	Data ArtifactStats `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ArtifactSummaryResponseJSONResponse struct {
	// Data Harness Artifact Summary
	Data ArtifactSummary `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ArtifactVersionSummaryResponseJSONResponse struct {
	// Data Docker Artifact Version Summary
	Data ArtifactVersionSummary `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type BadRequestJSONResponse Error

type ClientSetupDetailsResponseJSONResponse struct {
	// Data Client Setup Details
	Data ClientSetupDetails `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type DockerArtifactDetailResponseJSONResponse struct {
	// Data Docker Artifact Detail
	Data DockerArtifactDetail `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type DockerArtifactManifestResponseJSONResponse struct {
	// Data Docker Artifact Manifest
	Data DockerArtifactManifest `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type DockerLayersResponseJSONResponse struct {
	// Data Harness Layers Summary
	Data DockerLayersSummary `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type DockerManifestsResponseJSONResponse struct {
	// Data Harness Manifests
	Data DockerManifests `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type FileDetailResponseJSONResponse struct {
	// Files A list of Harness Artifact Files
	Files []FileDetail `json:"files"`

	// ItemCount The total number of items
	ItemCount *int64 `json:"itemCount,omitempty"`

	// PageCount The total number of pages
	PageCount *int64 `json:"pageCount,omitempty"`

	// PageIndex The current page
	PageIndex *int64 `json:"pageIndex,omitempty"`

	// PageSize The number of items per page
	PageSize *int `json:"pageSize,omitempty"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type HelmArtifactDetailResponseJSONResponse struct {
	// Data Helm Artifact Detail
	Data HelmArtifactDetail `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type HelmArtifactManifestResponseJSONResponse struct {
	// Data Helm Artifact Manifest
	Data HelmArtifactManifest `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type InternalServerErrorJSONResponse Error

type ListArtifactLabelResponseJSONResponse struct {
	// Data A list of Harness Artifact Labels
	Data ListArtifactLabel `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListArtifactResponseJSONResponse struct {
	// Data A list of Artifacts
	Data ListArtifact `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListArtifactVersionResponseJSONResponse struct {
	// Data A list of Artifact versions
	Data ListArtifactVersion `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListMigrationImageResponseJSONResponse struct {
	// Data A list of migration images
	Data ListMigrationImage `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListRegistryArtifactResponseJSONResponse struct {
	// Data A list of Artifacts
	Data ListRegistryArtifact `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListRegistryResponseJSONResponse struct {
	// Data A list of Harness Artifact Registries
	Data ListRegistry `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListReplicationRuleResponseJSONResponse struct {
	// Data A list of replication rules
	Data ListReplicationRule `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListWebhooksExecutionResponseJSONResponse struct {
	// Data A list of Harness Registries webhooks executions
	Data ListWebhooksExecutions `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ListWebhooksResponseJSONResponse struct {
	// Data A list of Harness Registries webhooks
	Data ListWebhooks `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type NotFoundJSONResponse Error

type PlainTextResponseTextplainCharsetUtf8Response struct {
	Body io.Reader

	ContentLength int64
}

type RegistryResponseJSONResponse struct {
	// Data Harness Artifact Registry
	Data Registry `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type ReplicationRuleResponseJSONResponse struct {
	Data ReplicationRule `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type SuccessJSONResponse struct {
	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type UnauthenticatedJSONResponse Error

type UnauthorizedJSONResponse Error

type WebhookExecutionResponseJSONResponse struct {
	// Data Harness Regstries Webhook Execution
	Data WebhookExecution `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type WebhookResponseJSONResponse struct {
	// Data Harness Regstries Webhook
	Data Webhook `json:"data"`

	// Status Indicates if the request was successful or not
	Status Status `json:"status"`
}

type CreateRegistryRequestObject struct {
	Params CreateRegistryParams
	Body   *CreateRegistryJSONRequestBody
}

type CreateRegistryResponseObject interface {
	VisitCreateRegistryResponse(w http.ResponseWriter) error
}

type CreateRegistry201JSONResponse struct{ RegistryResponseJSONResponse }

func (response CreateRegistry201JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)

	return json.NewEncoder(w).Encode(response)
}

type CreateRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response CreateRegistry400JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type CreateRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response CreateRegistry401JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type CreateRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response CreateRegistry403JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type CreateRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response CreateRegistry500JSONResponse) VisitCreateRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
}

type DeleteRegistryResponseObject interface {
	VisitDeleteRegistryResponse(w http.ResponseWriter) error
}

type DeleteRegistry200JSONResponse struct{ SuccessJSONResponse }

func (response DeleteRegistry200JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response DeleteRegistry400JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response DeleteRegistry401JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response DeleteRegistry403JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistry404JSONResponse struct{ NotFoundJSONResponse }

func (response DeleteRegistry404JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type DeleteRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response DeleteRegistry500JSONResponse) VisitDeleteRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
}

type GetRegistryResponseObject interface {
	VisitGetRegistryResponse(w http.ResponseWriter) error
}

type GetRegistry200JSONResponse struct{ RegistryResponseJSONResponse }

func (response GetRegistry200JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response GetRegistry400JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetRegistry401JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetRegistry403JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistry404JSONResponse struct{ NotFoundJSONResponse }

func (response GetRegistry404JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetRegistry500JSONResponse) VisitGetRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Body        *ModifyRegistryJSONRequestBody
}

type ModifyRegistryResponseObject interface {
	VisitModifyRegistryResponse(w http.ResponseWriter) error
}

type ModifyRegistry200JSONResponse struct{ RegistryResponseJSONResponse }

func (response ModifyRegistry200JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response ModifyRegistry400JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ModifyRegistry401JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ModifyRegistry403JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistry404JSONResponse struct{ NotFoundJSONResponse }

func (response ModifyRegistry404JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type ModifyRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ModifyRegistry500JSONResponse) VisitModifyRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabelsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Params      ListArtifactLabelsParams
}

type ListArtifactLabelsResponseObject interface {
	VisitListArtifactLabelsResponse(w http.ResponseWriter) error
}

type ListArtifactLabels200JSONResponse struct {
	ListArtifactLabelResponseJSONResponse
}

func (response ListArtifactLabels200JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabels400JSONResponse struct{ BadRequestJSONResponse }

func (response ListArtifactLabels400JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabels401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ListArtifactLabels401JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabels403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ListArtifactLabels403JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabels404JSONResponse struct{ NotFoundJSONResponse }

func (response ListArtifactLabels404JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type ListArtifactLabels500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ListArtifactLabels500JSONResponse) VisitListArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Params      GetArtifactStatsForRegistryParams
}

type GetArtifactStatsForRegistryResponseObject interface {
	VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error
}

type GetArtifactStatsForRegistry200JSONResponse struct {
	ArtifactStatsResponseJSONResponse
}

func (response GetArtifactStatsForRegistry200JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactStatsForRegistry400JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactStatsForRegistry401JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactStatsForRegistry403JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistry404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactStatsForRegistry404JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactStatsForRegistry500JSONResponse) VisitGetArtifactStatsForRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
}

type DeleteArtifactResponseObject interface {
	VisitDeleteArtifactResponse(w http.ResponseWriter) error
}

type DeleteArtifact200JSONResponse struct{ SuccessJSONResponse }

func (response DeleteArtifact200JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifact400JSONResponse struct{ BadRequestJSONResponse }

func (response DeleteArtifact400JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifact401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response DeleteArtifact401JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifact403JSONResponse struct{ UnauthorizedJSONResponse }

func (response DeleteArtifact403JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifact404JSONResponse struct{ NotFoundJSONResponse }

func (response DeleteArtifact404JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifact500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response DeleteArtifact500JSONResponse) VisitDeleteArtifactResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabelsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Body        *UpdateArtifactLabelsJSONRequestBody
}

type UpdateArtifactLabelsResponseObject interface {
	VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error
}

type UpdateArtifactLabels200JSONResponse struct {
	ArtifactLabelResponseJSONResponse
}

func (response UpdateArtifactLabels200JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabels400JSONResponse struct{ BadRequestJSONResponse }

func (response UpdateArtifactLabels400JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabels401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response UpdateArtifactLabels401JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabels403JSONResponse struct{ UnauthorizedJSONResponse }

func (response UpdateArtifactLabels403JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabels404JSONResponse struct{ NotFoundJSONResponse }

func (response UpdateArtifactLabels404JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type UpdateArtifactLabels500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response UpdateArtifactLabels500JSONResponse) VisitUpdateArtifactLabelsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Params      GetArtifactStatsParams
}

type GetArtifactStatsResponseObject interface {
	VisitGetArtifactStatsResponse(w http.ResponseWriter) error
}

type GetArtifactStats200JSONResponse struct {
	ArtifactStatsResponseJSONResponse
}

func (response GetArtifactStats200JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStats400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactStats400JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStats401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactStats401JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStats403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactStats403JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStats404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactStats404JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStats500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactStats500JSONResponse) VisitGetArtifactStatsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummaryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
}

type GetArtifactSummaryResponseObject interface {
	VisitGetArtifactSummaryResponse(w http.ResponseWriter) error
}

type GetArtifactSummary200JSONResponse struct {
	ArtifactSummaryResponseJSONResponse
}

func (response GetArtifactSummary200JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummary400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactSummary400JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummary401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactSummary401JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummary403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactSummary403JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummary404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactSummary404JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactSummary500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactSummary500JSONResponse) VisitGetArtifactSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersionRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
}

type DeleteArtifactVersionResponseObject interface {
	VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error
}

type DeleteArtifactVersion200JSONResponse struct{ SuccessJSONResponse }

func (response DeleteArtifactVersion200JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersion400JSONResponse struct{ BadRequestJSONResponse }

func (response DeleteArtifactVersion400JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersion401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response DeleteArtifactVersion401JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersion403JSONResponse struct{ UnauthorizedJSONResponse }

func (response DeleteArtifactVersion403JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersion404JSONResponse struct{ NotFoundJSONResponse }

func (response DeleteArtifactVersion404JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type DeleteArtifactVersion500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response DeleteArtifactVersion500JSONResponse) VisitDeleteArtifactVersionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetailsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
	Params      GetArtifactDetailsParams
}

type GetArtifactDetailsResponseObject interface {
	VisitGetArtifactDetailsResponse(w http.ResponseWriter) error
}

type GetArtifactDetails200JSONResponse struct {
	ArtifactDetailResponseJSONResponse
}

func (response GetArtifactDetails200JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetails400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactDetails400JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetails401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactDetails401JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetails403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactDetails403JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetails404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactDetails404JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactDetails500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactDetails500JSONResponse) VisitGetArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetailsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
	Params      GetDockerArtifactDetailsParams
}

type GetDockerArtifactDetailsResponseObject interface {
	VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error
}

type GetDockerArtifactDetails200JSONResponse struct {
	DockerArtifactDetailResponseJSONResponse
}

func (response GetDockerArtifactDetails200JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetails400JSONResponse struct{ BadRequestJSONResponse }

func (response GetDockerArtifactDetails400JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetails401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetDockerArtifactDetails401JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetails403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetDockerArtifactDetails403JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetails404JSONResponse struct{ NotFoundJSONResponse }

func (response GetDockerArtifactDetails404JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactDetails500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetDockerArtifactDetails500JSONResponse) VisitGetDockerArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayersRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
	Params      GetDockerArtifactLayersParams
}

type GetDockerArtifactLayersResponseObject interface {
	VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error
}

type GetDockerArtifactLayers200JSONResponse struct {
	DockerLayersResponseJSONResponse
}

func (response GetDockerArtifactLayers200JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayers400JSONResponse struct{ BadRequestJSONResponse }

func (response GetDockerArtifactLayers400JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayers401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetDockerArtifactLayers401JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayers403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetDockerArtifactLayers403JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayers404JSONResponse struct{ NotFoundJSONResponse }

func (response GetDockerArtifactLayers404JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactLayers500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetDockerArtifactLayers500JSONResponse) VisitGetDockerArtifactLayersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifestRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
	Params      GetDockerArtifactManifestParams
}

type GetDockerArtifactManifestResponseObject interface {
	VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error
}

type GetDockerArtifactManifest200JSONResponse struct {
	DockerArtifactManifestResponseJSONResponse
}

func (response GetDockerArtifactManifest200JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifest400JSONResponse struct{ BadRequestJSONResponse }

func (response GetDockerArtifactManifest400JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifest401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetDockerArtifactManifest401JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifest403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetDockerArtifactManifest403JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifest404JSONResponse struct{ NotFoundJSONResponse }

func (response GetDockerArtifactManifest404JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifest500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetDockerArtifactManifest500JSONResponse) VisitGetDockerArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifestsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
}

type GetDockerArtifactManifestsResponseObject interface {
	VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error
}

type GetDockerArtifactManifests200JSONResponse struct {
	DockerManifestsResponseJSONResponse
}

func (response GetDockerArtifactManifests200JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifests400JSONResponse struct{ BadRequestJSONResponse }

func (response GetDockerArtifactManifests400JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifests401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetDockerArtifactManifests401JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifests403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetDockerArtifactManifests403JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifests404JSONResponse struct{ NotFoundJSONResponse }

func (response GetDockerArtifactManifests404JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDockerArtifactManifests500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetDockerArtifactManifests500JSONResponse) VisitGetDockerArtifactManifestsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFilesRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
	Params      GetArtifactFilesParams
}

type GetArtifactFilesResponseObject interface {
	VisitGetArtifactFilesResponse(w http.ResponseWriter) error
}

type GetArtifactFiles200JSONResponse struct{ FileDetailResponseJSONResponse }

func (response GetArtifactFiles200JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFiles400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactFiles400JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFiles401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactFiles401JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFiles403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactFiles403JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFiles404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactFiles404JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactFiles500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactFiles500JSONResponse) VisitGetArtifactFilesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetailsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
}

type GetHelmArtifactDetailsResponseObject interface {
	VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error
}

type GetHelmArtifactDetails200JSONResponse struct {
	HelmArtifactDetailResponseJSONResponse
}

func (response GetHelmArtifactDetails200JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetails400JSONResponse struct{ BadRequestJSONResponse }

func (response GetHelmArtifactDetails400JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetails401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetHelmArtifactDetails401JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetails403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetHelmArtifactDetails403JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetails404JSONResponse struct{ NotFoundJSONResponse }

func (response GetHelmArtifactDetails404JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactDetails500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetHelmArtifactDetails500JSONResponse) VisitGetHelmArtifactDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifestRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
}

type GetHelmArtifactManifestResponseObject interface {
	VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error
}

type GetHelmArtifactManifest200JSONResponse struct {
	HelmArtifactManifestResponseJSONResponse
}

func (response GetHelmArtifactManifest200JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifest400JSONResponse struct{ BadRequestJSONResponse }

func (response GetHelmArtifactManifest400JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifest401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetHelmArtifactManifest401JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifest403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetHelmArtifactManifest403JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifest404JSONResponse struct{ NotFoundJSONResponse }

func (response GetHelmArtifactManifest404JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetHelmArtifactManifest500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetHelmArtifactManifest500JSONResponse) VisitGetHelmArtifactManifestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummaryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Version     VersionPathParam     `json:"version"`
}

type GetArtifactVersionSummaryResponseObject interface {
	VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error
}

type GetArtifactVersionSummary200JSONResponse struct {
	ArtifactVersionSummaryResponseJSONResponse
}

func (response GetArtifactVersionSummary200JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummary400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactVersionSummary400JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummary401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactVersionSummary401JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummary403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactVersionSummary403JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummary404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactVersionSummary404JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactVersionSummary500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactVersionSummary500JSONResponse) VisitGetArtifactVersionSummaryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersionsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Artifact    ArtifactPathParam    `json:"artifact"`
	Params      GetAllArtifactVersionsParams
}

type GetAllArtifactVersionsResponseObject interface {
	VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error
}

type GetAllArtifactVersions200JSONResponse struct {
	ListArtifactVersionResponseJSONResponse
}

func (response GetAllArtifactVersions200JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersions400JSONResponse struct{ BadRequestJSONResponse }

func (response GetAllArtifactVersions400JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersions401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetAllArtifactVersions401JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersions403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetAllArtifactVersions403JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersions404JSONResponse struct{ NotFoundJSONResponse }

func (response GetAllArtifactVersions404JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactVersions500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetAllArtifactVersions500JSONResponse) VisitGetAllArtifactVersionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistryRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Params      GetAllArtifactsByRegistryParams
}

type GetAllArtifactsByRegistryResponseObject interface {
	VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error
}

type GetAllArtifactsByRegistry200JSONResponse struct {
	ListRegistryArtifactResponseJSONResponse
}

func (response GetAllArtifactsByRegistry200JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistry400JSONResponse struct{ BadRequestJSONResponse }

func (response GetAllArtifactsByRegistry400JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistry401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetAllArtifactsByRegistry401JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistry403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetAllArtifactsByRegistry403JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistry404JSONResponse struct{ NotFoundJSONResponse }

func (response GetAllArtifactsByRegistry404JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsByRegistry500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetAllArtifactsByRegistry500JSONResponse) VisitGetAllArtifactsByRegistryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetailsRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Params      GetClientSetupDetailsParams
}

type GetClientSetupDetailsResponseObject interface {
	VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error
}

type GetClientSetupDetails200JSONResponse struct {
	ClientSetupDetailsResponseJSONResponse
}

func (response GetClientSetupDetails200JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetails400JSONResponse struct{ BadRequestJSONResponse }

func (response GetClientSetupDetails400JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetails401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetClientSetupDetails401JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetails403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetClientSetupDetails403JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetails404JSONResponse struct{ NotFoundJSONResponse }

func (response GetClientSetupDetails404JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetClientSetupDetails500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetClientSetupDetails500JSONResponse) VisitGetClientSetupDetailsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhooksRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Params      ListWebhooksParams
}

type ListWebhooksResponseObject interface {
	VisitListWebhooksResponse(w http.ResponseWriter) error
}

type ListWebhooks200JSONResponse struct {
	ListWebhooksResponseJSONResponse
}

func (response ListWebhooks200JSONResponse) VisitListWebhooksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhooks400JSONResponse struct{ BadRequestJSONResponse }

func (response ListWebhooks400JSONResponse) VisitListWebhooksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhooks401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ListWebhooks401JSONResponse) VisitListWebhooksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhooks403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ListWebhooks403JSONResponse) VisitListWebhooksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhooks500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ListWebhooks500JSONResponse) VisitListWebhooksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type CreateWebhookRequestObject struct {
	RegistryRef RegistryRefPathParam `json:"registry_ref"`
	Body        *CreateWebhookJSONRequestBody
}

type CreateWebhookResponseObject interface {
	VisitCreateWebhookResponse(w http.ResponseWriter) error
}

type CreateWebhook201JSONResponse struct{ WebhookResponseJSONResponse }

func (response CreateWebhook201JSONResponse) VisitCreateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)

	return json.NewEncoder(w).Encode(response)
}

type CreateWebhook400JSONResponse struct{ BadRequestJSONResponse }

func (response CreateWebhook400JSONResponse) VisitCreateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type CreateWebhook401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response CreateWebhook401JSONResponse) VisitCreateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type CreateWebhook403JSONResponse struct{ UnauthorizedJSONResponse }

func (response CreateWebhook403JSONResponse) VisitCreateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type CreateWebhook500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response CreateWebhook500JSONResponse) VisitCreateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhookRequestObject struct {
	RegistryRef       RegistryRefPathParam       `json:"registry_ref"`
	WebhookIdentifier WebhookIdentifierPathParam `json:"webhook_identifier"`
}

type DeleteWebhookResponseObject interface {
	VisitDeleteWebhookResponse(w http.ResponseWriter) error
}

type DeleteWebhook200JSONResponse struct{ SuccessJSONResponse }

func (response DeleteWebhook200JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhook400JSONResponse struct{ BadRequestJSONResponse }

func (response DeleteWebhook400JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhook401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response DeleteWebhook401JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhook403JSONResponse struct{ UnauthorizedJSONResponse }

func (response DeleteWebhook403JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhook404JSONResponse struct{ NotFoundJSONResponse }

func (response DeleteWebhook404JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type DeleteWebhook500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response DeleteWebhook500JSONResponse) VisitDeleteWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookRequestObject struct {
	RegistryRef       RegistryRefPathParam       `json:"registry_ref"`
	WebhookIdentifier WebhookIdentifierPathParam `json:"webhook_identifier"`
}

type GetWebhookResponseObject interface {
	VisitGetWebhookResponse(w http.ResponseWriter) error
}

type GetWebhook200JSONResponse struct{ WebhookResponseJSONResponse }

func (response GetWebhook200JSONResponse) VisitGetWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhook400JSONResponse struct{ BadRequestJSONResponse }

func (response GetWebhook400JSONResponse) VisitGetWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhook401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetWebhook401JSONResponse) VisitGetWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhook403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetWebhook403JSONResponse) VisitGetWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhook500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetWebhook500JSONResponse) VisitGetWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UpdateWebhookRequestObject struct {
	RegistryRef       RegistryRefPathParam       `json:"registry_ref"`
	WebhookIdentifier WebhookIdentifierPathParam `json:"webhook_identifier"`
	Body              *UpdateWebhookJSONRequestBody
}

type UpdateWebhookResponseObject interface {
	VisitUpdateWebhookResponse(w http.ResponseWriter) error
}

type UpdateWebhook201JSONResponse struct{ WebhookResponseJSONResponse }

func (response UpdateWebhook201JSONResponse) VisitUpdateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)

	return json.NewEncoder(w).Encode(response)
}

type UpdateWebhook400JSONResponse struct{ BadRequestJSONResponse }

func (response UpdateWebhook400JSONResponse) VisitUpdateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UpdateWebhook401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response UpdateWebhook401JSONResponse) VisitUpdateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UpdateWebhook403JSONResponse struct{ UnauthorizedJSONResponse }

func (response UpdateWebhook403JSONResponse) VisitUpdateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type UpdateWebhook500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response UpdateWebhook500JSONResponse) VisitUpdateWebhookResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhookExecutionsRequestObject struct {
	RegistryRef       RegistryRefPathParam       `json:"registry_ref"`
	WebhookIdentifier WebhookIdentifierPathParam `json:"webhook_identifier"`
	Params            ListWebhookExecutionsParams
}

type ListWebhookExecutionsResponseObject interface {
	VisitListWebhookExecutionsResponse(w http.ResponseWriter) error
}

type ListWebhookExecutions200JSONResponse struct {
	ListWebhooksExecutionResponseJSONResponse
}

func (response ListWebhookExecutions200JSONResponse) VisitListWebhookExecutionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhookExecutions400JSONResponse struct{ BadRequestJSONResponse }

func (response ListWebhookExecutions400JSONResponse) VisitListWebhookExecutionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhookExecutions401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ListWebhookExecutions401JSONResponse) VisitListWebhookExecutionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhookExecutions403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ListWebhookExecutions403JSONResponse) VisitListWebhookExecutionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ListWebhookExecutions500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ListWebhookExecutions500JSONResponse) VisitListWebhookExecutionsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookExecutionRequestObject struct {
	RegistryRef        RegistryRefPathParam        `json:"registry_ref"`
	WebhookIdentifier  WebhookIdentifierPathParam  `json:"webhook_identifier"`
	WebhookExecutionId WebhookExecutionIdPathParam `json:"webhook_execution_id"`
}

type GetWebhookExecutionResponseObject interface {
	VisitGetWebhookExecutionResponse(w http.ResponseWriter) error
}

type GetWebhookExecution200JSONResponse struct {
	WebhookExecutionResponseJSONResponse
}

func (response GetWebhookExecution200JSONResponse) VisitGetWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookExecution400JSONResponse struct{ BadRequestJSONResponse }

func (response GetWebhookExecution400JSONResponse) VisitGetWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookExecution401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetWebhookExecution401JSONResponse) VisitGetWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookExecution403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetWebhookExecution403JSONResponse) VisitGetWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetWebhookExecution500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetWebhookExecution500JSONResponse) VisitGetWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ReTriggerWebhookExecutionRequestObject struct {
	RegistryRef        RegistryRefPathParam        `json:"registry_ref"`
	WebhookIdentifier  WebhookIdentifierPathParam  `json:"webhook_identifier"`
	WebhookExecutionId WebhookExecutionIdPathParam `json:"webhook_execution_id"`
}

type ReTriggerWebhookExecutionResponseObject interface {
	VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error
}

type ReTriggerWebhookExecution200JSONResponse struct {
	WebhookExecutionResponseJSONResponse
}

func (response ReTriggerWebhookExecution200JSONResponse) VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ReTriggerWebhookExecution400JSONResponse struct{ BadRequestJSONResponse }

func (response ReTriggerWebhookExecution400JSONResponse) VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ReTriggerWebhookExecution401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ReTriggerWebhookExecution401JSONResponse) VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ReTriggerWebhookExecution403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ReTriggerWebhookExecution403JSONResponse) VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ReTriggerWebhookExecution500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ReTriggerWebhookExecution500JSONResponse) VisitReTriggerWebhookExecutionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRulesRequestObject struct {
	Params ListReplicationRulesParams
}

type ListReplicationRulesResponseObject interface {
	VisitListReplicationRulesResponse(w http.ResponseWriter) error
}

type ListReplicationRules200JSONResponse struct {
	ListReplicationRuleResponseJSONResponse
}

func (response ListReplicationRules200JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRules400JSONResponse struct{ BadRequestJSONResponse }

func (response ListReplicationRules400JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRules401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ListReplicationRules401JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRules403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ListReplicationRules403JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRules404JSONResponse struct{ NotFoundJSONResponse }

func (response ListReplicationRules404JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type ListReplicationRules500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ListReplicationRules500JSONResponse) VisitListReplicationRulesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRuleRequestObject struct {
	Params CreateReplicationRuleParams
	Body   *CreateReplicationRuleJSONRequestBody
}

type CreateReplicationRuleResponseObject interface {
	VisitCreateReplicationRuleResponse(w http.ResponseWriter) error
}

type CreateReplicationRule200JSONResponse struct {
	ReplicationRuleResponseJSONResponse
}

func (response CreateReplicationRule200JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRule400JSONResponse struct{ BadRequestJSONResponse }

func (response CreateReplicationRule400JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRule401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response CreateReplicationRule401JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRule403JSONResponse struct{ UnauthorizedJSONResponse }

func (response CreateReplicationRule403JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRule404JSONResponse struct{ NotFoundJSONResponse }

func (response CreateReplicationRule404JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type CreateReplicationRule500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response CreateReplicationRule500JSONResponse) VisitCreateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRuleRequestObject struct {
	Id string `json:"id"`
}

type DeleteReplicationRuleResponseObject interface {
	VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error
}

type DeleteReplicationRule200JSONResponse struct{ SuccessJSONResponse }

func (response DeleteReplicationRule200JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRule400JSONResponse struct{ BadRequestJSONResponse }

func (response DeleteReplicationRule400JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRule401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response DeleteReplicationRule401JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRule403JSONResponse struct{ UnauthorizedJSONResponse }

func (response DeleteReplicationRule403JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRule404JSONResponse struct{ NotFoundJSONResponse }

func (response DeleteReplicationRule404JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type DeleteReplicationRule500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response DeleteReplicationRule500JSONResponse) VisitDeleteReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRuleRequestObject struct {
	Id string `json:"id"`
}

type GetReplicationRuleResponseObject interface {
	VisitGetReplicationRuleResponse(w http.ResponseWriter) error
}

type GetReplicationRule200JSONResponse struct {
	ReplicationRuleResponseJSONResponse
}

func (response GetReplicationRule200JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRule400JSONResponse struct{ BadRequestJSONResponse }

func (response GetReplicationRule400JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRule401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetReplicationRule401JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRule403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetReplicationRule403JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRule404JSONResponse struct{ NotFoundJSONResponse }

func (response GetReplicationRule404JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetReplicationRule500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetReplicationRule500JSONResponse) VisitGetReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRuleRequestObject struct {
	Id   string `json:"id"`
	Body *UpdateReplicationRuleJSONRequestBody
}

type UpdateReplicationRuleResponseObject interface {
	VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error
}

type UpdateReplicationRule200JSONResponse struct {
	ReplicationRuleResponseJSONResponse
}

func (response UpdateReplicationRule200JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRule400JSONResponse struct{ BadRequestJSONResponse }

func (response UpdateReplicationRule400JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRule401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response UpdateReplicationRule401JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRule403JSONResponse struct{ UnauthorizedJSONResponse }

func (response UpdateReplicationRule403JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRule404JSONResponse struct{ NotFoundJSONResponse }

func (response UpdateReplicationRule404JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type UpdateReplicationRule500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response UpdateReplicationRule500JSONResponse) VisitUpdateReplicationRuleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImagesRequestObject struct {
	Id     string `json:"id"`
	Params ListMigrationImagesParams
}

type ListMigrationImagesResponseObject interface {
	VisitListMigrationImagesResponse(w http.ResponseWriter) error
}

type ListMigrationImages200JSONResponse struct {
	ListMigrationImageResponseJSONResponse
}

func (response ListMigrationImages200JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImages400JSONResponse struct{ BadRequestJSONResponse }

func (response ListMigrationImages400JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImages401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response ListMigrationImages401JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImages403JSONResponse struct{ UnauthorizedJSONResponse }

func (response ListMigrationImages403JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImages404JSONResponse struct{ NotFoundJSONResponse }

func (response ListMigrationImages404JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type ListMigrationImages500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response ListMigrationImages500JSONResponse) VisitListMigrationImagesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetMigrationLogsForImageRequestObject struct {
	Id      string `json:"id"`
	ImageId string `json:"image_id"`
}

type GetMigrationLogsForImageResponseObject interface {
	VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error
}

type GetMigrationLogsForImage200TextplainCharsetUtf8Response struct {
	PlainTextResponseTextplainCharsetUtf8Response
}

func (response GetMigrationLogsForImage200TextplainCharsetUtf8Response) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type GetMigrationLogsForImage400JSONResponse struct{ BadRequestJSONResponse }

func (response GetMigrationLogsForImage400JSONResponse) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetMigrationLogsForImage401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetMigrationLogsForImage401JSONResponse) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetMigrationLogsForImage403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetMigrationLogsForImage403JSONResponse) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetMigrationLogsForImage404JSONResponse struct{ NotFoundJSONResponse }

func (response GetMigrationLogsForImage404JSONResponse) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetMigrationLogsForImage500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetMigrationLogsForImage500JSONResponse) VisitGetMigrationLogsForImageResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type StartMigrationRequestObject struct {
	Id string `json:"id"`
}

type StartMigrationResponseObject interface {
	VisitStartMigrationResponse(w http.ResponseWriter) error
}

type StartMigration200JSONResponse struct{ SuccessJSONResponse }

func (response StartMigration200JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type StartMigration400JSONResponse struct{ BadRequestJSONResponse }

func (response StartMigration400JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type StartMigration401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response StartMigration401JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type StartMigration403JSONResponse struct{ UnauthorizedJSONResponse }

func (response StartMigration403JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type StartMigration404JSONResponse struct{ NotFoundJSONResponse }

func (response StartMigration404JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type StartMigration500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response StartMigration500JSONResponse) VisitStartMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type StopMigrationRequestObject struct {
	Id string `json:"id"`
}

type StopMigrationResponseObject interface {
	VisitStopMigrationResponse(w http.ResponseWriter) error
}

type StopMigration200JSONResponse struct{ SuccessJSONResponse }

func (response StopMigration200JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type StopMigration400JSONResponse struct{ BadRequestJSONResponse }

func (response StopMigration400JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type StopMigration401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response StopMigration401JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type StopMigration403JSONResponse struct{ UnauthorizedJSONResponse }

func (response StopMigration403JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type StopMigration404JSONResponse struct{ NotFoundJSONResponse }

func (response StopMigration404JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type StopMigration500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response StopMigration500JSONResponse) VisitStopMigrationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpaceRequestObject struct {
	SpaceRef SpaceRefPathParam `json:"space_ref"`
	Params   GetArtifactStatsForSpaceParams
}

type GetArtifactStatsForSpaceResponseObject interface {
	VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error
}

type GetArtifactStatsForSpace200JSONResponse struct {
	ArtifactStatsResponseJSONResponse
}

func (response GetArtifactStatsForSpace200JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpace400JSONResponse struct{ BadRequestJSONResponse }

func (response GetArtifactStatsForSpace400JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpace401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetArtifactStatsForSpace401JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpace403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetArtifactStatsForSpace403JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpace404JSONResponse struct{ NotFoundJSONResponse }

func (response GetArtifactStatsForSpace404JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetArtifactStatsForSpace500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetArtifactStatsForSpace500JSONResponse) VisitGetArtifactStatsForSpaceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifactsRequestObject struct {
	SpaceRef SpaceRefPathParam `json:"space_ref"`
	Params   GetAllArtifactsParams
}

type GetAllArtifactsResponseObject interface {
	VisitGetAllArtifactsResponse(w http.ResponseWriter) error
}

type GetAllArtifacts200JSONResponse struct {
	ListArtifactResponseJSONResponse
}

func (response GetAllArtifacts200JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifacts400JSONResponse struct{ BadRequestJSONResponse }

func (response GetAllArtifacts400JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifacts401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetAllArtifacts401JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifacts403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetAllArtifacts403JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifacts404JSONResponse struct{ NotFoundJSONResponse }

func (response GetAllArtifacts404JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetAllArtifacts500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetAllArtifacts500JSONResponse) VisitGetAllArtifactsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistriesRequestObject struct {
	SpaceRef SpaceRefPathParam `json:"space_ref"`
	Params   GetAllRegistriesParams
}

type GetAllRegistriesResponseObject interface {
	VisitGetAllRegistriesResponse(w http.ResponseWriter) error
}

type GetAllRegistries200JSONResponse struct {
	ListRegistryResponseJSONResponse
}

func (response GetAllRegistries200JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistries400JSONResponse struct{ BadRequestJSONResponse }

func (response GetAllRegistries400JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistries401JSONResponse struct{ UnauthenticatedJSONResponse }

func (response GetAllRegistries401JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistries403JSONResponse struct{ UnauthorizedJSONResponse }

func (response GetAllRegistries403JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistries404JSONResponse struct{ NotFoundJSONResponse }

func (response GetAllRegistries404JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetAllRegistries500JSONResponse struct {
	InternalServerErrorJSONResponse
}

func (response GetAllRegistries500JSONResponse) VisitGetAllRegistriesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// Create Registry.
	// (POST /registry)
	CreateRegistry(ctx context.Context, request CreateRegistryRequestObject) (CreateRegistryResponseObject, error)
	// Delete a Registry
	// (DELETE /registry/{registry_ref})
	DeleteRegistry(ctx context.Context, request DeleteRegistryRequestObject) (DeleteRegistryResponseObject, error)
	// Returns Registry Details
	// (GET /registry/{registry_ref})
	GetRegistry(ctx context.Context, request GetRegistryRequestObject) (GetRegistryResponseObject, error)
	// Updates a Registry
	// (PUT /registry/{registry_ref})
	ModifyRegistry(ctx context.Context, request ModifyRegistryRequestObject) (ModifyRegistryResponseObject, error)
	// List Artifact Labels
	// (GET /registry/{registry_ref}/artifact/labels)
	ListArtifactLabels(ctx context.Context, request ListArtifactLabelsRequestObject) (ListArtifactLabelsResponseObject, error)
	// Get Artifact Stats
	// (GET /registry/{registry_ref}/artifact/stats)
	GetArtifactStatsForRegistry(ctx context.Context, request GetArtifactStatsForRegistryRequestObject) (GetArtifactStatsForRegistryResponseObject, error)
	// Delete Artifact
	// (DELETE /registry/{registry_ref}/artifact/{artifact})
	DeleteArtifact(ctx context.Context, request DeleteArtifactRequestObject) (DeleteArtifactResponseObject, error)
	// Update Artifact Labels
	// (PUT /registry/{registry_ref}/artifact/{artifact}/labels)
	UpdateArtifactLabels(ctx context.Context, request UpdateArtifactLabelsRequestObject) (UpdateArtifactLabelsResponseObject, error)
	// Get Artifact Stats
	// (GET /registry/{registry_ref}/artifact/{artifact}/stats)
	GetArtifactStats(ctx context.Context, request GetArtifactStatsRequestObject) (GetArtifactStatsResponseObject, error)
	// Get Artifact Summary
	// (GET /registry/{registry_ref}/artifact/{artifact}/summary)
	GetArtifactSummary(ctx context.Context, request GetArtifactSummaryRequestObject) (GetArtifactSummaryResponseObject, error)
	// Delete an Artifact Version
	// (DELETE /registry/{registry_ref}/artifact/{artifact}/version/{version})
	DeleteArtifactVersion(ctx context.Context, request DeleteArtifactVersionRequestObject) (DeleteArtifactVersionResponseObject, error)
	// Describe Artifact Details
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/details)
	GetArtifactDetails(ctx context.Context, request GetArtifactDetailsRequestObject) (GetArtifactDetailsResponseObject, error)
	// Describe Docker Artifact Detail
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/details)
	GetDockerArtifactDetails(ctx context.Context, request GetDockerArtifactDetailsRequestObject) (GetDockerArtifactDetailsResponseObject, error)
	// Describe Docker Artifact Layers
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/layers)
	GetDockerArtifactLayers(ctx context.Context, request GetDockerArtifactLayersRequestObject) (GetDockerArtifactLayersResponseObject, error)
	// Describe Docker Artifact Manifest
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifest)
	GetDockerArtifactManifest(ctx context.Context, request GetDockerArtifactManifestRequestObject) (GetDockerArtifactManifestResponseObject, error)
	// Describe Docker Artifact Manifests
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/docker/manifests)
	GetDockerArtifactManifests(ctx context.Context, request GetDockerArtifactManifestsRequestObject) (GetDockerArtifactManifestsResponseObject, error)
	// Describe Artifact files
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/files)
	GetArtifactFiles(ctx context.Context, request GetArtifactFilesRequestObject) (GetArtifactFilesResponseObject, error)
	// Describe Helm Artifact Detail
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/details)
	GetHelmArtifactDetails(ctx context.Context, request GetHelmArtifactDetailsRequestObject) (GetHelmArtifactDetailsResponseObject, error)
	// Describe Helm Artifact Manifest
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/helm/manifest)
	GetHelmArtifactManifest(ctx context.Context, request GetHelmArtifactManifestRequestObject) (GetHelmArtifactManifestResponseObject, error)
	// Get Artifact Version Summary
	// (GET /registry/{registry_ref}/artifact/{artifact}/version/{version}/summary)
	GetArtifactVersionSummary(ctx context.Context, request GetArtifactVersionSummaryRequestObject) (GetArtifactVersionSummaryResponseObject, error)
	// List Artifact Versions
	// (GET /registry/{registry_ref}/artifact/{artifact}/versions)
	GetAllArtifactVersions(ctx context.Context, request GetAllArtifactVersionsRequestObject) (GetAllArtifactVersionsResponseObject, error)
	// List Artifacts for Registry
	// (GET /registry/{registry_ref}/artifacts)
	GetAllArtifactsByRegistry(ctx context.Context, request GetAllArtifactsByRegistryRequestObject) (GetAllArtifactsByRegistryResponseObject, error)
	// Returns CLI Client Setup Details
	// (GET /registry/{registry_ref}/client-setup-details)
	GetClientSetupDetails(ctx context.Context, request GetClientSetupDetailsRequestObject) (GetClientSetupDetailsResponseObject, error)
	// ListWebhooks
	// (GET /registry/{registry_ref}/webhooks)
	ListWebhooks(ctx context.Context, request ListWebhooksRequestObject) (ListWebhooksResponseObject, error)
	// CreateWebhook
	// (POST /registry/{registry_ref}/webhooks)
	CreateWebhook(ctx context.Context, request CreateWebhookRequestObject) (CreateWebhookResponseObject, error)
	// DeleteWebhook
	// (DELETE /registry/{registry_ref}/webhooks/{webhook_identifier})
	DeleteWebhook(ctx context.Context, request DeleteWebhookRequestObject) (DeleteWebhookResponseObject, error)
	// GetWebhook
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier})
	GetWebhook(ctx context.Context, request GetWebhookRequestObject) (GetWebhookResponseObject, error)
	// UpdateWebhook
	// (PUT /registry/{registry_ref}/webhooks/{webhook_identifier})
	UpdateWebhook(ctx context.Context, request UpdateWebhookRequestObject) (UpdateWebhookResponseObject, error)
	// ListWebhookExecutions
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions)
	ListWebhookExecutions(ctx context.Context, request ListWebhookExecutionsRequestObject) (ListWebhookExecutionsResponseObject, error)
	// GetWebhookExecution
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id})
	GetWebhookExecution(ctx context.Context, request GetWebhookExecutionRequestObject) (GetWebhookExecutionResponseObject, error)
	// ReTriggerWebhookExecution
	// (GET /registry/{registry_ref}/webhooks/{webhook_identifier}/executions/{webhook_execution_id}/retrigger)
	ReTriggerWebhookExecution(ctx context.Context, request ReTriggerWebhookExecutionRequestObject) (ReTriggerWebhookExecutionResponseObject, error)
	// List replication rules
	// (GET /replication/rules)
	ListReplicationRules(ctx context.Context, request ListReplicationRulesRequestObject) (ListReplicationRulesResponseObject, error)
	// Create a replication rule
	// (POST /replication/rules)
	CreateReplicationRule(ctx context.Context, request CreateReplicationRuleRequestObject) (CreateReplicationRuleResponseObject, error)
	// Delete a replication rule
	// (DELETE /replication/rules/{id})
	DeleteReplicationRule(ctx context.Context, request DeleteReplicationRuleRequestObject) (DeleteReplicationRuleResponseObject, error)
	// Get a replication rule
	// (GET /replication/rules/{id})
	GetReplicationRule(ctx context.Context, request GetReplicationRuleRequestObject) (GetReplicationRuleResponseObject, error)
	// Update a replication rule
	// (PUT /replication/rules/{id})
	UpdateReplicationRule(ctx context.Context, request UpdateReplicationRuleRequestObject) (UpdateReplicationRuleResponseObject, error)
	// List migration images
	// (GET /replication/rules/{id}/migration/images)
	ListMigrationImages(ctx context.Context, request ListMigrationImagesRequestObject) (ListMigrationImagesResponseObject, error)
	// Get migration logs for an image
	// (GET /replication/rules/{id}/migration/images/{image_id}/logs)
	GetMigrationLogsForImage(ctx context.Context, request GetMigrationLogsForImageRequestObject) (GetMigrationLogsForImageResponseObject, error)
	// Start migration
	// (POST /replication/rules/{id}/migration/start)
	StartMigration(ctx context.Context, request StartMigrationRequestObject) (StartMigrationResponseObject, error)
	// Stop migration
	// (POST /replication/rules/{id}/migration/stop)
	StopMigration(ctx context.Context, request StopMigrationRequestObject) (StopMigrationResponseObject, error)
	// Get artifact stats
	// (GET /spaces/{space_ref}/artifact/stats)
	GetArtifactStatsForSpace(ctx context.Context, request GetArtifactStatsForSpaceRequestObject) (GetArtifactStatsForSpaceResponseObject, error)
	// List artifacts
	// (GET /spaces/{space_ref}/artifacts)
	GetAllArtifacts(ctx context.Context, request GetAllArtifactsRequestObject) (GetAllArtifactsResponseObject, error)
	// List registries
	// (GET /spaces/{space_ref}/registries)
	GetAllRegistries(ctx context.Context, request GetAllRegistriesRequestObject) (GetAllRegistriesResponseObject, error)
}

type StrictHandlerFunc = strictnethttp.StrictHTTPHandlerFunc
type StrictMiddlewareFunc = strictnethttp.StrictHTTPMiddlewareFunc

type StrictHTTPServerOptions struct {
	RequestErrorHandlerFunc  func(w http.ResponseWriter, r *http.Request, err error)
	ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
		RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		},
		ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		},
	}}
}

func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
	options     StrictHTTPServerOptions
}

// CreateRegistry operation middleware
func (sh *strictHandler) CreateRegistry(w http.ResponseWriter, r *http.Request, params CreateRegistryParams) {
	var request CreateRegistryRequestObject

	request.Params = params

	var body CreateRegistryJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.CreateRegistry(ctx, request.(CreateRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(CreateRegistryResponseObject); ok {
		if err := validResponse.VisitCreateRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteRegistry operation middleware
func (sh *strictHandler) DeleteRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	var request DeleteRegistryRequestObject

	request.RegistryRef = registryRef

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteRegistry(ctx, request.(DeleteRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteRegistryResponseObject); ok {
		if err := validResponse.VisitDeleteRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetRegistry operation middleware
func (sh *strictHandler) GetRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	var request GetRegistryRequestObject

	request.RegistryRef = registryRef

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetRegistry(ctx, request.(GetRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetRegistryResponseObject); ok {
		if err := validResponse.VisitGetRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ModifyRegistry operation middleware
func (sh *strictHandler) ModifyRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	var request ModifyRegistryRequestObject

	request.RegistryRef = registryRef

	var body ModifyRegistryJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ModifyRegistry(ctx, request.(ModifyRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ModifyRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ModifyRegistryResponseObject); ok {
		if err := validResponse.VisitModifyRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ListArtifactLabels operation middleware
func (sh *strictHandler) ListArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListArtifactLabelsParams) {
	var request ListArtifactLabelsRequestObject

	request.RegistryRef = registryRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ListArtifactLabels(ctx, request.(ListArtifactLabelsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListArtifactLabels")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ListArtifactLabelsResponseObject); ok {
		if err := validResponse.VisitListArtifactLabelsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactStatsForRegistry operation middleware
func (sh *strictHandler) GetArtifactStatsForRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetArtifactStatsForRegistryParams) {
	var request GetArtifactStatsForRegistryRequestObject

	request.RegistryRef = registryRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactStatsForRegistry(ctx, request.(GetArtifactStatsForRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactStatsForRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactStatsForRegistryResponseObject); ok {
		if err := validResponse.VisitGetArtifactStatsForRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteArtifact operation middleware
func (sh *strictHandler) DeleteArtifact(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	var request DeleteArtifactRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteArtifact(ctx, request.(DeleteArtifactRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteArtifact")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteArtifactResponseObject); ok {
		if err := validResponse.VisitDeleteArtifactResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// UpdateArtifactLabels operation middleware
func (sh *strictHandler) UpdateArtifactLabels(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	var request UpdateArtifactLabelsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact

	var body UpdateArtifactLabelsJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateArtifactLabels(ctx, request.(UpdateArtifactLabelsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateArtifactLabels")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UpdateArtifactLabelsResponseObject); ok {
		if err := validResponse.VisitUpdateArtifactLabelsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactStats operation middleware
func (sh *strictHandler) GetArtifactStats(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetArtifactStatsParams) {
	var request GetArtifactStatsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactStats(ctx, request.(GetArtifactStatsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactStats")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactStatsResponseObject); ok {
		if err := validResponse.VisitGetArtifactStatsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactSummary operation middleware
func (sh *strictHandler) GetArtifactSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam) {
	var request GetArtifactSummaryRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactSummary(ctx, request.(GetArtifactSummaryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactSummary")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactSummaryResponseObject); ok {
		if err := validResponse.VisitGetArtifactSummaryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteArtifactVersion operation middleware
func (sh *strictHandler) DeleteArtifactVersion(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	var request DeleteArtifactVersionRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteArtifactVersion(ctx, request.(DeleteArtifactVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteArtifactVersion")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteArtifactVersionResponseObject); ok {
		if err := validResponse.VisitDeleteArtifactVersionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactDetails operation middleware
func (sh *strictHandler) GetArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactDetailsParams) {
	var request GetArtifactDetailsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactDetails(ctx, request.(GetArtifactDetailsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactDetails")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactDetailsResponseObject); ok {
		if err := validResponse.VisitGetArtifactDetailsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetDockerArtifactDetails operation middleware
func (sh *strictHandler) GetDockerArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactDetailsParams) {
	var request GetDockerArtifactDetailsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDockerArtifactDetails(ctx, request.(GetDockerArtifactDetailsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDockerArtifactDetails")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDockerArtifactDetailsResponseObject); ok {
		if err := validResponse.VisitGetDockerArtifactDetailsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetDockerArtifactLayers operation middleware
func (sh *strictHandler) GetDockerArtifactLayers(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactLayersParams) {
	var request GetDockerArtifactLayersRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDockerArtifactLayers(ctx, request.(GetDockerArtifactLayersRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDockerArtifactLayers")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDockerArtifactLayersResponseObject); ok {
		if err := validResponse.VisitGetDockerArtifactLayersResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetDockerArtifactManifest operation middleware
func (sh *strictHandler) GetDockerArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetDockerArtifactManifestParams) {
	var request GetDockerArtifactManifestRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDockerArtifactManifest(ctx, request.(GetDockerArtifactManifestRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDockerArtifactManifest")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDockerArtifactManifestResponseObject); ok {
		if err := validResponse.VisitGetDockerArtifactManifestResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetDockerArtifactManifests operation middleware
func (sh *strictHandler) GetDockerArtifactManifests(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	var request GetDockerArtifactManifestsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDockerArtifactManifests(ctx, request.(GetDockerArtifactManifestsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDockerArtifactManifests")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDockerArtifactManifestsResponseObject); ok {
		if err := validResponse.VisitGetDockerArtifactManifestsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactFiles operation middleware
func (sh *strictHandler) GetArtifactFiles(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam, params GetArtifactFilesParams) {
	var request GetArtifactFilesRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactFiles(ctx, request.(GetArtifactFilesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactFiles")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactFilesResponseObject); ok {
		if err := validResponse.VisitGetArtifactFilesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetHelmArtifactDetails operation middleware
func (sh *strictHandler) GetHelmArtifactDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	var request GetHelmArtifactDetailsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetHelmArtifactDetails(ctx, request.(GetHelmArtifactDetailsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetHelmArtifactDetails")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetHelmArtifactDetailsResponseObject); ok {
		if err := validResponse.VisitGetHelmArtifactDetailsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetHelmArtifactManifest operation middleware
func (sh *strictHandler) GetHelmArtifactManifest(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	var request GetHelmArtifactManifestRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetHelmArtifactManifest(ctx, request.(GetHelmArtifactManifestRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetHelmArtifactManifest")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetHelmArtifactManifestResponseObject); ok {
		if err := validResponse.VisitGetHelmArtifactManifestResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactVersionSummary operation middleware
func (sh *strictHandler) GetArtifactVersionSummary(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, version VersionPathParam) {
	var request GetArtifactVersionSummaryRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Version = version

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactVersionSummary(ctx, request.(GetArtifactVersionSummaryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactVersionSummary")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactVersionSummaryResponseObject); ok {
		if err := validResponse.VisitGetArtifactVersionSummaryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAllArtifactVersions operation middleware
func (sh *strictHandler) GetAllArtifactVersions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, artifact ArtifactPathParam, params GetAllArtifactVersionsParams) {
	var request GetAllArtifactVersionsRequestObject

	request.RegistryRef = registryRef
	request.Artifact = artifact
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAllArtifactVersions(ctx, request.(GetAllArtifactVersionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAllArtifactVersions")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAllArtifactVersionsResponseObject); ok {
		if err := validResponse.VisitGetAllArtifactVersionsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAllArtifactsByRegistry operation middleware
func (sh *strictHandler) GetAllArtifactsByRegistry(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetAllArtifactsByRegistryParams) {
	var request GetAllArtifactsByRegistryRequestObject

	request.RegistryRef = registryRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAllArtifactsByRegistry(ctx, request.(GetAllArtifactsByRegistryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAllArtifactsByRegistry")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAllArtifactsByRegistryResponseObject); ok {
		if err := validResponse.VisitGetAllArtifactsByRegistryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetClientSetupDetails operation middleware
func (sh *strictHandler) GetClientSetupDetails(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params GetClientSetupDetailsParams) {
	var request GetClientSetupDetailsRequestObject

	request.RegistryRef = registryRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetClientSetupDetails(ctx, request.(GetClientSetupDetailsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetClientSetupDetails")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetClientSetupDetailsResponseObject); ok {
		if err := validResponse.VisitGetClientSetupDetailsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ListWebhooks operation middleware
func (sh *strictHandler) ListWebhooks(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, params ListWebhooksParams) {
	var request ListWebhooksRequestObject

	request.RegistryRef = registryRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ListWebhooks(ctx, request.(ListWebhooksRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListWebhooks")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ListWebhooksResponseObject); ok {
		if err := validResponse.VisitListWebhooksResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// CreateWebhook operation middleware
func (sh *strictHandler) CreateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam) {
	var request CreateWebhookRequestObject

	request.RegistryRef = registryRef

	var body CreateWebhookJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.CreateWebhook(ctx, request.(CreateWebhookRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateWebhook")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(CreateWebhookResponseObject); ok {
		if err := validResponse.VisitCreateWebhookResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteWebhook operation middleware
func (sh *strictHandler) DeleteWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	var request DeleteWebhookRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteWebhook(ctx, request.(DeleteWebhookRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteWebhook")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteWebhookResponseObject); ok {
		if err := validResponse.VisitDeleteWebhookResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetWebhook operation middleware
func (sh *strictHandler) GetWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	var request GetWebhookRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetWebhook(ctx, request.(GetWebhookRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetWebhook")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetWebhookResponseObject); ok {
		if err := validResponse.VisitGetWebhookResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// UpdateWebhook operation middleware
func (sh *strictHandler) UpdateWebhook(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam) {
	var request UpdateWebhookRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier

	var body UpdateWebhookJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateWebhook(ctx, request.(UpdateWebhookRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateWebhook")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UpdateWebhookResponseObject); ok {
		if err := validResponse.VisitUpdateWebhookResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ListWebhookExecutions operation middleware
func (sh *strictHandler) ListWebhookExecutions(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, params ListWebhookExecutionsParams) {
	var request ListWebhookExecutionsRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ListWebhookExecutions(ctx, request.(ListWebhookExecutionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListWebhookExecutions")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ListWebhookExecutionsResponseObject); ok {
		if err := validResponse.VisitListWebhookExecutionsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetWebhookExecution operation middleware
func (sh *strictHandler) GetWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam) {
	var request GetWebhookExecutionRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier
	request.WebhookExecutionId = webhookExecutionId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetWebhookExecution(ctx, request.(GetWebhookExecutionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetWebhookExecution")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetWebhookExecutionResponseObject); ok {
		if err := validResponse.VisitGetWebhookExecutionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ReTriggerWebhookExecution operation middleware
func (sh *strictHandler) ReTriggerWebhookExecution(w http.ResponseWriter, r *http.Request, registryRef RegistryRefPathParam, webhookIdentifier WebhookIdentifierPathParam, webhookExecutionId WebhookExecutionIdPathParam) {
	var request ReTriggerWebhookExecutionRequestObject

	request.RegistryRef = registryRef
	request.WebhookIdentifier = webhookIdentifier
	request.WebhookExecutionId = webhookExecutionId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ReTriggerWebhookExecution(ctx, request.(ReTriggerWebhookExecutionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ReTriggerWebhookExecution")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ReTriggerWebhookExecutionResponseObject); ok {
		if err := validResponse.VisitReTriggerWebhookExecutionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ListReplicationRules operation middleware
func (sh *strictHandler) ListReplicationRules(w http.ResponseWriter, r *http.Request, params ListReplicationRulesParams) {
	var request ListReplicationRulesRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ListReplicationRules(ctx, request.(ListReplicationRulesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListReplicationRules")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ListReplicationRulesResponseObject); ok {
		if err := validResponse.VisitListReplicationRulesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// CreateReplicationRule operation middleware
func (sh *strictHandler) CreateReplicationRule(w http.ResponseWriter, r *http.Request, params CreateReplicationRuleParams) {
	var request CreateReplicationRuleRequestObject

	request.Params = params

	var body CreateReplicationRuleJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.CreateReplicationRule(ctx, request.(CreateReplicationRuleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateReplicationRule")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(CreateReplicationRuleResponseObject); ok {
		if err := validResponse.VisitCreateReplicationRuleResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteReplicationRule operation middleware
func (sh *strictHandler) DeleteReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	var request DeleteReplicationRuleRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteReplicationRule(ctx, request.(DeleteReplicationRuleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteReplicationRule")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteReplicationRuleResponseObject); ok {
		if err := validResponse.VisitDeleteReplicationRuleResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetReplicationRule operation middleware
func (sh *strictHandler) GetReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	var request GetReplicationRuleRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetReplicationRule(ctx, request.(GetReplicationRuleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetReplicationRule")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetReplicationRuleResponseObject); ok {
		if err := validResponse.VisitGetReplicationRuleResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// UpdateReplicationRule operation middleware
func (sh *strictHandler) UpdateReplicationRule(w http.ResponseWriter, r *http.Request, id string) {
	var request UpdateReplicationRuleRequestObject

	request.Id = id

	var body UpdateReplicationRuleJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateReplicationRule(ctx, request.(UpdateReplicationRuleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateReplicationRule")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UpdateReplicationRuleResponseObject); ok {
		if err := validResponse.VisitUpdateReplicationRuleResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// ListMigrationImages operation middleware
func (sh *strictHandler) ListMigrationImages(w http.ResponseWriter, r *http.Request, id string, params ListMigrationImagesParams) {
	var request ListMigrationImagesRequestObject

	request.Id = id
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.ListMigrationImages(ctx, request.(ListMigrationImagesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListMigrationImages")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(ListMigrationImagesResponseObject); ok {
		if err := validResponse.VisitListMigrationImagesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetMigrationLogsForImage operation middleware
func (sh *strictHandler) GetMigrationLogsForImage(w http.ResponseWriter, r *http.Request, id string, imageId string) {
	var request GetMigrationLogsForImageRequestObject

	request.Id = id
	request.ImageId = imageId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetMigrationLogsForImage(ctx, request.(GetMigrationLogsForImageRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetMigrationLogsForImage")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetMigrationLogsForImageResponseObject); ok {
		if err := validResponse.VisitGetMigrationLogsForImageResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// StartMigration operation middleware
func (sh *strictHandler) StartMigration(w http.ResponseWriter, r *http.Request, id string) {
	var request StartMigrationRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.StartMigration(ctx, request.(StartMigrationRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "StartMigration")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(StartMigrationResponseObject); ok {
		if err := validResponse.VisitStartMigrationResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// StopMigration operation middleware
func (sh *strictHandler) StopMigration(w http.ResponseWriter, r *http.Request, id string) {
	var request StopMigrationRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.StopMigration(ctx, request.(StopMigrationRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "StopMigration")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(StopMigrationResponseObject); ok {
		if err := validResponse.VisitStopMigrationResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetArtifactStatsForSpace operation middleware
func (sh *strictHandler) GetArtifactStatsForSpace(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetArtifactStatsForSpaceParams) {
	var request GetArtifactStatsForSpaceRequestObject

	request.SpaceRef = spaceRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetArtifactStatsForSpace(ctx, request.(GetArtifactStatsForSpaceRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetArtifactStatsForSpace")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetArtifactStatsForSpaceResponseObject); ok {
		if err := validResponse.VisitGetArtifactStatsForSpaceResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAllArtifacts operation middleware
func (sh *strictHandler) GetAllArtifacts(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllArtifactsParams) {
	var request GetAllArtifactsRequestObject

	request.SpaceRef = spaceRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAllArtifacts(ctx, request.(GetAllArtifactsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAllArtifacts")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAllArtifactsResponseObject); ok {
		if err := validResponse.VisitGetAllArtifactsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAllRegistries operation middleware
func (sh *strictHandler) GetAllRegistries(w http.ResponseWriter, r *http.Request, spaceRef SpaceRefPathParam, params GetAllRegistriesParams) {
	var request GetAllRegistriesRequestObject

	request.SpaceRef = spaceRef
	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAllRegistries(ctx, request.(GetAllRegistriesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAllRegistries")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAllRegistriesResponseObject); ok {
		if err := validResponse.VisitGetAllRegistriesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

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

	"H4sIAAAAAAAC/+x9bXPbOJL/V8Gf/9uq3VrG8szmrq58dS8cx0586zhaWcnW1FzKA5OQhA1FcgDQtibl",
	"735FPJAgCZCgJEtywldxRDw0Gr9udAPoxjcvSJZpEqOYUe/km5dCApeIIcL/dwXvUETH+W/5f0NEA4JT",
	"hpPYOxEfjzzfw/n/fs8QWXm+F8Ml8k68KP/o+R4NFmgJ88qYoSVvlK3SvARlBMdz78lXP0BC4Mp7evK9",
	"CZpjysjqMkQxwzOMiIUEVRCUJS30EDS/xXqhjQibrlLURVJexkIME59KElCcLb2TX73Pl5Ppp9Mrz/c+",
	"jW+mk/PTD94Xv07Xk+9BwvAMBsxCwyn/zCy9q8oVCtr6YAtLP9dwiUAyA6poAYYUsoWxQ4J+zzBBoXfC",
	"SIbaCQgWOAo/I0JxElsIOMuLgHtRBuA4gJQT9DYJviJS0EVtKNW76GBHiOeI2hj+ln+09SKq9hz9jCTL",
	"t5DZYJZ/OgIXCVlCBl6BDx9Gb9+Ofvnll18sNOTNdYwwggxRprhhEPf8M5DfwQWOGCJ28c8L397bWXuX",
	"JBGCMe85hcFXOEcuUjUWRdukS7Z225CyHoKewjm6zpZ3iBhAlxGCYgbyMiAWhWyUzKsUhGgGs4h5Jz/5",
	"3ozPnXfi4Zj9x2uvIALHDM0RKci4wX8gg+jxfnOs81GBFBEguzNRQvNGjJT8fOxGCkFBRii+t83QPxeI",
	"LRABLAERpgwQMWMYUVBUjVZHVvUsi5iJnMGIIt8EHdnNaoJmLYrqU4x/zxDI1RIoVwEwSwhgCwRmOIaR",
	"ongFcMx/vSMwDhZHYLpA4B5GGQIBjMEdAilJ7nGIQoAwHzKkAIJZFkUr8Gly9QrFQZJ/5b39GR3Nj3zw",
	"W0LmMMZ/wJygP/18kZLkXyhgf/r5QvX6219AIptKI4hjUR3FIY7n4AGzBYCAEYij/P9plFFA8TwGf/7t",
	"r7/9Ja9GUb50s4QYuxzJDkequ9Fff/vL0f/GZoWtCt0SNOuptiiCJFhMETHMgvgG8o82HIgityyv39FR",
	"QtgFRlFo6Kf4ZOkkIex2Jgt09fGRhCYlUH5q6SORBVr7SGGAtoBe3s4OobsjvLbBlA95HYxKlv8jn7KB",
	"5x08rwNbY3obk1myReuFJR293beaiaWFZ2r83sn+K3rotIZPpdWpTCWLVVx22we7D+hukSRfzx9RkOX9",
	"XobdikPWAUhV0hBtIU5WuS2q3OJwPUp1H86VUGfyKh6dO3FPojCi7E0SYsRtQjVr3KudiK/570ESMxTz",
	"P2GaRjgQsvIvKmzkspN/y2XixPv/o9KhHomvdGRsnNNR5YOkKjeisjSEDBUuDOAONfU0J3TbRNbbbaEv",
	"V4MBQZzAOFS0KrNBEFmQMckitH1ajc2vQXLRDiBZhHLS/ynAtW2Sa832JlViXlq9NE1iWkXuW8Qgjiby",
	"Uy+6U5KkiDApCiFkzogWneZsowyyjHbVuxGllAgKef1VVfZF3+WeR3KXr0hmZolx5rIyR6wUlJBTxCWl",
	"JnY7ZcxNtlxCIQuHwhmuQoD6rDMo75vumkF5n4fEnrwpamaPmMsBQbQkSVEpjZz9sKja+QFwKqxuPBZb",
	"kxrj3sBw20vLOSEJMZH3BoaAqAXH984ijGJ2g1iWCr29K5lvdrzPueLrK6cI0JwkfckQO8d7WVJNXR8g",
	"pMOCsCrBH2CMZ4iyvXBLdX6A/FpqpAmir+AKEbpTPokuD9ImyQkreaMmcrfsKXo9TNZc4AhtTRXNcCTZ",
	"Uz0zFNv2yQy8hyRGlJb7GBe8hl+en7TxpaS1ebAimjhLMkF1lYDpImcBg5E8UynONjzfQ49wmUbI7dxE",
	"HJv06CUvXu3l+Ni5n8s4RI/mfgLtoEhv3r1x89lP3nZsP//RmdVsdovo9iWWNkK5aOLJ996jaLmXdbfZ",
	"8QFogQWKlqY1Vyd2xyuuqeuD45S+2l7GDJEYRjeI3CMijORnN7lVp4DyXgESBX3vClO2jw2JRr/7Nr35",
	"OmPY19QJ3QNvDootdX5IR3cPbFFnJ4fAHelNU/3OkeLUBzwnnAOXSzhHO2RUteM98GnS4NNSkQTwkts2",
	"kkdqh38PUlbv+iClrTwB2TlfDoIf+gGOIK52yrJDtlR6Pgipqp8VFWIlT3ZocSi7Q0Y1+t6HC8vZI8+n",
	"aHnMXN1M16ndA4MOQsAeNGKuE3aRZHH4/CZp7i/SFAV4hlGYz0mSkQCBB0hBnDAw41Q8+d44gjieokfb",
	"usDQIxvxiyf/BYIFJBSx/87Y7NV/Vmks/M/cWYkSHzwkJAr/n+ebzuHrmxDiXkveUwU8O9bMh6KVxSmw",
	"Lzxmx4P2HTHooPRzXTVLRuVk3WRBgCjdgB/bGJjLiCSlYKLh/lMMM7ZAMcuJRTvQFfUOCxoSgv/YHQGy",
	"t/I2xq7X1nq3e0B489qWrhGL6yS7ZMeB6kP9aowkgF+M4fL0d7S6QQFB7O9o1Rw8VGWMcQGw2oIWZeRQ",
	"+iaFAbrkIuOw3WuqPIZsYeyJqgF1UFSU60dLtZqFivrMGkj68uR7p3ESr5YJR4x2bUButFpClwIGZAHf",
	"C3H+fYljyMT+3RKmaU7ByTfv7cezv59P+hyoniXxDM8933t3fn0+uTyz1X2HYkRwYKn8/vzqg/t2clHt",
	"w+nn82tbvQ/wHsWWitdja3fXqa238S/T9x+t3Y1XbJGY+3vylZCsrishNTzo5sn3khh9nHknv/Y/zy56",
	"6Lsl71ixbdq66tonoKtmKy/bq9qm7+mLX9NUQveFp8wo6fLrG7MeC5OHOEpgWByKOSiBZRJyh8HSobiJ",
	"a/igY6VjkRhXYUXlaVejyfsyJq1dCfHtLo5Zv3K/WpjLY3GHOCO5WtHJbK5DvvU+cHVS5O51v+AynWLZ",
	"QBsFHxCDao22KMuiSB00auJpn5nvP6i8DmUfJGJ2hZc0i6KzZLmEsblL0ggjbi1mXW2d4RcL5Bn6rUdX",
	"1nptm35xT7Ix941TelHOBoA+86/qqNNnhyr8SP2GJUQ7tHaolqW9+nlqY5O82+LAKFmyn4JdS5JKfWRq",
	"ch0569DK6wpTix51VZQS2g7aSoUQ27UWD5guGG1HaK/JmOEI9VOD369Ksyy1u9BntTu7zdgwcX+ugRab",
	"2LbL2PpTsaHR0Sk2GVsoqmpyUm7A5OOWYewqRcQnisgYUvqQkNDzTT6u7nM1s0f43lmEYJyl4yTCgYH/",
	"8jMQ37nb3VChkyK4uzEd6DHFBL2FK2oW3S6hGRM0w4/9lKKKzetd1bSgGO4qG3jEbw/zQkCVqnNiCXH8",
	"HsHQ7pu3fxWnOfpoHK9Y34i6nbanRqBOjtb5l3b+qI7a+aNKtbvyl9dXl9fnLqNjKC183OnpmxtbnSm8",
	"q1doerasl0trJqPLxzMR0nDvFusihTmoNjkFxrWe2TRUbbBds5wXaZhUYilbD8WcW2IpNMj8YjOO1Doq",
	"ONPFBW1x7mAGUEV9k89odjRglFmW5W66OK7WmCPKULr2BPVWqQWzLZRWCtXXvtzFwYHne3ybBzI0Tb6i",
	"2LjIGYMpOm2NYtNxz57BM1n57vZlX8NR7Kocyt5Ny85jE3b8d27mmCNdmgt7OxOfOgkqLs924rEo2bQt",
	"yiba2VqUtDOKB4ecx8zJexaRJDZNv4GzoVrooJN2OvqimNVfkNm4zA75Sia+c9KFDe4ZlqmEnpLA4fhE",
	"UmUfvIKC1SZ1nql2ZWbnzlp6zjp+V1gUydMiNRzZZDerWphUFunnTi71pnuApD57didmPUVpYkZx4b0u",
	"qaElpmTBWCruqwNeSAsl8V4fv/YMy2xoQ+NpGOL8TxgpNQrgXZIxnipH3Ik3kLxElMK5hTyCIE1Erp0i",
	"UwLEEQo9v1O18NGo1o3MemQEllZ2LbeZPInnhUDhJlX5+tVyhtxi1Ok0fuWeuyhsIlCLq2rQl3+z2i4L",
	"FHyl2bLnPqObydNmSlgd/V57TzJxXTmKZuc6sSbOtZ0JtpkDc1Gv2x6otOBkDxhCjpqqCkXLTsu0uMHc",
	"cia4TbN1MEw3Mkyt59ptODSFgm3DKDXGc3XA8LkN0v+ZkWSuXy5UNx0by1iuH3guMgsQxQ6purfjUEi7",
	"ImPDUCEgGcGm1TCjiFjUXo0JAi7lGEy8qAQntcTrqjLUqh2oS3XXAN/GsfQQ5ntwYb41tJU46MLZldqb",
	"cg4OFynCm2b0ThCwzgnqgBpH1LRcTTEFCDqomCKAz6qpPqsCPVvrpbnqJ9WDAnv5CqwWhdkCn0ZwpHEH",
	"4HkQ2IwVHYB30MArGaVPjda3PkZfQccGUt2adV5gW87aB7DsO5tKmeV+/Tl10hwKOvZFq4ZcjbIuOB6g",
	"k1EnbVirv6O1uh482IKbZsz1oAP3OfvHRiWYdWQU0yYcTLKoj9ZrhJm2Kr2ey7Ug3AbTInLcQbOXCr2M",
	"8R6Qemir9YPDjJpn0gmtWpBkK0qLdruQpyV1WA+DWi4Gw0VNl8Y7G+3DmUo07bCMH/Qyrk2yEaZJACOn",
	"jXqnK+tm47USS2ogwh6x13aessxrdR+oqAKWI4E5SbL00vWspbk9YdhzsPTEv03h3HyGQZI5kfkN2pI9",
	"OtBoC0Vs42WcOhxNLbWQEFjcCxhrZcSDHfVYcAON4+oBYz1UfIYIBSwB8hxOuzooI4VVDG4RHVsGAsuo",
	"Xt+7/vTufCqDbk1XC1uiPdtYlfJqO+WWfb/B5pE2r0vBKEoeUDiGjCES99tqv4uS4OuadYN6lILj9VS9",
	"lqnZYqJc3M/y2njHWXrrDQDfw+3hOgcUCGY7Lzffzqi8vyMv67qdhFsd/Bcd5Np4QnMXMWPbiQl7ztCv",
	"mjg1pvgmu5OKUqapCrjG/IwJy2AEEgI+pZQRBJe6nmqLJimez7WwULVXBJKol3ct5SUpWwojqbfWXrpG",
	"azN0xCXeQX+52D0EpLHr6L6Q2MW12CDqFZPcoWHXu4S/fbXcqSI2uCJlu/qk5O/GdgWqP0AclwGp8vUx",
	"1RaFvJk2ZFkzKwx2x74si00Qmju1k7x856U6g+XgajN0Wf95RbF5rB70PULgvlxMMqlQTWuIRa/3eqC9",
	"mpRPs8HdVgera921UFgvzz19aSYK7JI4uonIbfeyMaIsnyApAq77xVqORK0FhR01oZzZnrx4mHuDZ2Pj",
	"jHbIWac1bhcM3xP5ONccm6i83rDaZFISVWV/pbsmX/0GhprA0JlR4VvXNW77i5KHAuODAOqhgOm58GOC",
	"hh7e3LIuVN78kjHuKsS070Igw9VlBLppIm6Kvbf6AxEhz61JAZ5VglkeIAVU5ACdZXyhihOmR79+Ojs7",
	"v7nxfO/i9PLq0yTv/Xwy+Tgxdq8HnRv2ieGdjAmmppjgxe4TEzQm1RA13zEMEChvruYfwTt3cit8cyOU",
	"4PncFDakWSSySDmZp5Pp5cXp2fT2bHJ+Or3kO5HFb2/Pr875b6aJrbmDli3HTN5xM6bvUE2MSfJoulcE",
	"M+FpuNkrlYwkXTZKmZqks2Qzswm3Y6CWOKW1vipXUYrFfjAPy1tkd57vnWWUJbk1ePpAz4N8lvjBwhmK",
	"GeGKb7waY+NcODlJBcEN1eV7j68qiueVDBYrrct8wnX+NrMTu2QmpWskJKUOeUgzisi1W8CDKplPYXX/",
	"oweC1Y6Qy+W4rAbyDdPCqMNd6w7IBM3lQakqukEGxy3siKAY3kWVTYi7JMndVP6xDHd0V416jKTpALcd",
	"gzimKMgIMhOE5bNJ5q9ix1HPAZ1FrMehs6ywQVbLvYqZXD56LGJyvTHMkkM4nEsePqvfUEY2eSUGtdn/",
	"YpctMVOFWd8lZu+n07GSNaDq1WXuLgnNYbmLEvzuar2d8jITd0/SZcWt0G498lWfzmT8t0tyxaYItRg5",
	"jXzlRtt1cj6dXJ6+uTq/FbZrbs1OT69u7ZZs4/KIuwoG5xotRmXsqmzlauRYHKnQe8M+gmMTpBQEZyVX",
	"PPRMNCy6q8gitzxZX78SJJXVx5nzQGWNXFWY1b8s4GL1aZpP4tFRE7fA37rV8H0twT/q2ldfzRSTKsuX",
	"ZYkzv2CA41miHmSQ9+oFc1uOy16BEN2jKIcXlX2ceAvGUnoyGj08PBwtRNUjnPChYRa1N3g6vtQC1k+8",
	"n46Oj475GWWKYphi78T7G/9JnCxxvo6Ifo0rMa3DZ1xvAlh0dOTxJuX1prAoot8ogQQuEeOzaHEmyyIj",
	"HhE9QbN/ZIisxvnv/MxTKsQ3clE0NVIWwag8TDHoRT7Yn49/sjcky40aDw89+d7r4+Puitoz/7yKQ1+G",
	"t1deH//NtV75ZMq/u9BnehyVv5+h0iupmdbnmcF5PoWe5nZ9ySsVuBl9U3/dEjR7EvCJEDNYRW/57xqQ",
	"ABbJXWAQJFnMuOOX/3+O71EMRH6UKtBEE2sDjRRzO8vVjw61CkwcuKleGXoB6Hh9/Lq7UvE42fbg1Jhv",
	"G558b44MimeCWEZiWsJF5lLqD5t3iB0CZl6iatkXeGyTb8dQmhkw9Im/F0Q3Ujr8dsfqOQC09fVtAOFW",
	"QdhEzxpL4khdfxqVdzOM+u4KU1ZPs9G0tRrJO+iWEOl31kvhHF3zWAPX0vyCkkNZiiAJFlNE1lWt9rfW",
	"B3hb4W0CnAbwMgLYEd9UPVxihPc7xGpvlxyZFurKKygXCdmy3u3G4owky7eQIecKLNGKr4XeypgH5HYj",
	"t4mlTXD7Tf3l4r6o1o8szokW+L4bvCriB49mVx6NNsVbwJxmFrSYsN2GgSi3J9PABsKeFq7xDbanTVTq",
	"YAz0snW3aQ5oEN++ZbBPZA82xGBDtIG9zFfvAHdRuB3wZWL7F2VR1OgfQNkXlMW8bwOW8mBo9E3+0cfY",
	"VW+ydRm9n7XX0A5WOavHwwZ7eVcnAHEDSM+F6ZH2PkG38i33lK26V3vr7SUhurtOsMBR+FlV3FzJC0YN",
	"Ot5FKnJA3iETDp9JKPjdZyfZMD+QZRQR06NL36GgiPdoNhERE6MGQekhKNZX25S41ApsVWrKN6KchaZ4",
	"iKlDZsoHmwaRMYmM4M8gKhuISgGxXYiK/iaIs7BoL4x0iIv+FskgMG1rjOLUIDobiI4Gt10KD11Leqi7",
	"+NAfwj2vvQw4SMIWJOHZ15EZlomFu313UbTFc7+QBb6zpeIZL+EkhH0koVvDeeELjKJwJ9d7yrcQBzle",
	"Z4NBCcvzbC8sULR02lwwvXBolOHms3k/xqLVHPeA9x54t7ygqVBf+bxF6Du5PdZnFVvB/1Jdno3RP3gw",
	"G+Pf4L88gwT0Ou2W5w1Op96y7AEcfu9MAMxDH0Sg57l5DWXbtXva7+9TAKOIx5PUqbHcaYqi0/pLiAeN",
	"9B/S/TC8fjkIZd/4Ag3f64pjX9mjPLpLiyBokz/6ZrXzWANxyXIQvi7hqyePH6Svp/Q1JKF3FJvIpfiK",
	"51J81eXsq+jNs6tLINIByqx9KoT3DlIUgiRWD3eorIwNAdWSCe5vI6CvFbi+Bdgc7gB192BhG9zWwbv+",
	"dFgrxq/kw1kqA5FtW6vywtx3ELJ52CuG4vQPmMajBjSF/OInHixvTPWiIN0FZZEoRMt6uKeA+Fq6prXy",
	"vRRt/KDpXspZNADFRUGOvsm/bsucSW55YMquTXfKtwuvbrVTZA9TgxguiO/ogngrBDuSw3SpqneIvXgg",
	"/bgqqjJ75oUs2wAcIubx4PAxrII7hFgdA9tcBUfVJ3edFFmRwLTwlXN7rs2bOK88+bt3CD+fU7KxM6Dn",
	"k/6BvYIKYJ4J7+X34rdbHD6tLwYtK3sl5+8LwP9DjezLcEsWwo+MbzMcdovuUZHauA3nooQxY3UV4RMk",
	"U9sOOB9wXu512kFhRXvx9tOIZG03bPleJowioFUBoorJAKm90EW3l/l3vUOi2nthw8a50xmRaa7L7fLi",
	"W8u+YZEiut6UNVN09WXC/SWMNr4wt2ZezQF96+WbNsLGDECjNht9k4Zl54ZjJzxVfukOeOK8Vf46r0qi",
	"7+HQ07PKixf7RYZ6Uwb6YUPxmXNOO0PKt19bdAAMzyx9mGgZFNJatwh7QactYZ8DekTJXQFoWBxfYD6+",
	"rSyOoyWeC9iN8BLOuxyAojQQpWVudBgDDrumH/BBVbgUrT8Dgl/iVYe1PZkqPwdpcXRk6rjdhqSMvvF/",
	"+e5OlMx1yWlYAsW0XSVzepEQPnvPJAymRiShz29ajCOI4yl6HO5hOhoVJTJzDPG7mFCidDOQUgYJs7/d",
	"dJN/1npvU+S8bAHhwel5OQirzfKmiErSNkAlqTOeknSA04uEkz7HrWjiG3F09I3/2/s1CFUUUJl9t/Mx",
	"CP5y4NrbhUMK5+/RX6+DSKGVY4V2A9U1qKgs3xFHtBt8qlgO/WzuB7kU3l1aPB+ucs06DZKHoUxXKdr0",
	"GGqIUerptumC5Sq8pAzjcJPesoItDleLDNmJADch5y70vSp9/+JOUJARiu/R5kfIw+N4Pc+ONaFpCi9/",
	"8jlvQIhR/SpMEY0oHj8ewRSP7n/i8yfbqtc5HV/yp+fFY+4+yPguqQ+iBjHSp9CkOgeSubU5YrIJXRfJ",
	"Fsp1vbUBIGMiQTIDIqOfqbFG1jTnNhcoWpparKX0sLdnZNlDGSck2yvujjx9efq/AAAA//8cRKqrLBAB",
	"AA==",
}

// 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
}