registry-backend/drip/api.gen.go

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

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

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/labstack/echo/v4"
	"github.com/oapi-codegen/runtime"
	strictecho "github.com/oapi-codegen/runtime/strictmiddleware/echo"
	openapi_types "github.com/oapi-codegen/runtime/types"
)

const (
	BearerAuthScopes = "BearerAuth.Scopes"
)

// Defines values for NodeStatus.
const (
	NodeStatusActive  NodeStatus = "NodeStatusActive"
	NodeStatusBanned  NodeStatus = "NodeStatusBanned"
	NodeStatusDeleted NodeStatus = "NodeStatusDeleted"
)

// Defines values for NodeVersionStatus.
const (
	NodeVersionStatusActive  NodeVersionStatus = "NodeVersionStatusActive"
	NodeVersionStatusBanned  NodeVersionStatus = "NodeVersionStatusBanned"
	NodeVersionStatusDeleted NodeVersionStatus = "NodeVersionStatusDeleted"
	NodeVersionStatusFlagged NodeVersionStatus = "NodeVersionStatusFlagged"
	NodeVersionStatusPending NodeVersionStatus = "NodeVersionStatusPending"
)

// Defines values for PublisherStatus.
const (
	PublisherStatusActive PublisherStatus = "PublisherStatusActive"
	PublisherStatusBanned PublisherStatus = "PublisherStatusBanned"
)

// Defines values for WorkflowRunStatus.
const (
	WorkflowRunStatusCompleted WorkflowRunStatus = "WorkflowRunStatusCompleted"
	WorkflowRunStatusFailed    WorkflowRunStatus = "WorkflowRunStatusFailed"
	WorkflowRunStatusStarted   WorkflowRunStatus = "WorkflowRunStatusStarted"
)

// ActionJobResult defines model for ActionJobResult.
type ActionJobResult struct {
	// ActionJobId Identifier of the job this result belongs to
	ActionJobId *string `json:"action_job_id,omitempty"`

	// ActionRunId Identifier of the run this result belongs to
	ActionRunId *string `json:"action_run_id,omitempty"`

	// Author The author of the commit
	Author *string `json:"author,omitempty"`

	// AvgVram The average VRAM used by the job
	AvgVram *int `json:"avg_vram,omitempty"`

	// BranchName Name of the relevant git branch
	BranchName *string `json:"branch_name,omitempty"`

	// ComfyRunFlags The comfy run flags. E.g. `--low-vram`
	ComfyRunFlags *string `json:"comfy_run_flags,omitempty"`

	// CommitHash The hash of the commit
	CommitHash *string `json:"commit_hash,omitempty"`

	// CommitId The ID of the commit
	CommitId *string `json:"commit_id,omitempty"`

	// CommitMessage The message of the commit
	CommitMessage *string `json:"commit_message,omitempty"`

	// CommitTime The Unix timestamp when the commit was made
	CommitTime *int64 `json:"commit_time,omitempty"`

	// CudaVersion CUDA version used
	CudaVersion *string `json:"cuda_version,omitempty"`

	// EndTime The end time of the job as a Unix timestamp.
	EndTime *int64 `json:"end_time,omitempty"`

	// GitRepo The repository name
	GitRepo *string `json:"git_repo,omitempty"`

	// Id Unique identifier for the job result
	Id *openapi_types.UUID `json:"id,omitempty"`

	// JobTriggerUser The user who triggered the job.
	JobTriggerUser *string       `json:"job_trigger_user,omitempty"`
	MachineStats   *MachineStats `json:"machine_stats,omitempty"`

	// OperatingSystem Operating system used
	OperatingSystem *string `json:"operating_system,omitempty"`

	// PeakVram The peak VRAM used by the job
	PeakVram *int `json:"peak_vram,omitempty"`

	// PrNumber The pull request number
	PrNumber *string `json:"pr_number,omitempty"`

	// PythonVersion PyTorch version used
	PythonVersion *string `json:"python_version,omitempty"`

	// PytorchVersion PyTorch version used
	PytorchVersion *string `json:"pytorch_version,omitempty"`

	// StartTime The start time of the job as a Unix timestamp.
	StartTime   *int64             `json:"start_time,omitempty"`
	Status      *WorkflowRunStatus `json:"status,omitempty"`
	StorageFile *StorageFile       `json:"storage_file,omitempty"`

	// WorkflowName Name of the workflow
	WorkflowName *string `json:"workflow_name,omitempty"`
}

// ComfyNode defines model for ComfyNode.
type ComfyNode struct {
	// Category UI category where the node is listed, used for grouping nodes.
	Category *string `json:"category,omitempty"`

	// ComfyNodeId Unique identifier for the node
	ComfyNodeId *string `json:"comfy_node_id,omitempty"`

	// Deprecated Indicates if the node is deprecated. Deprecated nodes are hidden in the UI.
	Deprecated *bool `json:"deprecated,omitempty"`

	// Description Brief description of the node's functionality or purpose.
	Description *string `json:"description,omitempty"`

	// Experimental Indicates if the node is experimental, subject to changes or removal.
	Experimental *bool `json:"experimental,omitempty"`

	// Function Name of the entry-point function to execute the node.
	Function *string `json:"function,omitempty"`

	// InputTypes Defines input parameters
	InputTypes *string `json:"input_types,omitempty"`

	// OutputIsList Boolean values indicating if each output is a list.
	OutputIsList *[]bool `json:"output_is_list,omitempty"`

	// ReturnNames Names of the outputs for clarity in workflows.
	ReturnNames *string `json:"return_names,omitempty"`

	// ReturnTypes Specifies the types of outputs produced by the node.
	ReturnTypes *string `json:"return_types,omitempty"`
}

// ComfyNodeCloudBuildInfo defines model for ComfyNodeCloudBuildInfo.
type ComfyNodeCloudBuildInfo struct {
	BuildId       *string `json:"build_id,omitempty"`
	Location      *string `json:"location,omitempty"`
	ProjectId     *string `json:"project_id,omitempty"`
	ProjectNumber *string `json:"project_number,omitempty"`
}

// Error defines model for Error.
type Error struct {
	// Details Optional detailed information about the error or hints for resolving it.
	Details *[]string `json:"details,omitempty"`

	// Message A clear and concise description of the error.
	Message *string `json:"message,omitempty"`
}

// ErrorResponse defines model for ErrorResponse.
type ErrorResponse struct {
	Error   string `json:"error"`
	Message string `json:"message"`
}

// GitCommitSummary defines model for GitCommitSummary.
type GitCommitSummary struct {
	// Author The author of the commit
	Author *string `json:"author,omitempty"`

	// BranchName The branch where the commit was made
	BranchName *string `json:"branch_name,omitempty"`

	// CommitHash The hash of the commit
	CommitHash *string `json:"commit_hash,omitempty"`

	// CommitName The name of the commit
	CommitName *string `json:"commit_name,omitempty"`

	// StatusSummary A map of operating system to status pairs
	StatusSummary *map[string]string `json:"status_summary,omitempty"`

	// Timestamp The timestamp when the commit was made
	Timestamp *time.Time `json:"timestamp,omitempty"`
}

// MachineStats defines model for MachineStats.
type MachineStats struct {
	// CpuCapacity Total CPU on the machine.
	CpuCapacity *string `json:"cpu_capacity,omitempty"`

	// DiskCapacity Total disk capacity on the machine.
	DiskCapacity *string `json:"disk_capacity,omitempty"`

	// GpuType The GPU type. eg. NVIDIA Tesla K80
	GpuType *string `json:"gpu_type,omitempty"`

	// InitialCpu Initial CPU available before the job starts.
	InitialCpu *string `json:"initial_cpu,omitempty"`

	// InitialDisk Initial disk available before the job starts.
	InitialDisk *string `json:"initial_disk,omitempty"`

	// InitialRam Initial RAM available before the job starts.
	InitialRam *string `json:"initial_ram,omitempty"`

	// MachineName Name of the machine.
	MachineName *string `json:"machine_name,omitempty"`

	// MemoryCapacity Total memory on the machine.
	MemoryCapacity *string `json:"memory_capacity,omitempty"`

	// OsVersion The operating system version. eg. Ubuntu Linux 20.04
	OsVersion *string `json:"os_version,omitempty"`

	// PipFreeze The pip freeze output
	PipFreeze *string `json:"pip_freeze,omitempty"`

	// VramTimeSeries Time series of VRAM usage.
	VramTimeSeries *map[string]interface{} `json:"vram_time_series,omitempty"`
}

// Node defines model for Node.
type Node struct {
	Author *string `json:"author,omitempty"`

	// Category The category of the node.
	Category    *string `json:"category,omitempty"`
	Description *string `json:"description,omitempty"`

	// Downloads The number of downloads of the node.
	Downloads *int `json:"downloads,omitempty"`

	// Icon URL to the node's icon.
	Icon *string `json:"icon,omitempty"`

	// Id The unique identifier of the node.
	Id            *string      `json:"id,omitempty"`
	LatestVersion *NodeVersion `json:"latest_version,omitempty"`

	// License The path to the LICENSE file in the node's repository.
	License *string `json:"license,omitempty"`

	// Name The display name of the node.
	Name      *string    `json:"name,omitempty"`
	Publisher *Publisher `json:"publisher,omitempty"`

	// Rating The average rating of the node.
	Rating *float32 `json:"rating,omitempty"`

	// Repository URL to the node's repository.
	Repository *string     `json:"repository,omitempty"`
	Status     *NodeStatus `json:"status,omitempty"`

	// StatusDetail The status detail of the node.
	StatusDetail *string   `json:"status_detail,omitempty"`
	Tags         *[]string `json:"tags,omitempty"`
}

// NodeStatus defines model for NodeStatus.
type NodeStatus string

// NodeVersion defines model for NodeVersion.
type NodeVersion struct {
	// Changelog Summary of changes made in this version
	Changelog *string `json:"changelog,omitempty"`

	// CreatedAt The date and time the version was created.
	CreatedAt *time.Time `json:"createdAt,omitempty"`

	// Dependencies A list of pip dependencies required by the node.
	Dependencies *[]string `json:"dependencies,omitempty"`

	// Deprecated Indicates if this version is deprecated.
	Deprecated *bool `json:"deprecated,omitempty"`

	// DownloadUrl [Output Only] URL to download this version of the node
	DownloadUrl *string `json:"downloadUrl,omitempty"`
	Id          *string `json:"id,omitempty"`

	// NodeId The unique identifier of the node.
	NodeId *string            `json:"node_id,omitempty"`
	Status *NodeVersionStatus `json:"status,omitempty"`

	// StatusReason The reason for the status change.
	StatusReason *string `json:"status_reason,omitempty"`

	// Version The version identifier, following semantic versioning. Must be unique for the node.
	Version *string `json:"version,omitempty"`
}

// NodeVersionStatus defines model for NodeVersionStatus.
type NodeVersionStatus string

// NodeVersionUpdateRequest defines model for NodeVersionUpdateRequest.
type NodeVersionUpdateRequest struct {
	// Changelog The changelog describing the version changes.
	Changelog *string `json:"changelog,omitempty"`

	// Deprecated Whether the version is deprecated.
	Deprecated *bool `json:"deprecated,omitempty"`
}

// PersonalAccessToken defines model for PersonalAccessToken.
type PersonalAccessToken struct {
	// CreatedAt [Output Only]The date and time the token was created.
	CreatedAt *time.Time `json:"createdAt,omitempty"`

	// Description Optional. A more detailed description of the token's intended use.
	Description *string `json:"description,omitempty"`

	// Id Unique identifier for the GitCommit
	Id *openapi_types.UUID `json:"id,omitempty"`

	// Name Required. The name of the token. Can be a simple description.
	Name *string `json:"name,omitempty"`

	// Token [Output Only]. The personal access token. Only returned during creation.
	Token *string `json:"token,omitempty"`
}

// Publisher defines model for Publisher.
type Publisher struct {
	// CreatedAt The date and time the publisher was created.
	CreatedAt   *time.Time `json:"createdAt,omitempty"`
	Description *string    `json:"description,omitempty"`

	// Id The unique identifier for the publisher. It's akin to a username. Should be lowercase.
	Id *string `json:"id,omitempty"`

	// Logo URL to the publisher's logo.
	Logo *string `json:"logo,omitempty"`

	// Members A list of members in the publisher.
	Members        *[]PublisherMember `json:"members,omitempty"`
	Name           *string            `json:"name,omitempty"`
	SourceCodeRepo *string            `json:"source_code_repo,omitempty"`
	Status         *PublisherStatus   `json:"status,omitempty"`
	Support        *string            `json:"support,omitempty"`
	Website        *string            `json:"website,omitempty"`
}

// PublisherMember defines model for PublisherMember.
type PublisherMember struct {
	// Id The unique identifier for the publisher member.
	Id *string `json:"id,omitempty"`

	// Role The role of the user in the publisher.
	Role *string        `json:"role,omitempty"`
	User *PublisherUser `json:"user,omitempty"`
}

// PublisherStatus defines model for PublisherStatus.
type PublisherStatus string

// PublisherUser defines model for PublisherUser.
type PublisherUser struct {
	// Email The email address for this user.
	Email *string `json:"email,omitempty"`

	// Id The unique id for this user.
	Id *string `json:"id,omitempty"`

	// Name The name for this user.
	Name *string `json:"name,omitempty"`
}

// StorageFile defines model for StorageFile.
type StorageFile struct {
	// FilePath Path to the file in storage
	FilePath *string `json:"file_path,omitempty"`

	// Id Unique identifier for the storage file
	Id *openapi_types.UUID `json:"id,omitempty"`

	// PublicUrl Public URL
	PublicUrl *string `json:"public_url,omitempty"`
}

// User defines model for User.
type User struct {
	// Email The email address for this user.
	Email *string `json:"email,omitempty"`

	// Id The unique id for this user.
	Id *string `json:"id,omitempty"`

	// IsAdmin Indicates if the user has admin privileges.
	IsAdmin *bool `json:"isAdmin,omitempty"`

	// IsApproved Indicates if the user is approved.
	IsApproved *bool `json:"isApproved,omitempty"`

	// Name The name for this user.
	Name *string `json:"name,omitempty"`
}

// WorkflowRunStatus defines model for WorkflowRunStatus.
type WorkflowRunStatus string

// AdminUpdateNodeVersionJSONBody defines parameters for AdminUpdateNodeVersion.
type AdminUpdateNodeVersionJSONBody struct {
	Status *NodeVersionStatus `json:"status,omitempty"`

	// StatusReason The reason for the status change.
	StatusReason *string `json:"status_reason,omitempty"`
}

// GetBranchParams defines parameters for GetBranch.
type GetBranchParams struct {
	// RepoName The repo to filter by.
	RepoName string `form:"repo_name" json:"repo_name"`
}

// ComfyNodesBackfillParams defines parameters for ComfyNodesBackfill.
type ComfyNodesBackfillParams struct {
	MaxNode *int `form:"max_node,omitempty" json:"max_node,omitempty"`
}

// GetGitcommitParams defines parameters for GetGitcommit.
type GetGitcommitParams struct {
	// CommitId The ID of the commit to fetch data for.
	CommitId *string `form:"commitId,omitempty" json:"commitId,omitempty"`

	// OperatingSystem The operating system to filter the CI data by.
	OperatingSystem *string `form:"operatingSystem,omitempty" json:"operatingSystem,omitempty"`

	// WorkflowName The name of the workflow to filter the CI data by.
	WorkflowName *string `form:"workflowName,omitempty" json:"workflowName,omitempty"`

	// Branch The branch of the gitcommit to filter the CI data by.
	Branch *string `form:"branch,omitempty" json:"branch,omitempty"`

	// Page The page number to retrieve.
	Page *int `form:"page,omitempty" json:"page,omitempty"`

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

	// RepoName The repo to filter by.
	RepoName *string `form:"repoName,omitempty" json:"repoName,omitempty"`
}

// GetGitcommitsummaryParams defines parameters for GetGitcommitsummary.
type GetGitcommitsummaryParams struct {
	// RepoName The repository name to filter the git commits by.
	RepoName *string `form:"repoName,omitempty" json:"repoName,omitempty"`

	// BranchName The branch name to filter the git commits by.
	BranchName *string `form:"branchName,omitempty" json:"branchName,omitempty"`

	// Page The page number to retrieve.
	Page *int `form:"page,omitempty" json:"page,omitempty"`

	// PageSize The number of items to include per page.
	PageSize *int `form:"pageSize,omitempty" json:"pageSize,omitempty"`
}

// ListAllNodesParams defines parameters for ListAllNodes.
type ListAllNodesParams struct {
	// Page Page number of the nodes list
	Page *int `form:"page,omitempty" json:"page,omitempty"`

	// Limit Number of nodes to return per page
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`

	// IncludeBanned Number of nodes to return per page
	IncludeBanned *bool `form:"include_banned,omitempty" json:"include_banned,omitempty"`

	// Timestamp Retrieve nodes created or updated after this timestamp (ISO 8601 format)
	Timestamp *time.Time `form:"timestamp,omitempty" json:"timestamp,omitempty"`

	// Latest Whether to fetch fresh result from database or use cached one if false
	Latest *bool `form:"latest,omitempty" json:"latest,omitempty"`
}

// ReindexNodesParams defines parameters for ReindexNodes.
type ReindexNodesParams struct {
	// MaxBatch Maximum number of nodes to send to algolia at a time
	MaxBatch *int `form:"max_batch,omitempty" json:"max_batch,omitempty"`

	// MinAge Minimum interval from the last time the nodes were indexed to algolia
	MinAge *time.Duration `form:"min_age,omitempty" json:"min_age,omitempty"`
}

// SearchNodesParams defines parameters for SearchNodes.
type SearchNodesParams struct {
	// Page Page number of the nodes list
	Page *int `form:"page,omitempty" json:"page,omitempty"`

	// Limit Number of nodes to return per page
	Limit *int `form:"limit,omitempty" json:"limit,omitempty"`

	// Search Keyword to search the nodes
	Search *string `form:"search,omitempty" json:"search,omitempty"`

	// IncludeBanned Number of nodes to return per page
	IncludeBanned *bool `form:"include_banned,omitempty" json:"include_banned,omitempty"`
}

// InstallNodeParams defines parameters for InstallNode.
type InstallNodeParams struct {
	// Version Specific version of the node to retrieve. If omitted, the latest version is returned.
	Version *string `form:"version,omitempty" json:"version,omitempty"`
}

// PostNodeReviewParams defines parameters for PostNodeReview.
type PostNodeReviewParams struct {
	// Star number of star given to the node version
	Star int `form:"star" json:"star"`
}

// ListNodeVersionsParams defines parameters for ListNodeVersions.
type ListNodeVersionsParams struct {
	Statuses            *[]NodeVersionStatus `form:"statuses,omitempty" json:"statuses,omitempty"`
	IncludeStatusReason *bool                `form:"include_status_reason,omitempty" json:"include_status_reason,omitempty"`
}

// CreateComfyNodesJSONBody defines parameters for CreateComfyNodes.
type CreateComfyNodesJSONBody struct {
	CloudBuildInfo *ComfyNodeCloudBuildInfo `json:"cloud_build_info,omitempty"`
	Nodes          *map[string]ComfyNode    `json:"nodes,omitempty"`
	Reason         *string                  `json:"reason,omitempty"`
	Success        *bool                    `json:"success,omitempty"`
}

// ValidatePublisherParams defines parameters for ValidatePublisher.
type ValidatePublisherParams struct {
	// Username The publisher username to validate.
	Username string `form:"username" json:"username"`
}

// ListNodesForPublisherParams defines parameters for ListNodesForPublisher.
type ListNodesForPublisherParams struct {
	// IncludeBanned Number of nodes to return per page
	IncludeBanned *bool `form:"include_banned,omitempty" json:"include_banned,omitempty"`
}

// PublishNodeVersionJSONBody defines parameters for PublishNodeVersion.
type PublishNodeVersionJSONBody struct {
	Node                Node        `json:"node"`
	NodeVersion         NodeVersion `json:"node_version"`
	PersonalAccessToken string      `json:"personal_access_token"`
}

// SecurityScanParams defines parameters for SecurityScan.
type SecurityScanParams struct {
	MinAge   *time.Duration `form:"minAge,omitempty" json:"minAge,omitempty"`
	MaxNodes *int           `form:"maxNodes,omitempty" json:"maxNodes,omitempty"`
}

// PostUploadArtifactJSONBody defines parameters for PostUploadArtifact.
type PostUploadArtifactJSONBody struct {
	// Author The author of the commit
	Author string `json:"author"`

	// AvgVram The average amount of VRAM used in the run.
	AvgVram    *int   `json:"avg_vram,omitempty"`
	BranchName string `json:"branch_name"`

	// BucketName The name of the bucket where the output files are stored
	BucketName *string `json:"bucket_name,omitempty"`

	// ComfyLogsGcsPath The path to Hanzo Studio logs. eg. gs://bucket-name/logs
	ComfyLogsGcsPath *string `json:"comfy_logs_gcs_path,omitempty"`

	// ComfyRunFlags The flags used in the comfy run
	ComfyRunFlags *string `json:"comfy_run_flags,omitempty"`
	CommitHash    string  `json:"commit_hash"`

	// CommitMessage The commit message
	CommitMessage string `json:"commit_message"`

	// CommitTime The time of the commit in the format of "YYYY-MM-DDTHH:MM:SSZ" (2016-10-10T00:00:00Z)
	CommitTime string `json:"commit_time"`

	// CudaVersion Cuda version.
	CudaVersion *string `json:"cuda_version,omitempty"`

	// EndTime The end time of the job as a Unix timestamp.
	EndTime int64 `json:"end_time"`

	// JobId Unique identifier for the job
	JobId string `json:"job_id"`

	// JobTriggerUser The user who triggered the job
	JobTriggerUser string        `json:"job_trigger_user"`
	MachineStats   *MachineStats `json:"machine_stats,omitempty"`

	// Os Operating system used in the run
	Os string `json:"os"`

	// OutputFilesGcsPaths A comma separated string that contains GCS path(s) to output files. eg. gs://bucket-name/output, gs://bucket-name/output2
	OutputFilesGcsPaths *string `json:"output_files_gcs_paths,omitempty"`

	// PeakVram The peak amount of VRAM used in the run.
	PeakVram *int `json:"peak_vram,omitempty"`

	// PrNumber The pull request number
	PrNumber string `json:"pr_number"`

	// PythonVersion The python version used in the run
	PythonVersion string `json:"python_version"`

	// PytorchVersion The pytorch version used in the run
	PytorchVersion *string `json:"pytorch_version,omitempty"`

	// Repo Repository name
	Repo string `json:"repo"`

	// RunId Unique identifier for the run
	RunId string `json:"run_id"`

	// StartTime The start time of the job as a Unix timestamp.
	StartTime int64             `json:"start_time"`
	Status    WorkflowRunStatus `json:"status"`

	// WorkflowName The name of the workflow
	WorkflowName string `json:"workflow_name"`
}

// ListAllNodeVersionsParams defines parameters for ListAllNodeVersions.
type ListAllNodeVersionsParams struct {
	NodeId              *string              `form:"nodeId,omitempty" json:"nodeId,omitempty"`
	Statuses            *[]NodeVersionStatus `form:"statuses,omitempty" json:"statuses,omitempty"`
	IncludeStatusReason *bool                `form:"include_status_reason,omitempty" json:"include_status_reason,omitempty"`

	// Page The page number to retrieve.
	Page *int `form:"page,omitempty" json:"page,omitempty"`

	// PageSize The number of items to include per page.
	PageSize *int `form:"pageSize,omitempty" json:"pageSize,omitempty"`
}

// AdminUpdateNodeVersionJSONRequestBody defines body for AdminUpdateNodeVersion for application/json ContentType.
type AdminUpdateNodeVersionJSONRequestBody AdminUpdateNodeVersionJSONBody

// CreateComfyNodesJSONRequestBody defines body for CreateComfyNodes for application/json ContentType.
type CreateComfyNodesJSONRequestBody CreateComfyNodesJSONBody

// CreatePublisherJSONRequestBody defines body for CreatePublisher for application/json ContentType.
type CreatePublisherJSONRequestBody = Publisher

// UpdatePublisherJSONRequestBody defines body for UpdatePublisher for application/json ContentType.
type UpdatePublisherJSONRequestBody = Publisher

// CreateNodeJSONRequestBody defines body for CreateNode for application/json ContentType.
type CreateNodeJSONRequestBody = Node

// UpdateNodeJSONRequestBody defines body for UpdateNode for application/json ContentType.
type UpdateNodeJSONRequestBody = Node

// PublishNodeVersionJSONRequestBody defines body for PublishNodeVersion for application/json ContentType.
type PublishNodeVersionJSONRequestBody PublishNodeVersionJSONBody

// UpdateNodeVersionJSONRequestBody defines body for UpdateNodeVersion for application/json ContentType.
type UpdateNodeVersionJSONRequestBody = NodeVersionUpdateRequest

// CreatePersonalAccessTokenJSONRequestBody defines body for CreatePersonalAccessToken for application/json ContentType.
type CreatePersonalAccessTokenJSONRequestBody = PersonalAccessToken

// PostUploadArtifactJSONRequestBody defines body for PostUploadArtifact for application/json ContentType.
type PostUploadArtifactJSONRequestBody PostUploadArtifactJSONBody

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Admin Update Node Version Status
	// (PUT /admin/nodes/{nodeId}/versions/{versionNumber})
	AdminUpdateNodeVersion(ctx echo.Context, nodeId string, versionNumber string) error
	// Retrieve all distinct branches for a given repo
	// (GET /branch)
	GetBranch(ctx echo.Context, params GetBranchParams) error
	// trigger comfy nodes backfill
	// (POST /comfy-nodes/backfill)
	ComfyNodesBackfill(ctx echo.Context, params ComfyNodesBackfillParams) error
	// Retrieve CI data for a given commit
	// (GET /gitcommit)
	GetGitcommit(ctx echo.Context, params GetGitcommitParams) error
	// Retrieve a summary of git commits
	// (GET /gitcommitsummary)
	GetGitcommitsummary(ctx echo.Context, params GetGitcommitsummaryParams) error
	// Retrieves a list of nodes
	// (GET /nodes)
	ListAllNodes(ctx echo.Context, params ListAllNodesParams) error
	// Reindex all nodes for searching.
	// (POST /nodes/reindex)
	ReindexNodes(ctx echo.Context, params ReindexNodesParams) error
	// Retrieves a list of nodes
	// (GET /nodes/search)
	SearchNodes(ctx echo.Context, params SearchNodesParams) error
	// Retrieve a specific node by ID
	// (GET /nodes/{nodeId})
	GetNode(ctx echo.Context, nodeId string) error
	// Returns a node version to be installed.
	// (GET /nodes/{nodeId}/install)
	InstallNode(ctx echo.Context, nodeId string, params InstallNodeParams) error
	// Add review to a specific version of a node
	// (POST /nodes/{nodeId}/reviews)
	PostNodeReview(ctx echo.Context, nodeId string, params PostNodeReviewParams) error
	// List all versions of a node
	// (GET /nodes/{nodeId}/versions)
	ListNodeVersions(ctx echo.Context, nodeId string, params ListNodeVersionsParams) error
	// Retrieve a specific version of a node
	// (GET /nodes/{nodeId}/versions/{versionId})
	GetNodeVersion(ctx echo.Context, nodeId string, versionId string) error
	// create comfy-nodes for certain node
	// (POST /nodes/{nodeId}/versions/{version}/comfy-nodes)
	CreateComfyNodes(ctx echo.Context, nodeId string, version string) error
	// get specify comfy-node based on its id
	// (GET /nodes/{nodeId}/versions/{version}/comfy-nodes/{comfyNodeId})
	GetComfyNode(ctx echo.Context, nodeId string, version string, comfyNodeId string) error
	// Retrieve all publishers
	// (GET /publishers)
	ListPublishers(ctx echo.Context) error
	// Create a new publisher
	// (POST /publishers)
	CreatePublisher(ctx echo.Context) error
	// Validate if a publisher username is available
	// (GET /publishers/validate)
	ValidatePublisher(ctx echo.Context, params ValidatePublisherParams) error
	// Delete a publisher
	// (DELETE /publishers/{publisherId})
	DeletePublisher(ctx echo.Context, publisherId string) error
	// Retrieve a publisher by ID
	// (GET /publishers/{publisherId})
	GetPublisher(ctx echo.Context, publisherId string) error
	// Update a publisher
	// (PUT /publishers/{publisherId})
	UpdatePublisher(ctx echo.Context, publisherId string) error
	// Ban a publisher
	// (POST /publishers/{publisherId}/ban)
	BanPublisher(ctx echo.Context, publisherId string) error
	// Retrieve all nodes
	// (GET /publishers/{publisherId}/nodes)
	ListNodesForPublisher(ctx echo.Context, publisherId string, params ListNodesForPublisherParams) error
	// Create a new custom node
	// (POST /publishers/{publisherId}/nodes)
	CreateNode(ctx echo.Context, publisherId string) error
	// Delete a specific node
	// (DELETE /publishers/{publisherId}/nodes/{nodeId})
	DeleteNode(ctx echo.Context, publisherId string, nodeId string) error
	// Update a specific node
	// (PUT /publishers/{publisherId}/nodes/{nodeId})
	UpdateNode(ctx echo.Context, publisherId string, nodeId string) error
	// Ban a publisher's Node
	// (POST /publishers/{publisherId}/nodes/{nodeId}/ban)
	BanPublisherNode(ctx echo.Context, publisherId string, nodeId string) error
	// Retrieve permissions the user has for a given publisher
	// (GET /publishers/{publisherId}/nodes/{nodeId}/permissions)
	GetPermissionOnPublisherNodes(ctx echo.Context, publisherId string, nodeId string) error
	// Publish a new version of a node
	// (POST /publishers/{publisherId}/nodes/{nodeId}/versions)
	PublishNodeVersion(ctx echo.Context, publisherId string, nodeId string) error
	// Unpublish (delete) a specific version of a node
	// (DELETE /publishers/{publisherId}/nodes/{nodeId}/versions/{versionId})
	DeleteNodeVersion(ctx echo.Context, publisherId string, nodeId string, versionId string) error
	// Update changelog and deprecation status of a node version
	// (PUT /publishers/{publisherId}/nodes/{nodeId}/versions/{versionId})
	UpdateNodeVersion(ctx echo.Context, publisherId string, nodeId string, versionId string) error
	// Retrieve permissions the user has for a given publisher
	// (GET /publishers/{publisherId}/permissions)
	GetPermissionOnPublisher(ctx echo.Context, publisherId string) error
	// Retrieve all personal access tokens for a publisher
	// (GET /publishers/{publisherId}/tokens)
	ListPersonalAccessTokens(ctx echo.Context, publisherId string) error
	// Create a new personal access token
	// (POST /publishers/{publisherId}/tokens)
	CreatePersonalAccessToken(ctx echo.Context, publisherId string) error
	// Delete a specific personal access token
	// (DELETE /publishers/{publisherId}/tokens/{tokenId})
	DeletePersonalAccessToken(ctx echo.Context, publisherId string, tokenId string) error
	// Security Scan
	// (GET /security-scan)
	SecurityScan(ctx echo.Context, params SecurityScanParams) error
	// Receive artifacts (output files) from the Hanzo Studio GitHub Action
	// (POST /upload-artifact)
	PostUploadArtifact(ctx echo.Context) error
	// Get information about the calling user.
	// (GET /users)
	GetUser(ctx echo.Context) error
	// Retrieve all publishers for a given user
	// (GET /users/publishers/)
	ListPublishersForUser(ctx echo.Context) error
	// List all node versions given some filters.
	// (GET /versions)
	ListAllNodeVersions(ctx echo.Context, params ListAllNodeVersionsParams) error
	// Retrieve a specific commit by ID
	// (GET /workflowresult/{workflowResultId})
	GetWorkflowResult(ctx echo.Context, workflowResultId string) error
}

// ServerInterfaceWrapper converts echo contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler ServerInterface
}

// AdminUpdateNodeVersion converts echo context to params.
func (w *ServerInterfaceWrapper) AdminUpdateNodeVersion(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "versionNumber" -------------
	var versionNumber string

	err = runtime.BindStyledParameterWithOptions("simple", "versionNumber", ctx.Param("versionNumber"), &versionNumber, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter versionNumber: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.AdminUpdateNodeVersion(ctx, nodeId, versionNumber)
	return err
}

// GetBranch converts echo context to params.
func (w *ServerInterfaceWrapper) GetBranch(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params GetBranchParams
	// ------------- Required query parameter "repo_name" -------------

	err = runtime.BindQueryParameter("form", true, true, "repo_name", ctx.QueryParams(), &params.RepoName)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter repo_name: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetBranch(ctx, params)
	return err
}

// ComfyNodesBackfill converts echo context to params.
func (w *ServerInterfaceWrapper) ComfyNodesBackfill(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ComfyNodesBackfillParams
	// ------------- Optional query parameter "max_node" -------------

	err = runtime.BindQueryParameter("form", true, false, "max_node", ctx.QueryParams(), &params.MaxNode)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max_node: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ComfyNodesBackfill(ctx, params)
	return err
}

// GetGitcommit converts echo context to params.
func (w *ServerInterfaceWrapper) GetGitcommit(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params GetGitcommitParams
	// ------------- Optional query parameter "commitId" -------------

	err = runtime.BindQueryParameter("form", true, false, "commitId", ctx.QueryParams(), &params.CommitId)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter commitId: %s", err))
	}

	// ------------- Optional query parameter "operatingSystem" -------------

	err = runtime.BindQueryParameter("form", true, false, "operatingSystem", ctx.QueryParams(), &params.OperatingSystem)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter operatingSystem: %s", err))
	}

	// ------------- Optional query parameter "workflowName" -------------

	err = runtime.BindQueryParameter("form", true, false, "workflowName", ctx.QueryParams(), &params.WorkflowName)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter workflowName: %s", err))
	}

	// ------------- Optional query parameter "branch" -------------

	err = runtime.BindQueryParameter("form", true, false, "branch", ctx.QueryParams(), &params.Branch)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter branch: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", true, false, "page", ctx.QueryParams(), &params.Page)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

	// ------------- Optional query parameter "pageSize" -------------

	err = runtime.BindQueryParameter("form", true, false, "pageSize", ctx.QueryParams(), &params.PageSize)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter pageSize: %s", err))
	}

	// ------------- Optional query parameter "repoName" -------------

	err = runtime.BindQueryParameter("form", true, false, "repoName", ctx.QueryParams(), &params.RepoName)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter repoName: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetGitcommit(ctx, params)
	return err
}

// GetGitcommitsummary converts echo context to params.
func (w *ServerInterfaceWrapper) GetGitcommitsummary(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params GetGitcommitsummaryParams
	// ------------- Optional query parameter "repoName" -------------

	err = runtime.BindQueryParameter("form", true, false, "repoName", ctx.QueryParams(), &params.RepoName)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter repoName: %s", err))
	}

	// ------------- Optional query parameter "branchName" -------------

	err = runtime.BindQueryParameter("form", true, false, "branchName", ctx.QueryParams(), &params.BranchName)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter branchName: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", true, false, "page", ctx.QueryParams(), &params.Page)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

	// ------------- Optional query parameter "pageSize" -------------

	err = runtime.BindQueryParameter("form", true, false, "pageSize", ctx.QueryParams(), &params.PageSize)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter pageSize: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetGitcommitsummary(ctx, params)
	return err
}

// ListAllNodes converts echo context to params.
func (w *ServerInterfaceWrapper) ListAllNodes(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ListAllNodesParams
	// ------------- Optional query parameter "page" -------------

	err = runtime.BindQueryParameter("form", true, false, "page", ctx.QueryParams(), &params.Page)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
	}

	// ------------- Optional query parameter "include_banned" -------------

	err = runtime.BindQueryParameter("form", true, false, "include_banned", ctx.QueryParams(), &params.IncludeBanned)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include_banned: %s", err))
	}

	// ------------- Optional query parameter "timestamp" -------------

	err = runtime.BindQueryParameter("form", true, false, "timestamp", ctx.QueryParams(), &params.Timestamp)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter timestamp: %s", err))
	}

	// ------------- Optional query parameter "latest" -------------

	err = runtime.BindQueryParameter("form", true, false, "latest", ctx.QueryParams(), &params.Latest)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter latest: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListAllNodes(ctx, params)
	return err
}

// ReindexNodes converts echo context to params.
func (w *ServerInterfaceWrapper) ReindexNodes(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ReindexNodesParams
	// ------------- Optional query parameter "max_batch" -------------

	err = runtime.BindQueryParameter("form", true, false, "max_batch", ctx.QueryParams(), &params.MaxBatch)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max_batch: %s", err))
	}

	// ------------- Optional query parameter "min_age" -------------

	err = runtime.BindQueryParameter("form", true, false, "min_age", ctx.QueryParams(), &params.MinAge)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter min_age: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ReindexNodes(ctx, params)
	return err
}

// SearchNodes converts echo context to params.
func (w *ServerInterfaceWrapper) SearchNodes(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params SearchNodesParams
	// ------------- Optional query parameter "page" -------------

	err = runtime.BindQueryParameter("form", true, false, "page", ctx.QueryParams(), &params.Page)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
	}

	// ------------- Optional query parameter "search" -------------

	err = runtime.BindQueryParameter("form", true, false, "search", ctx.QueryParams(), &params.Search)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter search: %s", err))
	}

	// ------------- Optional query parameter "include_banned" -------------

	err = runtime.BindQueryParameter("form", true, false, "include_banned", ctx.QueryParams(), &params.IncludeBanned)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include_banned: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.SearchNodes(ctx, params)
	return err
}

// GetNode converts echo context to params.
func (w *ServerInterfaceWrapper) GetNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetNode(ctx, nodeId)
	return err
}

// InstallNode converts echo context to params.
func (w *ServerInterfaceWrapper) InstallNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params InstallNodeParams
	// ------------- Optional query parameter "version" -------------

	err = runtime.BindQueryParameter("form", true, false, "version", ctx.QueryParams(), &params.Version)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter version: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.InstallNode(ctx, nodeId, params)
	return err
}

// PostNodeReview converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeReview(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params PostNodeReviewParams
	// ------------- Required query parameter "star" -------------

	err = runtime.BindQueryParameter("form", true, true, "star", ctx.QueryParams(), &params.Star)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter star: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostNodeReview(ctx, nodeId, params)
	return err
}

// ListNodeVersions converts echo context to params.
func (w *ServerInterfaceWrapper) ListNodeVersions(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params ListNodeVersionsParams
	// ------------- Optional query parameter "statuses" -------------

	err = runtime.BindQueryParameter("form", true, false, "statuses", ctx.QueryParams(), &params.Statuses)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter statuses: %s", err))
	}

	// ------------- Optional query parameter "include_status_reason" -------------

	err = runtime.BindQueryParameter("form", true, false, "include_status_reason", ctx.QueryParams(), &params.IncludeStatusReason)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include_status_reason: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListNodeVersions(ctx, nodeId, params)
	return err
}

// GetNodeVersion converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeVersion(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "versionId" -------------
	var versionId string

	err = runtime.BindStyledParameterWithOptions("simple", "versionId", ctx.Param("versionId"), &versionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter versionId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetNodeVersion(ctx, nodeId, versionId)
	return err
}

// CreateComfyNodes converts echo context to params.
func (w *ServerInterfaceWrapper) CreateComfyNodes(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "version" -------------
	var version string

	err = runtime.BindStyledParameterWithOptions("simple", "version", ctx.Param("version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter version: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.CreateComfyNodes(ctx, nodeId, version)
	return err
}

// GetComfyNode converts echo context to params.
func (w *ServerInterfaceWrapper) GetComfyNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "version" -------------
	var version string

	err = runtime.BindStyledParameterWithOptions("simple", "version", ctx.Param("version"), &version, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter version: %s", err))
	}

	// ------------- Path parameter "comfyNodeId" -------------
	var comfyNodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "comfyNodeId", ctx.Param("comfyNodeId"), &comfyNodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter comfyNodeId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetComfyNode(ctx, nodeId, version, comfyNodeId)
	return err
}

// ListPublishers converts echo context to params.
func (w *ServerInterfaceWrapper) ListPublishers(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListPublishers(ctx)
	return err
}

// CreatePublisher converts echo context to params.
func (w *ServerInterfaceWrapper) CreatePublisher(ctx echo.Context) error {
	var err error

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.CreatePublisher(ctx)
	return err
}

// ValidatePublisher converts echo context to params.
func (w *ServerInterfaceWrapper) ValidatePublisher(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ValidatePublisherParams
	// ------------- Required query parameter "username" -------------

	err = runtime.BindQueryParameter("form", true, true, "username", ctx.QueryParams(), &params.Username)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter username: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ValidatePublisher(ctx, params)
	return err
}

// DeletePublisher converts echo context to params.
func (w *ServerInterfaceWrapper) DeletePublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.DeletePublisher(ctx, publisherId)
	return err
}

// GetPublisher converts echo context to params.
func (w *ServerInterfaceWrapper) GetPublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetPublisher(ctx, publisherId)
	return err
}

// UpdatePublisher converts echo context to params.
func (w *ServerInterfaceWrapper) UpdatePublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.UpdatePublisher(ctx, publisherId)
	return err
}

// BanPublisher converts echo context to params.
func (w *ServerInterfaceWrapper) BanPublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.BanPublisher(ctx, publisherId)
	return err
}

// ListNodesForPublisher converts echo context to params.
func (w *ServerInterfaceWrapper) ListNodesForPublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Parameter object where we will unmarshal all parameters from the context
	var params ListNodesForPublisherParams
	// ------------- Optional query parameter "include_banned" -------------

	err = runtime.BindQueryParameter("form", true, false, "include_banned", ctx.QueryParams(), &params.IncludeBanned)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include_banned: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListNodesForPublisher(ctx, publisherId, params)
	return err
}

// CreateNode converts echo context to params.
func (w *ServerInterfaceWrapper) CreateNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.CreateNode(ctx, publisherId)
	return err
}

// DeleteNode converts echo context to params.
func (w *ServerInterfaceWrapper) DeleteNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.DeleteNode(ctx, publisherId, nodeId)
	return err
}

// UpdateNode converts echo context to params.
func (w *ServerInterfaceWrapper) UpdateNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.UpdateNode(ctx, publisherId, nodeId)
	return err
}

// BanPublisherNode converts echo context to params.
func (w *ServerInterfaceWrapper) BanPublisherNode(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.BanPublisherNode(ctx, publisherId, nodeId)
	return err
}

// GetPermissionOnPublisherNodes converts echo context to params.
func (w *ServerInterfaceWrapper) GetPermissionOnPublisherNodes(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetPermissionOnPublisherNodes(ctx, publisherId, nodeId)
	return err
}

// PublishNodeVersion converts echo context to params.
func (w *ServerInterfaceWrapper) PublishNodeVersion(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PublishNodeVersion(ctx, publisherId, nodeId)
	return err
}

// DeleteNodeVersion converts echo context to params.
func (w *ServerInterfaceWrapper) DeleteNodeVersion(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "versionId" -------------
	var versionId string

	err = runtime.BindStyledParameterWithOptions("simple", "versionId", ctx.Param("versionId"), &versionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter versionId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.DeleteNodeVersion(ctx, publisherId, nodeId, versionId)
	return err
}

// UpdateNodeVersion converts echo context to params.
func (w *ServerInterfaceWrapper) UpdateNodeVersion(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "nodeId" -------------
	var nodeId string

	err = runtime.BindStyledParameterWithOptions("simple", "nodeId", ctx.Param("nodeId"), &nodeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Path parameter "versionId" -------------
	var versionId string

	err = runtime.BindStyledParameterWithOptions("simple", "versionId", ctx.Param("versionId"), &versionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter versionId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.UpdateNodeVersion(ctx, publisherId, nodeId, versionId)
	return err
}

// GetPermissionOnPublisher converts echo context to params.
func (w *ServerInterfaceWrapper) GetPermissionOnPublisher(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetPermissionOnPublisher(ctx, publisherId)
	return err
}

// ListPersonalAccessTokens converts echo context to params.
func (w *ServerInterfaceWrapper) ListPersonalAccessTokens(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListPersonalAccessTokens(ctx, publisherId)
	return err
}

// CreatePersonalAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) CreatePersonalAccessToken(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.CreatePersonalAccessToken(ctx, publisherId)
	return err
}

// DeletePersonalAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) DeletePersonalAccessToken(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "publisherId" -------------
	var publisherId string

	err = runtime.BindStyledParameterWithOptions("simple", "publisherId", ctx.Param("publisherId"), &publisherId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter publisherId: %s", err))
	}

	// ------------- Path parameter "tokenId" -------------
	var tokenId string

	err = runtime.BindStyledParameterWithOptions("simple", "tokenId", ctx.Param("tokenId"), &tokenId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tokenId: %s", err))
	}

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.DeletePersonalAccessToken(ctx, publisherId, tokenId)
	return err
}

// SecurityScan converts echo context to params.
func (w *ServerInterfaceWrapper) SecurityScan(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params SecurityScanParams
	// ------------- Optional query parameter "minAge" -------------

	err = runtime.BindQueryParameter("form", true, false, "minAge", ctx.QueryParams(), &params.MinAge)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter minAge: %s", err))
	}

	// ------------- Optional query parameter "maxNodes" -------------

	err = runtime.BindQueryParameter("form", true, false, "maxNodes", ctx.QueryParams(), &params.MaxNodes)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter maxNodes: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.SecurityScan(ctx, params)
	return err
}

// PostUploadArtifact converts echo context to params.
func (w *ServerInterfaceWrapper) PostUploadArtifact(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostUploadArtifact(ctx)
	return err
}

// GetUser converts echo context to params.
func (w *ServerInterfaceWrapper) GetUser(ctx echo.Context) error {
	var err error

	ctx.Set(BearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetUser(ctx)
	return err
}

// ListPublishersForUser converts echo context to params.
func (w *ServerInterfaceWrapper) ListPublishersForUser(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListPublishersForUser(ctx)
	return err
}

// ListAllNodeVersions converts echo context to params.
func (w *ServerInterfaceWrapper) ListAllNodeVersions(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ListAllNodeVersionsParams
	// ------------- Optional query parameter "nodeId" -------------

	err = runtime.BindQueryParameter("form", true, false, "nodeId", ctx.QueryParams(), &params.NodeId)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodeId: %s", err))
	}

	// ------------- Optional query parameter "statuses" -------------

	err = runtime.BindQueryParameter("form", true, false, "statuses", ctx.QueryParams(), &params.Statuses)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter statuses: %s", err))
	}

	// ------------- Optional query parameter "include_status_reason" -------------

	err = runtime.BindQueryParameter("form", true, false, "include_status_reason", ctx.QueryParams(), &params.IncludeStatusReason)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include_status_reason: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", true, false, "page", ctx.QueryParams(), &params.Page)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

	// ------------- Optional query parameter "pageSize" -------------

	err = runtime.BindQueryParameter("form", true, false, "pageSize", ctx.QueryParams(), &params.PageSize)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter pageSize: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ListAllNodeVersions(ctx, params)
	return err
}

// GetWorkflowResult converts echo context to params.
func (w *ServerInterfaceWrapper) GetWorkflowResult(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "workflowResultId" -------------
	var workflowResultId string

	err = runtime.BindStyledParameterWithOptions("simple", "workflowResultId", ctx.Param("workflowResultId"), &workflowResultId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter workflowResultId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetWorkflowResult(ctx, workflowResultId)
	return err
}

// This is a simple interface which specifies echo.Route addition functions which
// are present on both echo.Echo and echo.Group, since we want to allow using
// either of them for path registration
type EchoRouter interface {
	CONNECT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	DELETE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	GET(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	HEAD(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	OPTIONS(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PATCH(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	POST(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PUT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	TRACE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
}

// RegisterHandlers adds each server route to the EchoRouter.
func RegisterHandlers(router EchoRouter, si ServerInterface) {
	RegisterHandlersWithBaseURL(router, si, "")
}

// Registers handlers, and prepends BaseURL to the paths, so that the paths
// can be served under a prefix.
func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string) {

	wrapper := ServerInterfaceWrapper{
		Handler: si,
	}

	router.PUT(baseURL+"/admin/nodes/:nodeId/versions/:versionNumber", wrapper.AdminUpdateNodeVersion)
	router.GET(baseURL+"/branch", wrapper.GetBranch)
	router.POST(baseURL+"/comfy-nodes/backfill", wrapper.ComfyNodesBackfill)
	router.GET(baseURL+"/gitcommit", wrapper.GetGitcommit)
	router.GET(baseURL+"/gitcommitsummary", wrapper.GetGitcommitsummary)
	router.GET(baseURL+"/nodes", wrapper.ListAllNodes)
	router.POST(baseURL+"/nodes/reindex", wrapper.ReindexNodes)
	router.GET(baseURL+"/nodes/search", wrapper.SearchNodes)
	router.GET(baseURL+"/nodes/:nodeId", wrapper.GetNode)
	router.GET(baseURL+"/nodes/:nodeId/install", wrapper.InstallNode)
	router.POST(baseURL+"/nodes/:nodeId/reviews", wrapper.PostNodeReview)
	router.GET(baseURL+"/nodes/:nodeId/versions", wrapper.ListNodeVersions)
	router.GET(baseURL+"/nodes/:nodeId/versions/:versionId", wrapper.GetNodeVersion)
	router.POST(baseURL+"/nodes/:nodeId/versions/:version/comfy-nodes", wrapper.CreateComfyNodes)
	router.GET(baseURL+"/nodes/:nodeId/versions/:version/comfy-nodes/:comfyNodeId", wrapper.GetComfyNode)
	router.GET(baseURL+"/publishers", wrapper.ListPublishers)
	router.POST(baseURL+"/publishers", wrapper.CreatePublisher)
	router.GET(baseURL+"/publishers/validate", wrapper.ValidatePublisher)
	router.DELETE(baseURL+"/publishers/:publisherId", wrapper.DeletePublisher)
	router.GET(baseURL+"/publishers/:publisherId", wrapper.GetPublisher)
	router.PUT(baseURL+"/publishers/:publisherId", wrapper.UpdatePublisher)
	router.POST(baseURL+"/publishers/:publisherId/ban", wrapper.BanPublisher)
	router.GET(baseURL+"/publishers/:publisherId/nodes", wrapper.ListNodesForPublisher)
	router.POST(baseURL+"/publishers/:publisherId/nodes", wrapper.CreateNode)
	router.DELETE(baseURL+"/publishers/:publisherId/nodes/:nodeId", wrapper.DeleteNode)
	router.PUT(baseURL+"/publishers/:publisherId/nodes/:nodeId", wrapper.UpdateNode)
	router.POST(baseURL+"/publishers/:publisherId/nodes/:nodeId/ban", wrapper.BanPublisherNode)
	router.GET(baseURL+"/publishers/:publisherId/nodes/:nodeId/permissions", wrapper.GetPermissionOnPublisherNodes)
	router.POST(baseURL+"/publishers/:publisherId/nodes/:nodeId/versions", wrapper.PublishNodeVersion)
	router.DELETE(baseURL+"/publishers/:publisherId/nodes/:nodeId/versions/:versionId", wrapper.DeleteNodeVersion)
	router.PUT(baseURL+"/publishers/:publisherId/nodes/:nodeId/versions/:versionId", wrapper.UpdateNodeVersion)
	router.GET(baseURL+"/publishers/:publisherId/permissions", wrapper.GetPermissionOnPublisher)
	router.GET(baseURL+"/publishers/:publisherId/tokens", wrapper.ListPersonalAccessTokens)
	router.POST(baseURL+"/publishers/:publisherId/tokens", wrapper.CreatePersonalAccessToken)
	router.DELETE(baseURL+"/publishers/:publisherId/tokens/:tokenId", wrapper.DeletePersonalAccessToken)
	router.GET(baseURL+"/security-scan", wrapper.SecurityScan)
	router.POST(baseURL+"/upload-artifact", wrapper.PostUploadArtifact)
	router.GET(baseURL+"/users", wrapper.GetUser)
	router.GET(baseURL+"/users/publishers/", wrapper.ListPublishersForUser)
	router.GET(baseURL+"/versions", wrapper.ListAllNodeVersions)
	router.GET(baseURL+"/workflowresult/:workflowResultId", wrapper.GetWorkflowResult)

}

type AdminUpdateNodeVersionRequestObject struct {
	NodeId        string `json:"nodeId"`
	VersionNumber string `json:"versionNumber"`
	Body          *AdminUpdateNodeVersionJSONRequestBody
}

type AdminUpdateNodeVersionResponseObject interface {
	VisitAdminUpdateNodeVersionResponse(w http.ResponseWriter) error
}

type AdminUpdateNodeVersion200JSONResponse NodeVersion

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

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

type AdminUpdateNodeVersion400JSONResponse ErrorResponse

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

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

type AdminUpdateNodeVersion401Response struct {
}

func (response AdminUpdateNodeVersion401Response) VisitAdminUpdateNodeVersionResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type AdminUpdateNodeVersion403JSONResponse ErrorResponse

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

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

type AdminUpdateNodeVersion404JSONResponse ErrorResponse

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

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

type AdminUpdateNodeVersion500JSONResponse ErrorResponse

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

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

type GetBranchRequestObject struct {
	Params GetBranchParams
}

type GetBranchResponseObject interface {
	VisitGetBranchResponse(w http.ResponseWriter) error
}

type GetBranch200JSONResponse struct {
	Branches *[]string `json:"branches,omitempty"`
}

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

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

type GetBranch404Response struct {
}

func (response GetBranch404Response) VisitGetBranchResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type GetBranch500Response struct {
}

func (response GetBranch500Response) VisitGetBranchResponse(w http.ResponseWriter) error {
	w.WriteHeader(500)
	return nil
}

type ComfyNodesBackfillRequestObject struct {
	Params ComfyNodesBackfillParams
}

type ComfyNodesBackfillResponseObject interface {
	VisitComfyNodesBackfillResponse(w http.ResponseWriter) error
}

type ComfyNodesBackfill204Response struct {
}

func (response ComfyNodesBackfill204Response) VisitComfyNodesBackfillResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type ComfyNodesBackfill400JSONResponse ErrorResponse

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

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

type ComfyNodesBackfill401Response struct {
}

func (response ComfyNodesBackfill401Response) VisitComfyNodesBackfillResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type ComfyNodesBackfill403JSONResponse ErrorResponse

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

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

type ComfyNodesBackfill500JSONResponse ErrorResponse

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

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

type GetGitcommitRequestObject struct {
	Params GetGitcommitParams
}

type GetGitcommitResponseObject interface {
	VisitGetGitcommitResponse(w http.ResponseWriter) error
}

type GetGitcommit200JSONResponse struct {
	JobResults         *[]ActionJobResult `json:"jobResults,omitempty"`
	TotalNumberOfPages *int               `json:"totalNumberOfPages,omitempty"`
}

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

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

type GetGitcommit404Response struct {
}

func (response GetGitcommit404Response) VisitGetGitcommitResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type GetGitcommit500Response struct {
}

func (response GetGitcommit500Response) VisitGetGitcommitResponse(w http.ResponseWriter) error {
	w.WriteHeader(500)
	return nil
}

type GetGitcommitsummaryRequestObject struct {
	Params GetGitcommitsummaryParams
}

type GetGitcommitsummaryResponseObject interface {
	VisitGetGitcommitsummaryResponse(w http.ResponseWriter) error
}

type GetGitcommitsummary200JSONResponse struct {
	CommitSummaries    *[]GitCommitSummary `json:"commitSummaries,omitempty"`
	TotalNumberOfPages *int                `json:"totalNumberOfPages,omitempty"`
}

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

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

type GetGitcommitsummary500JSONResponse struct {
	Message *string `json:"message,omitempty"`
}

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

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

type ListAllNodesRequestObject struct {
	Params ListAllNodesParams
}

type ListAllNodesResponseObject interface {
	VisitListAllNodesResponse(w http.ResponseWriter) error
}

type ListAllNodes200JSONResponse struct {
	// Limit Maximum number of nodes per page
	Limit *int    `json:"limit,omitempty"`
	Nodes *[]Node `json:"nodes,omitempty"`

	// Page Current page number
	Page *int `json:"page,omitempty"`

	// Total Total number of nodes available
	Total *int `json:"total,omitempty"`

	// TotalPages Total number of pages available
	TotalPages *int `json:"totalPages,omitempty"`
}

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

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

type ListAllNodes400Response struct {
}

func (response ListAllNodes400Response) VisitListAllNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type ListAllNodes404Response struct {
}

func (response ListAllNodes404Response) VisitListAllNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type ListAllNodes500JSONResponse ErrorResponse

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

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

type ReindexNodesRequestObject struct {
	Params ReindexNodesParams
}

type ReindexNodesResponseObject interface {
	VisitReindexNodesResponse(w http.ResponseWriter) error
}

type ReindexNodes200Response struct {
}

func (response ReindexNodes200Response) VisitReindexNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(200)
	return nil
}

type ReindexNodes400JSONResponse ErrorResponse

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

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

type ReindexNodes500JSONResponse ErrorResponse

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

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

type SearchNodesRequestObject struct {
	Params SearchNodesParams
}

type SearchNodesResponseObject interface {
	VisitSearchNodesResponse(w http.ResponseWriter) error
}

type SearchNodes200JSONResponse struct {
	// Limit Maximum number of nodes per page
	Limit *int    `json:"limit,omitempty"`
	Nodes *[]Node `json:"nodes,omitempty"`

	// Page Current page number
	Page *int `json:"page,omitempty"`

	// Total Total number of nodes available
	Total *int `json:"total,omitempty"`

	// TotalPages Total number of pages available
	TotalPages *int `json:"totalPages,omitempty"`
}

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

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

type SearchNodes400Response struct {
}

func (response SearchNodes400Response) VisitSearchNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type SearchNodes404Response struct {
}

func (response SearchNodes404Response) VisitSearchNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type SearchNodes500JSONResponse ErrorResponse

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

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

type GetNodeRequestObject struct {
	NodeId string `json:"nodeId"`
}

type GetNodeResponseObject interface {
	VisitGetNodeResponse(w http.ResponseWriter) error
}

type GetNode200JSONResponse Node

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

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

type GetNode403JSONResponse ErrorResponse

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

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

type GetNode404JSONResponse ErrorResponse

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

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

type GetNode500JSONResponse ErrorResponse

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

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

type InstallNodeRequestObject struct {
	NodeId string `json:"nodeId"`
	Params InstallNodeParams
}

type InstallNodeResponseObject interface {
	VisitInstallNodeResponse(w http.ResponseWriter) error
}

type InstallNode200JSONResponse NodeVersion

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

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

type InstallNode400JSONResponse ErrorResponse

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

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

type InstallNode403JSONResponse ErrorResponse

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

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

type InstallNode404JSONResponse ErrorResponse

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

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

type InstallNode500JSONResponse ErrorResponse

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

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

type PostNodeReviewRequestObject struct {
	NodeId string `json:"nodeId"`
	Params PostNodeReviewParams
}

type PostNodeReviewResponseObject interface {
	VisitPostNodeReviewResponse(w http.ResponseWriter) error
}

type PostNodeReview200JSONResponse Node

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

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

type PostNodeReview400Response struct {
}

func (response PostNodeReview400Response) VisitPostNodeReviewResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type PostNodeReview404JSONResponse Error

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

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

type PostNodeReview500JSONResponse ErrorResponse

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

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

type ListNodeVersionsRequestObject struct {
	NodeId string `json:"nodeId"`
	Params ListNodeVersionsParams
}

type ListNodeVersionsResponseObject interface {
	VisitListNodeVersionsResponse(w http.ResponseWriter) error
}

type ListNodeVersions200JSONResponse []NodeVersion

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

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

type ListNodeVersions403JSONResponse ErrorResponse

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

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

type ListNodeVersions404JSONResponse Error

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

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

type ListNodeVersions500JSONResponse ErrorResponse

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

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

type GetNodeVersionRequestObject struct {
	NodeId    string `json:"nodeId"`
	VersionId string `json:"versionId"`
}

type GetNodeVersionResponseObject interface {
	VisitGetNodeVersionResponse(w http.ResponseWriter) error
}

type GetNodeVersion200JSONResponse NodeVersion

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

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

type GetNodeVersion404JSONResponse Error

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

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

type GetNodeVersion500JSONResponse ErrorResponse

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

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

type CreateComfyNodesRequestObject struct {
	NodeId  string `json:"nodeId"`
	Version string `json:"version"`
	Body    *CreateComfyNodesJSONRequestBody
}

type CreateComfyNodesResponseObject interface {
	VisitCreateComfyNodesResponse(w http.ResponseWriter) error
}

type CreateComfyNodes204Response struct {
}

func (response CreateComfyNodes204Response) VisitCreateComfyNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type CreateComfyNodes401Response struct {
}

func (response CreateComfyNodes401Response) VisitCreateComfyNodesResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type CreateComfyNodes403JSONResponse ErrorResponse

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

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

type CreateComfyNodes404JSONResponse ErrorResponse

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

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

type CreateComfyNodes409JSONResponse ErrorResponse

func (response CreateComfyNodes409JSONResponse) VisitCreateComfyNodesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(409)

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

type CreateComfyNodes500JSONResponse ErrorResponse

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

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

type GetComfyNodeRequestObject struct {
	NodeId      string `json:"nodeId"`
	Version     string `json:"version"`
	ComfyNodeId string `json:"comfyNodeId"`
}

type GetComfyNodeResponseObject interface {
	VisitGetComfyNodeResponse(w http.ResponseWriter) error
}

type GetComfyNode200JSONResponse ComfyNode

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

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

type GetComfyNode401Response struct {
}

func (response GetComfyNode401Response) VisitGetComfyNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type GetComfyNode403JSONResponse ErrorResponse

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

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

type GetComfyNode404JSONResponse ErrorResponse

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

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

type GetComfyNode500JSONResponse ErrorResponse

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

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

type ListPublishersRequestObject struct {
}

type ListPublishersResponseObject interface {
	VisitListPublishersResponse(w http.ResponseWriter) error
}

type ListPublishers200JSONResponse []Publisher

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

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

type ListPublishers400JSONResponse ErrorResponse

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

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

type ListPublishers500JSONResponse ErrorResponse

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

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

type CreatePublisherRequestObject struct {
	Body *CreatePublisherJSONRequestBody
}

type CreatePublisherResponseObject interface {
	VisitCreatePublisherResponse(w http.ResponseWriter) error
}

type CreatePublisher201JSONResponse Publisher

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

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

type CreatePublisher400JSONResponse ErrorResponse

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

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

type CreatePublisher401Response struct {
}

func (response CreatePublisher401Response) VisitCreatePublisherResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type CreatePublisher403JSONResponse ErrorResponse

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

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

type CreatePublisher500JSONResponse ErrorResponse

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

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

type ValidatePublisherRequestObject struct {
	Params ValidatePublisherParams
}

type ValidatePublisherResponseObject interface {
	VisitValidatePublisherResponse(w http.ResponseWriter) error
}

type ValidatePublisher200JSONResponse struct {
	// IsAvailable True if the username is available, false otherwise.
	IsAvailable *bool `json:"isAvailable,omitempty"`
}

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

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

type ValidatePublisher400JSONResponse ErrorResponse

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

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

type ValidatePublisher500JSONResponse ErrorResponse

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

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

type DeletePublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
}

type DeletePublisherResponseObject interface {
	VisitDeletePublisherResponse(w http.ResponseWriter) error
}

type DeletePublisher204Response struct {
}

func (response DeletePublisher204Response) VisitDeletePublisherResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeletePublisher404JSONResponse ErrorResponse

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

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

type DeletePublisher500JSONResponse ErrorResponse

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

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

type GetPublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
}

type GetPublisherResponseObject interface {
	VisitGetPublisherResponse(w http.ResponseWriter) error
}

type GetPublisher200JSONResponse Publisher

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

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

type GetPublisher404JSONResponse ErrorResponse

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

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

type GetPublisher500JSONResponse ErrorResponse

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

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

type UpdatePublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
	Body        *UpdatePublisherJSONRequestBody
}

type UpdatePublisherResponseObject interface {
	VisitUpdatePublisherResponse(w http.ResponseWriter) error
}

type UpdatePublisher200JSONResponse Publisher

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

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

type UpdatePublisher400JSONResponse ErrorResponse

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

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

type UpdatePublisher401Response struct {
}

func (response UpdatePublisher401Response) VisitUpdatePublisherResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type UpdatePublisher404JSONResponse ErrorResponse

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

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

type UpdatePublisher500JSONResponse ErrorResponse

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

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

type BanPublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
}

type BanPublisherResponseObject interface {
	VisitBanPublisherResponse(w http.ResponseWriter) error
}

type BanPublisher204Response struct {
}

func (response BanPublisher204Response) VisitBanPublisherResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type BanPublisher401Response struct {
}

func (response BanPublisher401Response) VisitBanPublisherResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type BanPublisher403JSONResponse ErrorResponse

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

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

type BanPublisher404JSONResponse ErrorResponse

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

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

type BanPublisher500JSONResponse ErrorResponse

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

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

type ListNodesForPublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
	Params      ListNodesForPublisherParams
}

type ListNodesForPublisherResponseObject interface {
	VisitListNodesForPublisherResponse(w http.ResponseWriter) error
}

type ListNodesForPublisher200JSONResponse []Node

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

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

type ListNodesForPublisher400JSONResponse ErrorResponse

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

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

type ListNodesForPublisher500JSONResponse ErrorResponse

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

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

type CreateNodeRequestObject struct {
	PublisherId string `json:"publisherId"`
	Body        *CreateNodeJSONRequestBody
}

type CreateNodeResponseObject interface {
	VisitCreateNodeResponse(w http.ResponseWriter) error
}

type CreateNode201JSONResponse Node

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

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

type CreateNode400JSONResponse ErrorResponse

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

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

type CreateNode401Response struct {
}

func (response CreateNode401Response) VisitCreateNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type CreateNode500JSONResponse ErrorResponse

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

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

type DeleteNodeRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
}

type DeleteNodeResponseObject interface {
	VisitDeleteNodeResponse(w http.ResponseWriter) error
}

type DeleteNode204Response struct {
}

func (response DeleteNode204Response) VisitDeleteNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteNode403JSONResponse ErrorResponse

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

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

type DeleteNode404JSONResponse ErrorResponse

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

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

type DeleteNode500JSONResponse ErrorResponse

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

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

type UpdateNodeRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
	Body        *UpdateNodeJSONRequestBody
}

type UpdateNodeResponseObject interface {
	VisitUpdateNodeResponse(w http.ResponseWriter) error
}

type UpdateNode200JSONResponse Node

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

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

type UpdateNode400JSONResponse ErrorResponse

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

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

type UpdateNode401Response struct {
}

func (response UpdateNode401Response) VisitUpdateNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type UpdateNode403JSONResponse ErrorResponse

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

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

type UpdateNode404JSONResponse ErrorResponse

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

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

type UpdateNode500JSONResponse ErrorResponse

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

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

type BanPublisherNodeRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
}

type BanPublisherNodeResponseObject interface {
	VisitBanPublisherNodeResponse(w http.ResponseWriter) error
}

type BanPublisherNode204Response struct {
}

func (response BanPublisherNode204Response) VisitBanPublisherNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type BanPublisherNode401Response struct {
}

func (response BanPublisherNode401Response) VisitBanPublisherNodeResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type BanPublisherNode403JSONResponse ErrorResponse

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

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

type BanPublisherNode404JSONResponse ErrorResponse

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

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

type BanPublisherNode500JSONResponse ErrorResponse

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

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

type GetPermissionOnPublisherNodesRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
}

type GetPermissionOnPublisherNodesResponseObject interface {
	VisitGetPermissionOnPublisherNodesResponse(w http.ResponseWriter) error
}

type GetPermissionOnPublisherNodes200JSONResponse struct {
	CanEdit *bool `json:"canEdit,omitempty"`
}

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

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

type GetPermissionOnPublisherNodes400JSONResponse ErrorResponse

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

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

type GetPermissionOnPublisherNodes500JSONResponse ErrorResponse

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

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

type PublishNodeVersionRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
	Body        *PublishNodeVersionJSONRequestBody
}

type PublishNodeVersionResponseObject interface {
	VisitPublishNodeVersionResponse(w http.ResponseWriter) error
}

type PublishNodeVersion201JSONResponse struct {
	NodeVersion *NodeVersion `json:"node_version,omitempty"`

	// SignedUrl The signed URL to upload the node version token.
	SignedUrl *string `json:"signedUrl,omitempty"`
}

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

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

type PublishNodeVersion400JSONResponse ErrorResponse

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

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

type PublishNodeVersion403JSONResponse ErrorResponse

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

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

type PublishNodeVersion500JSONResponse ErrorResponse

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

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

type DeleteNodeVersionRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
	VersionId   string `json:"versionId"`
}

type DeleteNodeVersionResponseObject interface {
	VisitDeleteNodeVersionResponse(w http.ResponseWriter) error
}

type DeleteNodeVersion204Response struct {
}

func (response DeleteNodeVersion204Response) VisitDeleteNodeVersionResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeleteNodeVersion403JSONResponse ErrorResponse

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

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

type DeleteNodeVersion404JSONResponse Error

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

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

type DeleteNodeVersion500JSONResponse ErrorResponse

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

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

type UpdateNodeVersionRequestObject struct {
	PublisherId string `json:"publisherId"`
	NodeId      string `json:"nodeId"`
	VersionId   string `json:"versionId"`
	Body        *UpdateNodeVersionJSONRequestBody
}

type UpdateNodeVersionResponseObject interface {
	VisitUpdateNodeVersionResponse(w http.ResponseWriter) error
}

type UpdateNodeVersion200JSONResponse NodeVersion

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

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

type UpdateNodeVersion400JSONResponse ErrorResponse

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

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

type UpdateNodeVersion401Response struct {
}

func (response UpdateNodeVersion401Response) VisitUpdateNodeVersionResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type UpdateNodeVersion403JSONResponse ErrorResponse

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

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

type UpdateNodeVersion404JSONResponse ErrorResponse

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

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

type UpdateNodeVersion500JSONResponse ErrorResponse

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

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

type GetPermissionOnPublisherRequestObject struct {
	PublisherId string `json:"publisherId"`
}

type GetPermissionOnPublisherResponseObject interface {
	VisitGetPermissionOnPublisherResponse(w http.ResponseWriter) error
}

type GetPermissionOnPublisher200JSONResponse struct {
	CanEdit *bool `json:"canEdit,omitempty"`
}

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

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

type GetPermissionOnPublisher400JSONResponse ErrorResponse

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

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

type GetPermissionOnPublisher500JSONResponse ErrorResponse

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

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

type ListPersonalAccessTokensRequestObject struct {
	PublisherId string `json:"publisherId"`
}

type ListPersonalAccessTokensResponseObject interface {
	VisitListPersonalAccessTokensResponse(w http.ResponseWriter) error
}

type ListPersonalAccessTokens200JSONResponse []PersonalAccessToken

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

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

type ListPersonalAccessTokens403JSONResponse ErrorResponse

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

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

type ListPersonalAccessTokens404JSONResponse ErrorResponse

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

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

type ListPersonalAccessTokens500JSONResponse ErrorResponse

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

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

type CreatePersonalAccessTokenRequestObject struct {
	PublisherId string `json:"publisherId"`
	Body        *CreatePersonalAccessTokenJSONRequestBody
}

type CreatePersonalAccessTokenResponseObject interface {
	VisitCreatePersonalAccessTokenResponse(w http.ResponseWriter) error
}

type CreatePersonalAccessToken201JSONResponse struct {
	// Token The newly created personal access token.
	Token *string `json:"token,omitempty"`
}

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

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

type CreatePersonalAccessToken400JSONResponse ErrorResponse

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

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

type CreatePersonalAccessToken403JSONResponse ErrorResponse

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

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

type CreatePersonalAccessToken500JSONResponse ErrorResponse

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

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

type DeletePersonalAccessTokenRequestObject struct {
	PublisherId string `json:"publisherId"`
	TokenId     string `json:"tokenId"`
}

type DeletePersonalAccessTokenResponseObject interface {
	VisitDeletePersonalAccessTokenResponse(w http.ResponseWriter) error
}

type DeletePersonalAccessToken204Response struct {
}

func (response DeletePersonalAccessToken204Response) VisitDeletePersonalAccessTokenResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type DeletePersonalAccessToken403JSONResponse ErrorResponse

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

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

type DeletePersonalAccessToken404JSONResponse ErrorResponse

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

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

type DeletePersonalAccessToken500JSONResponse ErrorResponse

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

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

type SecurityScanRequestObject struct {
	Params SecurityScanParams
}

type SecurityScanResponseObject interface {
	VisitSecurityScanResponse(w http.ResponseWriter) error
}

type SecurityScan200Response struct {
}

func (response SecurityScan200Response) VisitSecurityScanResponse(w http.ResponseWriter) error {
	w.WriteHeader(200)
	return nil
}

type SecurityScan400JSONResponse ErrorResponse

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

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

type SecurityScan401Response struct {
}

func (response SecurityScan401Response) VisitSecurityScanResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type SecurityScan403JSONResponse ErrorResponse

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

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

type SecurityScan500JSONResponse ErrorResponse

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

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

type PostUploadArtifactRequestObject struct {
	Body *PostUploadArtifactJSONRequestBody
}

type PostUploadArtifactResponseObject interface {
	VisitPostUploadArtifactResponse(w http.ResponseWriter) error
}

type PostUploadArtifact200JSONResponse struct {
	Message *string `json:"message,omitempty"`
}

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

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

type PostUploadArtifact400Response struct {
}

func (response PostUploadArtifact400Response) VisitPostUploadArtifactResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type PostUploadArtifact500Response struct {
}

func (response PostUploadArtifact500Response) VisitPostUploadArtifactResponse(w http.ResponseWriter) error {
	w.WriteHeader(500)
	return nil
}

type GetUserRequestObject struct {
}

type GetUserResponseObject interface {
	VisitGetUserResponse(w http.ResponseWriter) error
}

type GetUser200JSONResponse User

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

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

type GetUser401Response struct {
}

func (response GetUser401Response) VisitGetUserResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type GetUser404Response struct {
}

func (response GetUser404Response) VisitGetUserResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type ListPublishersForUserRequestObject struct {
}

type ListPublishersForUserResponseObject interface {
	VisitListPublishersForUserResponse(w http.ResponseWriter) error
}

type ListPublishersForUser200JSONResponse []Publisher

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

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

type ListPublishersForUser400JSONResponse ErrorResponse

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

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

type ListPublishersForUser500JSONResponse ErrorResponse

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

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

type ListAllNodeVersionsRequestObject struct {
	Params ListAllNodeVersionsParams
}

type ListAllNodeVersionsResponseObject interface {
	VisitListAllNodeVersionsResponse(w http.ResponseWriter) error
}

type ListAllNodeVersions200JSONResponse struct {
	// Page Current page number
	Page *int `json:"page,omitempty"`

	// PageSize Maximum number of node versions per page. Maximum is 100.
	PageSize *int `json:"pageSize,omitempty"`

	// Total Total number of node versions available
	Total *int `json:"total,omitempty"`

	// TotalPages Total number of pages available
	TotalPages *int           `json:"totalPages,omitempty"`
	Versions   *[]NodeVersion `json:"versions,omitempty"`
}

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

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

type ListAllNodeVersions400JSONResponse ErrorResponse

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

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

type ListAllNodeVersions403JSONResponse ErrorResponse

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

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

type ListAllNodeVersions500JSONResponse ErrorResponse

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

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

type GetWorkflowResultRequestObject struct {
	WorkflowResultId string `json:"workflowResultId"`
}

type GetWorkflowResultResponseObject interface {
	VisitGetWorkflowResultResponse(w http.ResponseWriter) error
}

type GetWorkflowResult200JSONResponse ActionJobResult

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

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

type GetWorkflowResult404JSONResponse ErrorResponse

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

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

type GetWorkflowResult500JSONResponse ErrorResponse

func (response GetWorkflowResult500JSONResponse) VisitGetWorkflowResultResponse(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 {
	// Admin Update Node Version Status
	// (PUT /admin/nodes/{nodeId}/versions/{versionNumber})
	AdminUpdateNodeVersion(ctx context.Context, request AdminUpdateNodeVersionRequestObject) (AdminUpdateNodeVersionResponseObject, error)
	// Retrieve all distinct branches for a given repo
	// (GET /branch)
	GetBranch(ctx context.Context, request GetBranchRequestObject) (GetBranchResponseObject, error)
	// trigger comfy nodes backfill
	// (POST /comfy-nodes/backfill)
	ComfyNodesBackfill(ctx context.Context, request ComfyNodesBackfillRequestObject) (ComfyNodesBackfillResponseObject, error)
	// Retrieve CI data for a given commit
	// (GET /gitcommit)
	GetGitcommit(ctx context.Context, request GetGitcommitRequestObject) (GetGitcommitResponseObject, error)
	// Retrieve a summary of git commits
	// (GET /gitcommitsummary)
	GetGitcommitsummary(ctx context.Context, request GetGitcommitsummaryRequestObject) (GetGitcommitsummaryResponseObject, error)
	// Retrieves a list of nodes
	// (GET /nodes)
	ListAllNodes(ctx context.Context, request ListAllNodesRequestObject) (ListAllNodesResponseObject, error)
	// Reindex all nodes for searching.
	// (POST /nodes/reindex)
	ReindexNodes(ctx context.Context, request ReindexNodesRequestObject) (ReindexNodesResponseObject, error)
	// Retrieves a list of nodes
	// (GET /nodes/search)
	SearchNodes(ctx context.Context, request SearchNodesRequestObject) (SearchNodesResponseObject, error)
	// Retrieve a specific node by ID
	// (GET /nodes/{nodeId})
	GetNode(ctx context.Context, request GetNodeRequestObject) (GetNodeResponseObject, error)
	// Returns a node version to be installed.
	// (GET /nodes/{nodeId}/install)
	InstallNode(ctx context.Context, request InstallNodeRequestObject) (InstallNodeResponseObject, error)
	// Add review to a specific version of a node
	// (POST /nodes/{nodeId}/reviews)
	PostNodeReview(ctx context.Context, request PostNodeReviewRequestObject) (PostNodeReviewResponseObject, error)
	// List all versions of a node
	// (GET /nodes/{nodeId}/versions)
	ListNodeVersions(ctx context.Context, request ListNodeVersionsRequestObject) (ListNodeVersionsResponseObject, error)
	// Retrieve a specific version of a node
	// (GET /nodes/{nodeId}/versions/{versionId})
	GetNodeVersion(ctx context.Context, request GetNodeVersionRequestObject) (GetNodeVersionResponseObject, error)
	// create comfy-nodes for certain node
	// (POST /nodes/{nodeId}/versions/{version}/comfy-nodes)
	CreateComfyNodes(ctx context.Context, request CreateComfyNodesRequestObject) (CreateComfyNodesResponseObject, error)
	// get specify comfy-node based on its id
	// (GET /nodes/{nodeId}/versions/{version}/comfy-nodes/{comfyNodeId})
	GetComfyNode(ctx context.Context, request GetComfyNodeRequestObject) (GetComfyNodeResponseObject, error)
	// Retrieve all publishers
	// (GET /publishers)
	ListPublishers(ctx context.Context, request ListPublishersRequestObject) (ListPublishersResponseObject, error)
	// Create a new publisher
	// (POST /publishers)
	CreatePublisher(ctx context.Context, request CreatePublisherRequestObject) (CreatePublisherResponseObject, error)
	// Validate if a publisher username is available
	// (GET /publishers/validate)
	ValidatePublisher(ctx context.Context, request ValidatePublisherRequestObject) (ValidatePublisherResponseObject, error)
	// Delete a publisher
	// (DELETE /publishers/{publisherId})
	DeletePublisher(ctx context.Context, request DeletePublisherRequestObject) (DeletePublisherResponseObject, error)
	// Retrieve a publisher by ID
	// (GET /publishers/{publisherId})
	GetPublisher(ctx context.Context, request GetPublisherRequestObject) (GetPublisherResponseObject, error)
	// Update a publisher
	// (PUT /publishers/{publisherId})
	UpdatePublisher(ctx context.Context, request UpdatePublisherRequestObject) (UpdatePublisherResponseObject, error)
	// Ban a publisher
	// (POST /publishers/{publisherId}/ban)
	BanPublisher(ctx context.Context, request BanPublisherRequestObject) (BanPublisherResponseObject, error)
	// Retrieve all nodes
	// (GET /publishers/{publisherId}/nodes)
	ListNodesForPublisher(ctx context.Context, request ListNodesForPublisherRequestObject) (ListNodesForPublisherResponseObject, error)
	// Create a new custom node
	// (POST /publishers/{publisherId}/nodes)
	CreateNode(ctx context.Context, request CreateNodeRequestObject) (CreateNodeResponseObject, error)
	// Delete a specific node
	// (DELETE /publishers/{publisherId}/nodes/{nodeId})
	DeleteNode(ctx context.Context, request DeleteNodeRequestObject) (DeleteNodeResponseObject, error)
	// Update a specific node
	// (PUT /publishers/{publisherId}/nodes/{nodeId})
	UpdateNode(ctx context.Context, request UpdateNodeRequestObject) (UpdateNodeResponseObject, error)
	// Ban a publisher's Node
	// (POST /publishers/{publisherId}/nodes/{nodeId}/ban)
	BanPublisherNode(ctx context.Context, request BanPublisherNodeRequestObject) (BanPublisherNodeResponseObject, error)
	// Retrieve permissions the user has for a given publisher
	// (GET /publishers/{publisherId}/nodes/{nodeId}/permissions)
	GetPermissionOnPublisherNodes(ctx context.Context, request GetPermissionOnPublisherNodesRequestObject) (GetPermissionOnPublisherNodesResponseObject, error)
	// Publish a new version of a node
	// (POST /publishers/{publisherId}/nodes/{nodeId}/versions)
	PublishNodeVersion(ctx context.Context, request PublishNodeVersionRequestObject) (PublishNodeVersionResponseObject, error)
	// Unpublish (delete) a specific version of a node
	// (DELETE /publishers/{publisherId}/nodes/{nodeId}/versions/{versionId})
	DeleteNodeVersion(ctx context.Context, request DeleteNodeVersionRequestObject) (DeleteNodeVersionResponseObject, error)
	// Update changelog and deprecation status of a node version
	// (PUT /publishers/{publisherId}/nodes/{nodeId}/versions/{versionId})
	UpdateNodeVersion(ctx context.Context, request UpdateNodeVersionRequestObject) (UpdateNodeVersionResponseObject, error)
	// Retrieve permissions the user has for a given publisher
	// (GET /publishers/{publisherId}/permissions)
	GetPermissionOnPublisher(ctx context.Context, request GetPermissionOnPublisherRequestObject) (GetPermissionOnPublisherResponseObject, error)
	// Retrieve all personal access tokens for a publisher
	// (GET /publishers/{publisherId}/tokens)
	ListPersonalAccessTokens(ctx context.Context, request ListPersonalAccessTokensRequestObject) (ListPersonalAccessTokensResponseObject, error)
	// Create a new personal access token
	// (POST /publishers/{publisherId}/tokens)
	CreatePersonalAccessToken(ctx context.Context, request CreatePersonalAccessTokenRequestObject) (CreatePersonalAccessTokenResponseObject, error)
	// Delete a specific personal access token
	// (DELETE /publishers/{publisherId}/tokens/{tokenId})
	DeletePersonalAccessToken(ctx context.Context, request DeletePersonalAccessTokenRequestObject) (DeletePersonalAccessTokenResponseObject, error)
	// Security Scan
	// (GET /security-scan)
	SecurityScan(ctx context.Context, request SecurityScanRequestObject) (SecurityScanResponseObject, error)
	// Receive artifacts (output files) from the Hanzo Studio GitHub Action
	// (POST /upload-artifact)
	PostUploadArtifact(ctx context.Context, request PostUploadArtifactRequestObject) (PostUploadArtifactResponseObject, error)
	// Get information about the calling user.
	// (GET /users)
	GetUser(ctx context.Context, request GetUserRequestObject) (GetUserResponseObject, error)
	// Retrieve all publishers for a given user
	// (GET /users/publishers/)
	ListPublishersForUser(ctx context.Context, request ListPublishersForUserRequestObject) (ListPublishersForUserResponseObject, error)
	// List all node versions given some filters.
	// (GET /versions)
	ListAllNodeVersions(ctx context.Context, request ListAllNodeVersionsRequestObject) (ListAllNodeVersionsResponseObject, error)
	// Retrieve a specific commit by ID
	// (GET /workflowresult/{workflowResultId})
	GetWorkflowResult(ctx context.Context, request GetWorkflowResultRequestObject) (GetWorkflowResultResponseObject, error)
}

type StrictHandlerFunc = strictecho.StrictEchoHandlerFunc
type StrictMiddlewareFunc = strictecho.StrictEchoMiddlewareFunc

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
}

// AdminUpdateNodeVersion operation middleware
func (sh *strictHandler) AdminUpdateNodeVersion(ctx echo.Context, nodeId string, versionNumber string) error {
	var request AdminUpdateNodeVersionRequestObject

	request.NodeId = nodeId
	request.VersionNumber = versionNumber

	var body AdminUpdateNodeVersionJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.AdminUpdateNodeVersion(ctx.Request().Context(), request.(AdminUpdateNodeVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "AdminUpdateNodeVersion")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(AdminUpdateNodeVersionResponseObject); ok {
		return validResponse.VisitAdminUpdateNodeVersionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetBranch operation middleware
func (sh *strictHandler) GetBranch(ctx echo.Context, params GetBranchParams) error {
	var request GetBranchRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetBranch(ctx.Request().Context(), request.(GetBranchRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetBranch")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetBranchResponseObject); ok {
		return validResponse.VisitGetBranchResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ComfyNodesBackfill operation middleware
func (sh *strictHandler) ComfyNodesBackfill(ctx echo.Context, params ComfyNodesBackfillParams) error {
	var request ComfyNodesBackfillRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ComfyNodesBackfill(ctx.Request().Context(), request.(ComfyNodesBackfillRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ComfyNodesBackfill")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ComfyNodesBackfillResponseObject); ok {
		return validResponse.VisitComfyNodesBackfillResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetGitcommit operation middleware
func (sh *strictHandler) GetGitcommit(ctx echo.Context, params GetGitcommitParams) error {
	var request GetGitcommitRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetGitcommit(ctx.Request().Context(), request.(GetGitcommitRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetGitcommit")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetGitcommitResponseObject); ok {
		return validResponse.VisitGetGitcommitResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetGitcommitsummary operation middleware
func (sh *strictHandler) GetGitcommitsummary(ctx echo.Context, params GetGitcommitsummaryParams) error {
	var request GetGitcommitsummaryRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetGitcommitsummary(ctx.Request().Context(), request.(GetGitcommitsummaryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetGitcommitsummary")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetGitcommitsummaryResponseObject); ok {
		return validResponse.VisitGetGitcommitsummaryResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListAllNodes operation middleware
func (sh *strictHandler) ListAllNodes(ctx echo.Context, params ListAllNodesParams) error {
	var request ListAllNodesRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListAllNodes(ctx.Request().Context(), request.(ListAllNodesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListAllNodes")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListAllNodesResponseObject); ok {
		return validResponse.VisitListAllNodesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ReindexNodes operation middleware
func (sh *strictHandler) ReindexNodes(ctx echo.Context, params ReindexNodesParams) error {
	var request ReindexNodesRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ReindexNodes(ctx.Request().Context(), request.(ReindexNodesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ReindexNodes")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ReindexNodesResponseObject); ok {
		return validResponse.VisitReindexNodesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// SearchNodes operation middleware
func (sh *strictHandler) SearchNodes(ctx echo.Context, params SearchNodesParams) error {
	var request SearchNodesRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.SearchNodes(ctx.Request().Context(), request.(SearchNodesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "SearchNodes")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(SearchNodesResponseObject); ok {
		return validResponse.VisitSearchNodesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetNode operation middleware
func (sh *strictHandler) GetNode(ctx echo.Context, nodeId string) error {
	var request GetNodeRequestObject

	request.NodeId = nodeId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetNode(ctx.Request().Context(), request.(GetNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetNodeResponseObject); ok {
		return validResponse.VisitGetNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// InstallNode operation middleware
func (sh *strictHandler) InstallNode(ctx echo.Context, nodeId string, params InstallNodeParams) error {
	var request InstallNodeRequestObject

	request.NodeId = nodeId
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.InstallNode(ctx.Request().Context(), request.(InstallNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "InstallNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(InstallNodeResponseObject); ok {
		return validResponse.VisitInstallNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// PostNodeReview operation middleware
func (sh *strictHandler) PostNodeReview(ctx echo.Context, nodeId string, params PostNodeReviewParams) error {
	var request PostNodeReviewRequestObject

	request.NodeId = nodeId
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.PostNodeReview(ctx.Request().Context(), request.(PostNodeReviewRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PostNodeReview")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(PostNodeReviewResponseObject); ok {
		return validResponse.VisitPostNodeReviewResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListNodeVersions operation middleware
func (sh *strictHandler) ListNodeVersions(ctx echo.Context, nodeId string, params ListNodeVersionsParams) error {
	var request ListNodeVersionsRequestObject

	request.NodeId = nodeId
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListNodeVersions(ctx.Request().Context(), request.(ListNodeVersionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListNodeVersions")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListNodeVersionsResponseObject); ok {
		return validResponse.VisitListNodeVersionsResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetNodeVersion operation middleware
func (sh *strictHandler) GetNodeVersion(ctx echo.Context, nodeId string, versionId string) error {
	var request GetNodeVersionRequestObject

	request.NodeId = nodeId
	request.VersionId = versionId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeVersion(ctx.Request().Context(), request.(GetNodeVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeVersion")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetNodeVersionResponseObject); ok {
		return validResponse.VisitGetNodeVersionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateComfyNodes operation middleware
func (sh *strictHandler) CreateComfyNodes(ctx echo.Context, nodeId string, version string) error {
	var request CreateComfyNodesRequestObject

	request.NodeId = nodeId
	request.Version = version

	var body CreateComfyNodesJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.CreateComfyNodes(ctx.Request().Context(), request.(CreateComfyNodesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateComfyNodes")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CreateComfyNodesResponseObject); ok {
		return validResponse.VisitCreateComfyNodesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetComfyNode operation middleware
func (sh *strictHandler) GetComfyNode(ctx echo.Context, nodeId string, version string, comfyNodeId string) error {
	var request GetComfyNodeRequestObject

	request.NodeId = nodeId
	request.Version = version
	request.ComfyNodeId = comfyNodeId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetComfyNode(ctx.Request().Context(), request.(GetComfyNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetComfyNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetComfyNodeResponseObject); ok {
		return validResponse.VisitGetComfyNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListPublishers operation middleware
func (sh *strictHandler) ListPublishers(ctx echo.Context) error {
	var request ListPublishersRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListPublishers(ctx.Request().Context(), request.(ListPublishersRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListPublishers")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListPublishersResponseObject); ok {
		return validResponse.VisitListPublishersResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreatePublisher operation middleware
func (sh *strictHandler) CreatePublisher(ctx echo.Context) error {
	var request CreatePublisherRequestObject

	var body CreatePublisherJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.CreatePublisher(ctx.Request().Context(), request.(CreatePublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreatePublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CreatePublisherResponseObject); ok {
		return validResponse.VisitCreatePublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ValidatePublisher operation middleware
func (sh *strictHandler) ValidatePublisher(ctx echo.Context, params ValidatePublisherParams) error {
	var request ValidatePublisherRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ValidatePublisher(ctx.Request().Context(), request.(ValidatePublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ValidatePublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ValidatePublisherResponseObject); ok {
		return validResponse.VisitValidatePublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeletePublisher operation middleware
func (sh *strictHandler) DeletePublisher(ctx echo.Context, publisherId string) error {
	var request DeletePublisherRequestObject

	request.PublisherId = publisherId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.DeletePublisher(ctx.Request().Context(), request.(DeletePublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeletePublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(DeletePublisherResponseObject); ok {
		return validResponse.VisitDeletePublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetPublisher operation middleware
func (sh *strictHandler) GetPublisher(ctx echo.Context, publisherId string) error {
	var request GetPublisherRequestObject

	request.PublisherId = publisherId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetPublisher(ctx.Request().Context(), request.(GetPublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetPublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetPublisherResponseObject); ok {
		return validResponse.VisitGetPublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdatePublisher operation middleware
func (sh *strictHandler) UpdatePublisher(ctx echo.Context, publisherId string) error {
	var request UpdatePublisherRequestObject

	request.PublisherId = publisherId

	var body UpdatePublisherJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.UpdatePublisher(ctx.Request().Context(), request.(UpdatePublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdatePublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(UpdatePublisherResponseObject); ok {
		return validResponse.VisitUpdatePublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// BanPublisher operation middleware
func (sh *strictHandler) BanPublisher(ctx echo.Context, publisherId string) error {
	var request BanPublisherRequestObject

	request.PublisherId = publisherId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.BanPublisher(ctx.Request().Context(), request.(BanPublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "BanPublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(BanPublisherResponseObject); ok {
		return validResponse.VisitBanPublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListNodesForPublisher operation middleware
func (sh *strictHandler) ListNodesForPublisher(ctx echo.Context, publisherId string, params ListNodesForPublisherParams) error {
	var request ListNodesForPublisherRequestObject

	request.PublisherId = publisherId
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListNodesForPublisher(ctx.Request().Context(), request.(ListNodesForPublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListNodesForPublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListNodesForPublisherResponseObject); ok {
		return validResponse.VisitListNodesForPublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateNode operation middleware
func (sh *strictHandler) CreateNode(ctx echo.Context, publisherId string) error {
	var request CreateNodeRequestObject

	request.PublisherId = publisherId

	var body CreateNodeJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.CreateNode(ctx.Request().Context(), request.(CreateNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CreateNodeResponseObject); ok {
		return validResponse.VisitCreateNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteNode operation middleware
func (sh *strictHandler) DeleteNode(ctx echo.Context, publisherId string, nodeId string) error {
	var request DeleteNodeRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteNode(ctx.Request().Context(), request.(DeleteNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(DeleteNodeResponseObject); ok {
		return validResponse.VisitDeleteNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateNode operation middleware
func (sh *strictHandler) UpdateNode(ctx echo.Context, publisherId string, nodeId string) error {
	var request UpdateNodeRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId

	var body UpdateNodeJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateNode(ctx.Request().Context(), request.(UpdateNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(UpdateNodeResponseObject); ok {
		return validResponse.VisitUpdateNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// BanPublisherNode operation middleware
func (sh *strictHandler) BanPublisherNode(ctx echo.Context, publisherId string, nodeId string) error {
	var request BanPublisherNodeRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.BanPublisherNode(ctx.Request().Context(), request.(BanPublisherNodeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "BanPublisherNode")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(BanPublisherNodeResponseObject); ok {
		return validResponse.VisitBanPublisherNodeResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetPermissionOnPublisherNodes operation middleware
func (sh *strictHandler) GetPermissionOnPublisherNodes(ctx echo.Context, publisherId string, nodeId string) error {
	var request GetPermissionOnPublisherNodesRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetPermissionOnPublisherNodes(ctx.Request().Context(), request.(GetPermissionOnPublisherNodesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetPermissionOnPublisherNodes")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetPermissionOnPublisherNodesResponseObject); ok {
		return validResponse.VisitGetPermissionOnPublisherNodesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// PublishNodeVersion operation middleware
func (sh *strictHandler) PublishNodeVersion(ctx echo.Context, publisherId string, nodeId string) error {
	var request PublishNodeVersionRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId

	var body PublishNodeVersionJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.PublishNodeVersion(ctx.Request().Context(), request.(PublishNodeVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PublishNodeVersion")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(PublishNodeVersionResponseObject); ok {
		return validResponse.VisitPublishNodeVersionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteNodeVersion operation middleware
func (sh *strictHandler) DeleteNodeVersion(ctx echo.Context, publisherId string, nodeId string, versionId string) error {
	var request DeleteNodeVersionRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId
	request.VersionId = versionId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteNodeVersion(ctx.Request().Context(), request.(DeleteNodeVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteNodeVersion")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(DeleteNodeVersionResponseObject); ok {
		return validResponse.VisitDeleteNodeVersionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateNodeVersion operation middleware
func (sh *strictHandler) UpdateNodeVersion(ctx echo.Context, publisherId string, nodeId string, versionId string) error {
	var request UpdateNodeVersionRequestObject

	request.PublisherId = publisherId
	request.NodeId = nodeId
	request.VersionId = versionId

	var body UpdateNodeVersionJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateNodeVersion(ctx.Request().Context(), request.(UpdateNodeVersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateNodeVersion")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(UpdateNodeVersionResponseObject); ok {
		return validResponse.VisitUpdateNodeVersionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetPermissionOnPublisher operation middleware
func (sh *strictHandler) GetPermissionOnPublisher(ctx echo.Context, publisherId string) error {
	var request GetPermissionOnPublisherRequestObject

	request.PublisherId = publisherId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetPermissionOnPublisher(ctx.Request().Context(), request.(GetPermissionOnPublisherRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetPermissionOnPublisher")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetPermissionOnPublisherResponseObject); ok {
		return validResponse.VisitGetPermissionOnPublisherResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListPersonalAccessTokens operation middleware
func (sh *strictHandler) ListPersonalAccessTokens(ctx echo.Context, publisherId string) error {
	var request ListPersonalAccessTokensRequestObject

	request.PublisherId = publisherId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListPersonalAccessTokens(ctx.Request().Context(), request.(ListPersonalAccessTokensRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListPersonalAccessTokens")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListPersonalAccessTokensResponseObject); ok {
		return validResponse.VisitListPersonalAccessTokensResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreatePersonalAccessToken operation middleware
func (sh *strictHandler) CreatePersonalAccessToken(ctx echo.Context, publisherId string) error {
	var request CreatePersonalAccessTokenRequestObject

	request.PublisherId = publisherId

	var body CreatePersonalAccessTokenJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.CreatePersonalAccessToken(ctx.Request().Context(), request.(CreatePersonalAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreatePersonalAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CreatePersonalAccessTokenResponseObject); ok {
		return validResponse.VisitCreatePersonalAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeletePersonalAccessToken operation middleware
func (sh *strictHandler) DeletePersonalAccessToken(ctx echo.Context, publisherId string, tokenId string) error {
	var request DeletePersonalAccessTokenRequestObject

	request.PublisherId = publisherId
	request.TokenId = tokenId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.DeletePersonalAccessToken(ctx.Request().Context(), request.(DeletePersonalAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeletePersonalAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(DeletePersonalAccessTokenResponseObject); ok {
		return validResponse.VisitDeletePersonalAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// SecurityScan operation middleware
func (sh *strictHandler) SecurityScan(ctx echo.Context, params SecurityScanParams) error {
	var request SecurityScanRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.SecurityScan(ctx.Request().Context(), request.(SecurityScanRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "SecurityScan")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(SecurityScanResponseObject); ok {
		return validResponse.VisitSecurityScanResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// PostUploadArtifact operation middleware
func (sh *strictHandler) PostUploadArtifact(ctx echo.Context) error {
	var request PostUploadArtifactRequestObject

	var body PostUploadArtifactJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.PostUploadArtifact(ctx.Request().Context(), request.(PostUploadArtifactRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PostUploadArtifact")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(PostUploadArtifactResponseObject); ok {
		return validResponse.VisitPostUploadArtifactResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetUser operation middleware
func (sh *strictHandler) GetUser(ctx echo.Context) error {
	var request GetUserRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetUser(ctx.Request().Context(), request.(GetUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetUserResponseObject); ok {
		return validResponse.VisitGetUserResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListPublishersForUser operation middleware
func (sh *strictHandler) ListPublishersForUser(ctx echo.Context) error {
	var request ListPublishersForUserRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListPublishersForUser(ctx.Request().Context(), request.(ListPublishersForUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListPublishersForUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListPublishersForUserResponseObject); ok {
		return validResponse.VisitListPublishersForUserResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListAllNodeVersions operation middleware
func (sh *strictHandler) ListAllNodeVersions(ctx echo.Context, params ListAllNodeVersionsParams) error {
	var request ListAllNodeVersionsRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ListAllNodeVersions(ctx.Request().Context(), request.(ListAllNodeVersionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListAllNodeVersions")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ListAllNodeVersionsResponseObject); ok {
		return validResponse.VisitListAllNodeVersionsResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetWorkflowResult operation middleware
func (sh *strictHandler) GetWorkflowResult(ctx echo.Context, workflowResultId string) error {
	var request GetWorkflowResultRequestObject

	request.WorkflowResultId = workflowResultId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetWorkflowResult(ctx.Request().Context(), request.(GetWorkflowResultRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetWorkflowResult")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetWorkflowResultResponseObject); ok {
		return validResponse.VisitGetWorkflowResultResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

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

	"H4sIAAAAAAAC/+x9fW/bONL4VyH0O2Bb/Bw73est7sl/btL2crdJg6TpYq/t46Ml2mYrkTqSSuot8t0f",
	"8E2iJFKWnTena2CxbU1qOCRnhjPDGc73KKZZTgkigkcH3yMeL1AG1V/HscCU/JNOzxEvUiF/yhnNERMY",
	"qQ5QdZh8odMJTuQPCeIxw7n8NTqIjhNEBJ5hxACdAbFA4AudArHAHDAFEUxRSsmcA0GjQSSWOYoOIi4Y",
	"JvPoZmDBs4L0BM8Ksg74Qiwoa8N9v0BAt1m4Mc0yLLwwruaTKwazAJQrxOAcgQ/n4xNQcJSA6dKuQwUN",
	"E4HmiElwUwZJvJgQmKE2xFOYoXKmKEVXkAgwxwLor3zoxTSbLdUCzlI4534sVSe1dqrTELwezofgP3t7",
	"Kb3ek5P7TwB0hsVkAfnCD1a2rF5AA8a3vxLI8VFvEBniHM6RH45p7A1M4CwA6ZLgb0A2cwGzHFwvEHFA",
	"gmvIQQYTFA2iGWUZFHqDf3np3e+4SODkCjGu4DeHO7w8GgPTqsjHhzAiSQe2iCQKWZcBIQewMY1hP3Tn",
	"WEwYyql/LNnCsaBsCRQBe5D1bfMlwf8tEMAVN88oK5HVnOyiVxTYuxBSCgmG53PEJgVHAcaWLeB6QYHp",
	"ihI71NAHNIPxAhM04QJq8fgXhmbRQfT/RpXUHBmROTrRnS9U35tBJEUlFJjMJ3zJBfIIiXe2B9A9gruc",
	"I/i1Q9DI5v5SJmcTUmTT0BLlRZoChv5bIC6A6ehDaSkWlISp92z5nrJ4sZKA86WQ/W4PiAvIujhXtd8h",
	"N0iaKFYSxW+UfZ2l9Pq8IBf6A/UplQfDZIZTtArAhe77Rna9GUTXBl6PQ8J2bS/WTfkLnX5BsZCAD+Ux",
	"cEoT1D7nYyjQnLKlh3mPgW2UopAhNTChCQKYgxRzgZKBJkrJ1XNGi1ySu+zBh+EjS7ZP1pMW8hMfwATl",
	"DEkkfSoESbBs4gDPaphXHw3BUfl3jTaADIEFThJEANbC//LYmcuU0hRBosd2RmsO/ophNAPOb3bf5Cg/",
	"cTAriFKAYIrFElAG8oLllCPvsqFvOWI4Q0TAdI15up8NAC8UNQBBQbyAZI64HJahjF7B1D9Di2Q3JSIi",
	"2HIvp5iIclpyFPQNxYWoiMY7NUzyQkzkzx4F5gjNMJHzkp1ADhnMkECM+wDRQkhImE8kYXo2RE8LXMG0",
	"UCDVoklyxTOAYLwAGoJcOKiIW+KLBcoUYu3FMb9AxuBS/pshUTCiOJf7F4zbFdMjcUXdcQqZJAFMSpb2",
	"846BH1iqixzFkmW4GkB1kqPZkXJGkyKuTo/AfnSKjsOUFsmrAqfJMZnRtiCZyibD1y3sUypXW5NS+5Rg",
	"VI4W+tY2V+daD7RfM6b1/zqSCRIQp9x3Wmt2BLoHSgAm+pyQ5AyntBCa2iVcyTkLTMwWMsRpeqVIyUs0",
	"1UyaNBNUa8cgThFkAJIExJTEmCOfMFHI9NxHtSDniOeUcM8xgOx6tdWkCsn2MFKVwEyK348GRPXBZw8W",
	"b7E4VMr0RZFlUJ86DbvzDiy3TlNLAtIdnFOtreHfs1EUxo04sjUMRisoE14tI0wSrGn4rLagnkOzTmoZ",
	"zJWsaOqrggI9CsghdqVutZ2lWuWfynqmVAIF2lMqXi+CrmnkbbUmLyYxzGGMhUe1eU8FTMHh2SWgGi1j",
	"C3glb4L515WwZCdgO/WBOs+Lif7Rt3Jvzy6VFB8CNB+C0w/HR8dj8B7xFIJ//X3ff5JigWE6ifPCpyOo",
	"RjVjeAVxCqcpAlM0o4b+pbasdGg+7AIuZxmGrtbgNuC9NpCFLi2gTYBbM2+1Tt21XRnKKFuuJAPdrc/+",
	"Ux62iiQFtNjR9NYUcTktiCjAr5gU38DP+8P9l17zC+eTGUPojwCV5TgHut1oCj4g0jJVlteEI4Z9ysd7",
	"aXbpRrmUxlaFc3film99nOw3TKqDoC1DgzaL8nlZo8VRuf2MXdfg2+30mqQUJgHfmtZH5Chlx8CQjmGJ",
	"Y9+GX57/KsWtYyDIfsO+bhbl/GgZT6umn0qjQbhU2GWqyk36YLrKj3GMjCLhoSsoFnY+vx4fvj69eA2k",
	"OWxNKjPHyqnkxS98RCaY5ylc1o7K4DTzYppivtCaY9cMz8qOUrFRvNft+jX86UfAaKtKR7LT7LPxKxal",
	"n2NCbpbrkVC6gtZsg/4TedDrLiuXVBh/c19NN8T0F+VkECkyqUNWv45jga+kKlD9dIRSJJR/qPrtFSQE",
	"JY6uWeHgUmxbP1A2cEo9W2xUU7kK1lKWqoomXsytIPYqdwxBgZKxCNAtFEjp9MpRJZfY+r2kPmQ+HvbU",
	"iZT3A5EEkdgrlcfKipWzkGLe7Qus1t40B/tbLms4XqoVazhf/F4VI0ovmYdSP77TNvo7ki4/A8M79ov6",
	"UA4Jh6VoW+SEXFObSdj+zGrotMWzDEEe0hB0W+kjMyysSdaLTqe+Ue5ROb0BmNE0pddKB0EZJALHthsm",
	"8yE4KbgA03JhXGddT6O0PfWGLKg11kRCraUuGWpNRkB4Ws4QSSRmnqY3KZzPV4uVy1zy57l2p68lY5Se",
	"YpuNaT+VC+0KBSN9hut6Pn9bILFArAZrJev5tucMMS4NynEcI87f06/IJ0nDMq/Gr34BKCTQTcVfhwPW",
	"+nOGYAwyaSmUfh2PH0UhIZUuIqSQTEAR8MSu57UunR19rrj82s65kdRD0HQNKJyH4BASyYIQcJzlac1L",
	"5D+67SZ27JQeLDebD6DafTug7AG0M1IuZiEB673zD+mlK1cl601NfgIq1bs7IaJbqNt210uEhuBY/MQB",
	"/IqVPxyq+0m5hUNwsaBFmsiNS+k1YjEM0FtK57RTaSwH+4kD2Tlku04R61QRTBeroFdzcLWCXsrzCbJ6",
	"b1NnsBTePiZpwWI0ieXha6+gNzxLSzSck7TIc8qEF+g1mnIsUE+fcnOOLeK9BbGYHfC7/mkaMIRkixUI",
	"6vbbt38tePYGvddCXsrO3cvRProbTeXB3fi9Q3mvj992V2dBU0Y1AZgkTEotvdCYq+XZzKDuAWOFN3cV",
	"AN/qulfDrelLY3oirWzPjbpje1ub21xJ3/5EM4AU4D6HmqLDeFL4lHm1w7HU4vstyJMgBMzHSYZJj1ta",
	"xa4LyAGUH4Cc4Sucorq659hFmI/znNGrXjfdWhRwAM0nfpD3QLTtgAhHKLQaLwRkWmtvNb1Rupqv5ZBK",
	"PUd4xYaU9iguGBbLCynHNIm8QpAhNi40t0zVv95Yyv3nb++jgQ6MVMujWqvJLoTIo5sb5aPWl54CC8mR",
	"+l4UjM+OI8ewil4M9010EIE5jg6ivw73hz9Hg0gyq8JmpPZ7pKINRt/lH8fJzchA4KPv5m+nyn10owi+",
	"8ChDSg1ToDiIIbFbDaC+/rfO4qiMVKLkOJFHvvxE2y2uf0QiWF6vH3z8HkkaVkhHllAijWvkXvoJViCz",
	"etB7iHoB1aa4FrzPujPi4hVNlDstplJnVwsE8zzF+pp59MVYzRWoutjYKsu8zUn1q1W5KuoHfXmr0P55",
	"f3+t6fd27d60bgg/2NgsRTUJ4IUyCGZFmiq97uUdolK/pfYg8womNn5tADC5gilOTIBIAgUcaoRe+A41",
	"faGA/0CJ7vTXh8P6DWVTFVSkR375cCPbzSNUgBktiJr73x5yx46JkGZPCjhiV4jpoIWarFYCx5XSHz9L",
	"Ti/vtrXQAlpqAUmtwE7LsKV1SX+08+XRZznCyIRPH3yP5kj4zGtpx3IA09TEBCCtKUAwx1eIKG98W4i+",
	"ReKVjctuyE1/6KxUyGY4FYiBqfLrK6n43wKxZSUWZceJia4Ni8QEzaAK2NfRdJBQssxowUfqQLo89oiX",
	"z7eUHY04H7NOt7sAaNPJmADVW9oz5RgVuzQ3Lqdemu5NeyVxnSPBMJJHZ6qusAUmsQhTg/p6pNZ+Tx/i",
	"Uxh/neFUaaE51Y7AOr2UMVT8le3rP3AbFJHBbxPjwfYQwIv99gWjZ689q2exqAKld3J8fTm+LVK0pGSz",
	"mybpQ8ezTiuCsyKyokYjJOdYmECjPnKSFYQPwBc61f83Ufx8oNxyroHIAeScxlgpDddYLEo+0qN55erb",
	"EpceorWZQaLELBLxQtGQZN2QrNX9lTbbqb32iMuoRLtE5PBYjx0W8yWAC504sDYGxBMGvjYW9sNTfd6s",
	"iYKJnzNIlPSzNhZldtOa4+eSxkz8haCAGREeGibXzg+fDPWI0EF3sIc68+SomMRpkShHuUKoa/QL/Mc6",
	"Unxwa0Wita+Prjd8sbmGdc2hSyo2kxQ9TmVBBUy1JfludgbntZhHZ0F76R+6EcgJQkwkj/cXdkFVRV8B",
	"3bWyYnnLVU+M4KzLdCdCtFu0A17FPcyxMND4wNC5knhK2x442TZ6IWwmWrdEt5j01JmddLOGXHGwewAu",
	"6BKAGyOnv99M+P7owu9uxU7shJtj1F/2tCLV71X4XDg+lXJHE4eYDHdiLWj+dqsl6YzoX4nqejZVQKpo",
	"IaVU1B6SKYdzTJQaae8rTbJWzCjXWml548XbQuhXzMU4TbXKu0L6nDnM5YT36Hy3++Gw03I0PZLm6YKR",
	"krkC46ZY68kbaxUbj2y4fzK1wTUtEebElXj2VROHHtRc2QPKSg8jnGlpirmTQvDs+OId+Psv+y+AvnZ6",
	"HsCtyklw0eqXZRCMpLF2xYwhvrBPEMwYzdQpPIUcKfw5AjGMF3I2BAE8AzOY8uD2qfjb7sW7W1moCabF",
	"aCfwG86KzCF7vTMOEbQDmUve7SVNVYi3R4Lm3vSnw4IxRIR70nlxUPI3FIrfnE2ZOxAGVYrwbngSrW54",
	"vfTNkFhzfDFNyeu4SQZWWzXOk6D+ebqNnt/WSWGzLqtVqBwWrq9Cu9wYwiRB38Iet3PdoZfID5G/oIAr",
	"zZYCmM5piiGAAkBghEfIYTeFwm/SdgjiE0wUCrILu4KpFi3y8EkhF1Wwk0bsGjEE1PyQi10IJ0wmzQOq",
	"LvgG0be9Od0zPypF/qjQixkWQU2ZrvCRx7u+na3dEg0f07043FK61wsmdRe9q9KS4wiyeIHJfNhJ/rrb",
	"/StOF2qcnd7UHPlfaHlNWaIlhFyiar6BIc2OrWXrPYh2tlMwdgrGTsFoSVgbmLNSxkrGN48KSMgQcP0S",
	"Q1ymQbQcYqf6Ru9eAm4+33OYiG8X1IW8fVjhzxNZoaZNngTtN8kSTJfg+KgXA4ww4QLqy+0QIxj+Kt+e",
	"KR3T5ls1/wFAuMxK0aYvUL7rErNgzNqxBuPnmw3ytO4sts37Bkvsy0GrOWrB8QzQDAv1fpKzHE6ujk2w",
	"CLlVqxxE5yiGQpJEdBD976dPyf//9Gno/PGXe7jfuUVM2WlJJ2UqyeMaDI2jjxfxQj8fNoVJuTHaiTT8",
	"0wq5bTWlrLnjhr5KjpsiK4JMDPRqccfQFUbXPOxZOKNcneDnquM9Bs7WF6JSDrmAzFz4OZnjTlay1/4Q",
	"sFek7d3dwmyiSRyF315qnGBBFVYa/jYh8z6YJcgkV9scaOlEUiZAk7hOSeOeMwuWWdOr2cXGrTvqQfvu",
	"xTkL+H1HmrfpXhRcKfvVt70NylbsdzOq8Xun/V2PFPf6G9T9wODuzfJ1p+iZXIu+fjXWk3VZgXLzH/o8",
	"VAxnvBsPyuTbzdxqg+Tu2I3xcnMjQnpVIkrdCPYas/efRBJ+rsBV7cGzUypPisvL46PnAUW/nNVWmdUd",
	"mnL/M7FUAXbnXi9LuOvIW5NJbtyA8I44cHXV7cTfPkba1eMkXMUpLZKJeSPUpNJ17Xro2VHXMRx68bAX",
	"XPN8pU3iaueba3PUH9KwSb6WPzRwqfJZqiiIdnLVLpepM5fp5f7/PBwGr7+p/JA50NmfeuuQ/JFvpdjT",
	"VAUc4aQfHUZMQEyaQq+VGLCW2Bt9j+33K3SGige3Xv75ITkT3Ro1whVsLVrZCZofJ2myZO45EkaZWToc",
	"DqaQq/gzgAUH+lmGEH9Xd/+d9vtZ1e0hzNLaO4yrjFLnlbsKyy1LZttyjbgWBOKQi7Ptn28GnSpttWWb",
	"64s9SaKPqvXivgb2vGCiHu8JC9XtosJdRuWd5qVr4pfWI7queCjEQnWJO1L7A/XjU96b1cMFir+Wb7pU",
	"L0XZZ8TUCy8pQzBZAgG/Is/N6QczhsufK+9PPSMJCiy6oRtJ2/dBFaLG81t8XIbMtGNsWIHc93HKFbSf",
	"DHSwNqBigdg1rr3ItsL0a/CThW6WTGoSrExg24ZbzQxzLq2Yah30s2FqS7fzks9SstxCGGIGN2CqBwd+",
	"L/9uDJZEPSPaPuT086IdTOSxERzYt2SJl4G3s9T8Ncq+k+cB9eUKnSf9zIjeZpe8wtpQyLZ9LCLZf2iV",
	"p0pS25Heeg7oSng1w7CaGnfhoTH9Cs4Dktmja/MPTtpP4aGrNbT5HTeuexCYl6bg2jp9TaMYTSEJ3wW9",
	"gmQrFQr9Jiu42LkHn/yZ8wqSGg13U2szGdsfx8PfUPYwdPs082FukayyOuKGb+UzXU9Nutc8n6FUkG5/",
	"Z+/Lqy3TvKr7oYdzoXamjTwFx2n/t+ietP8yLrigWVfsZ/fRUcuZ6vak3Dv7DO4vn8qbAKcSoEKOmF02",
	"1NPy/tQDzb1HQ9gwf2Kk/ZhHzANlJv5g1vxOmjwtF8IqabLGwdrfofAjHrA7x8QajgnKwBNIWGg4KH7i",
	"oIzM7c0TOWLqOrMrCektEmdlt3d1NuFPlU9u9SgiJK8TLPoHNweDrpzV30VdrXEN5CxcvRyQ+6Dr7dzP",
	"Hal6gdRW/fW6KT1PWZOtswUxhcj7+O5UqdjNamfbyooTXVlxUtZkbL/GWS3Cx8goELWBQ8A+b5Si8OKW",
	"a7fhenA8J8hf8VfVplbNttxvkZtiv6iZ7m0ioDZ40vQUXZdwLDU/CZ/ULlCvnzZuJJvxdK2R+LWucG2m",
	"Ta72gz0pSduZWHEfmn9Ze4pUfPnMuNqeP66vzaKWUMSVnj1FKSXzVmXWB0vHfPysBQ8Ga9nMdpPtFj/f",
	"IF1z4K+XZ+xxSlJd8r4qvg1J4pTGtsXa6m95tcZuh9puVlPvx+Po+/Eoeguu78rk7crk7crktXyOftEm",
	"Z+fKtsajQevqP7dxu2x1aOzOUfKnc5Qo03FFCqSxssdKpr/XH2wzGffLtGzPat2wJOt+ANr9AMxa/pmu",
	"qsycn+65UU8F9W6o4TYfnymyASeQwDnK5HxXJot6qO4pRrH7mOe+vWylq9BTpAldp8syoMq7jRu6x/QO",
	"P6FQrZ1bbJP8VR/FdPN5j1N19F392S/B7oEFg9/2NfjevS9LL+CfPE5ML8IPFii2IevYEfd4rAM7vGng",
	"Z0WampOZqCqMtbcXlY0XU5IUsQAWIJAAvfU8dPuFHK9fBWpMxreoHTMI1rW2V+/rv0DbeHQ7hiRQdWbn",
	"dPkBalpbkgWKZhXb6BvAPcgEnsFYdD/VfKk6j23fu7op1vvlV8R0W70ydVvxGkTwaj65YjALQLlCqrgs",
	"zGhBlLn14Xx8Is3fxKbrs8LV6JxaI7q66ERzm+dtu2kRf0WibO8uMa07g+sFYroIFS2EJGlT4pshVQdX",
	"5dW0BlLPEk1SOueTecwn6qA98Nc0FQsgKDBlWIH8ZAjQfAjm/GA00jjsSbRGsik8FivIZJYquesbRzXV",
	"FlEXS2cFCcDMsJgsIF94F9K0OwU120Oa+p22T3gUVVfMC0LV/6pXOjfY6ydBZdun6Pfff/997+Rk7+jo",
	"/T/+cXBycnBx8e9PEXj28/6LX/Ze7O+92H+/v3+g/vv3cy8eRQLdK/xmzZwEujUaWp8jknTMwdYItvP4",
	"Qqf6gf1Lgr9VZR4l5LJWIybil5deCv9CpxOc+CRps/aDNFzNeD6kJSBTN39ScBRgaeV0ul5QYLqipAtm",
	"BuMFJvr955U+mBPd+UL1vRlE1EO575o15xtSwIeE5tKJ4tKS+Tywx4qiIOBIqgP6BkzCAGIBy1LYHLw9",
	"vFBM+ow/l3zqyoAAn+oug1DDzz6kcwS/dshE2byRQMzZxFR58sOVKpY5GFrloBzslmJBSZhDFCjVp7ww",
	"7LFR+VJQFi9WgpWd1oHLUE595VpqlbW9HxZkTd4KYKDKhHeIhKqM+N0IBX29sYrhfqPs6yyl1+eF87D7",
	"tfmx55lou3v9KW7MltqEUlyVa6vYvH681I+B1tFSP9SbCNfW2pHELuW36Ncj/AZWsSkXc7NAsserTt0o",
	"pB0jfGWEtdUX66WqOqqgsaqMxC3q9SsMysE5eOaKzudVoU+r+bzF4h/FFIxja0JFI7k1nbdsl9y8vHdP",
	"N98Kvmex3/1r3Wco2pXj3qwfJ/IWCc9r6Eo5gmlqH7YaOovneql6PnX5hrK7WNbdi5fb/uJl7SLRSMHg",
	"HWKveiem1vyKkicNn0gZu9Ppr0Tf8lQFKWuP5IOXPJHnwjKVP0j2i+6xAsrAbyZWVWbdimr3U2BWnfrl",
	"oxNqCeWoZnLlqxNdo1/gP9AalWbvNnjhdrVPS/R7lnOtXJLlwgDbE3PwYn9/eNsaq47X8wFrrQ4il+vv",
	"oLJODzVmRa2dx3tC0lcT9vEq/2xvCZ46uerDhdMMSb1PmGLbgZgrq9rrN0NH3+2/z9W/V7yt/1utc6/r",
	"syb8rXmJUOvA/6RTMxn/w/YZbqj0D3ibZYZ/erVvjBdRP0B4o7VvCUATScHS6CBaCJHzg9EI5niovKRD",
	"yubRzeeb/wsAAP//LQIeYVfGAAA=",
}

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