//go:build go1.22

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

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

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/oapi-codegen/runtime"
	openapi_types "github.com/oapi-codegen/runtime/types"
	externalRef0 "github.com/openshift-kni/oran-o2ims/internal/service/common/api/generated"
)

// Defines values for ClusterChangeNotificationNotificationEventType.
const (
	N0 ClusterChangeNotificationNotificationEventType = 0
	N1 ClusterChangeNotificationNotificationEventType = 1
	N2 ClusterChangeNotificationNotificationEventType = 2
)

// Valid indicates whether the value is a known member of the ClusterChangeNotificationNotificationEventType enum.
func (e ClusterChangeNotificationNotificationEventType) Valid() bool {
	switch e {
	case N0:
		return true
	case N1:
		return true
	case N2:
		return true
	default:
		return false
	}
}

// ClusterChangeNotification Information about an inventory change notification
type ClusterChangeNotification struct {
	// ConsumerSubscriptionId The value provided by the consumer in the subscription
	ConsumerSubscriptionId *openapi_types.UUID `json:"consumerSubscriptionId,omitempty"`

	// NotificationEventType One of the following values: 0 - create, 1 - modify, 2 - delete
	NotificationEventType ClusterChangeNotificationNotificationEventType `json:"notificationEventType"`

	// NotificationId A unique identifier to represent this notification event
	NotificationId openapi_types.UUID `json:"notificationId"`

	// ObjectRef The URL to the object. This is not required if the notificationEventType is 2 (DELETE). It will point to
	// one of the following data types defined in clause 3.2.6 and the reference will match the type of objects
	// supplied in priorObjectState and/or postObjectState.
	ObjectRef *string `json:"objectRef,omitempty"`

	// PostObjectState This is required if the notificationEventType is 0 (CREATE) or 1 (MODIFY) and is one of the following data
	// types defined in clause 3.2.6 and will match the type of object in priorObjectState and/or the type
	// referred to in objectRef.
	PostObjectState *map[string]interface{} `json:"postObjectState,omitempty"`

	// PriorObjectState This is required if the notificationEventType is 1 (MODIFY) or 2 (DELETE) and is one of the following
	// data types defined in clause 3.2.6 and will match the type of object in postObjectState and/or the type
	// referred to in objectRef.
	PriorObjectState *map[string]interface{} `json:"priorObjectState,omitempty"`
}

// ClusterChangeNotificationNotificationEventType One of the following values: 0 - create, 1 - modify, 2 - delete
type ClusterChangeNotificationNotificationEventType int

// ClusterResource Information about a Cluster Resource
type ClusterResource struct {
	// ArtifactResourceIds Identifiers for the artifact(s) which this resource is based on.
	ArtifactResourceIds *[]openapi_types.UUID `json:"artifactResourceIds,omitempty"`

	// ClusterResourceId Unique identifier for the ClusterResource instance
	ClusterResourceId openapi_types.UUID `json:"clusterResourceId"`

	// ClusterResourceTypeId Identifier for the ClusterResourceType for this resource.
	ClusterResourceTypeId openapi_types.UUID `json:"clusterResourceTypeId"`

	// Description Human readable description of the cluster resource.
	Description string `json:"description"`

	// Extensions These are unspecified (not standardized) properties (keys) which are tailored extend the information
	// provided about the Cluster Resource.
	Extensions *map[string]interface{} `json:"extensions,omitempty"`

	// MemberOf list of other ClusterResources which are linked together.
	MemberOf *[]string `json:"memberOf,omitempty"`

	// Name Name of the cluster resource
	Name string `json:"name"`

	// ResourceId Identifier for the inventory resource which this resource is mapped to
	ResourceId openapi_types.UUID `json:"resourceId"`
}

// ClusterResourceType Information about a Cluster Resource Type
type ClusterResourceType struct {
	// ClusterResourceTypeId Unique identifier for the ClusterResourceType instance
	ClusterResourceTypeId openapi_types.UUID `json:"clusterResourceTypeId"`

	// Description Human readable description of the Cluster Resource Type.
	Description string `json:"description"`

	// Extensions These are unspecified (not standardized) properties (keys) which are tailored extend the information
	// provided about the Cluster Resource Type.
	Extensions *map[string]interface{} `json:"extensions,omitempty"`

	// Name Name of the Cluster Resource Type
	Name string `json:"name"`
}

// NodeCluster Information about a Node Cluster
type NodeCluster struct {
	// ArtifactResourceId Identifier for the template artifact which this NodeCluster is based on.
	ArtifactResourceId openapi_types.UUID `json:"artifactResourceId"`

	// ClientNodeClusterId Unique identifier for the NodeCluster instance assigned by the consumer who requested its creation
	ClientNodeClusterId openapi_types.UUID `json:"clientNodeClusterId"`

	// ClusterDistributionDescription Human readable text identifying the method of distribution of ClusterResources over OCloud Sites.
	ClusterDistributionDescription string `json:"clusterDistributionDescription"`

	// ClusterResourceGroups Optional list node groups that comprise the cluster resources which compose the NodeCluster
	ClusterResourceGroups *[]openapi_types.UUID `json:"clusterResourceGroups,omitempty"`

	// ClusterResourceIds The list of cluster resource identifiers that are used to construct this NodeCluster.
	ClusterResourceIds []openapi_types.UUID `json:"clusterResourceIds"`

	// Description Human readable description of the NodeCluster.
	Description string `json:"description"`

	// Extensions These are unspecified (not standardized) properties (keys) which are tailored extend the information
	// provided about the NodeCluster.
	Extensions *map[string]interface{} `json:"extensions,omitempty"`

	// Name Name of the NodeCluster.
	Name string `json:"name"`

	// NodeClusterId Unique identifier for the NodeClusterType instance
	NodeClusterId openapi_types.UUID `json:"nodeClusterId"`

	// NodeClusterTypeId Identifier for the NodeClusterType that this NodeCluster is.
	NodeClusterTypeId openapi_types.UUID `json:"nodeClusterTypeId"`
}

// NodeClusterType Information about a Node Cluster Type
type NodeClusterType struct {
	// Description Human readable description of the Node Cluster Type.
	Description string `json:"description"`

	// Extensions These are unspecified (not standardized) properties (keys) which are tailored extend the information
	// provided about the Node Cluster Type.
	Extensions *map[string]interface{} `json:"extensions,omitempty"`

	// Name Name of the Node Cluster Type
	Name string `json:"name"`

	// NodeClusterTypeId Unique identifier for the NodeClusterType instance
	NodeClusterTypeId openapi_types.UUID `json:"nodeClusterTypeId"`
}

// Subscription Information about an inventory subscription.
type Subscription struct {
	// Callback The fully qualified URI to a consumer procedure which can process a Post of the
	// InventoryEventNotification.
	//
	//
	// Example: https://smo.example.com/smo/v1/ocloud_inventory_observer
	Callback string `json:"callback"`

	// ConsumerSubscriptionId Identifier for the consumer of events sent due to the Subscription.
	ConsumerSubscriptionId *openapi_types.UUID `json:"consumerSubscriptionId,omitempty"`

	// Filter Criteria for events which do not need to be reported or will be filtered by the subscription
	// notification service. Therefore, if a filter is not provided then all events are reported.
	Filter *string `json:"filter,omitempty"`

	// SubscriptionId Identifier for the Subscription. This identifier is allocated by the O-Cloud.
	//
	// Example: 65221564-8b05-416a-bfc3-c250bc64e1aa
	SubscriptionId *openapi_types.UUID `json:"subscriptionId,omitempty"`
}

// ClusterResourceId defines model for clusterResourceId.
type ClusterResourceId = openapi_types.UUID

// ClusterResourceTypeId defines model for clusterResourceTypeId.
type ClusterResourceTypeId = openapi_types.UUID

// NodeClusterId defines model for nodeClusterId.
type NodeClusterId = openapi_types.UUID

// NodeClusterTypeId defines model for nodeClusterTypeId.
type NodeClusterTypeId = openapi_types.UUID

// SubscriptionId defines model for subscriptionId.
type SubscriptionId = openapi_types.UUID

// GetAlarmDictionariesParams defines parameters for GetAlarmDictionaries.
type GetAlarmDictionariesParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// GetClusterResourceTypesParams defines parameters for GetClusterResourceTypes.
type GetClusterResourceTypesParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// GetClusterResourcesParams defines parameters for GetClusterResources.
type GetClusterResourcesParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// GetNodeClusterTypesParams defines parameters for GetNodeClusterTypes.
type GetNodeClusterTypesParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// GetNodeClustersParams defines parameters for GetNodeClusters.
type GetNodeClustersParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// GetSubscriptionsParams defines parameters for GetSubscriptions.
type GetSubscriptionsParams struct {
	// AllFields This URI query parameter requests that all complex attributes are included in the response.
	//
	// ```
	// all_fields
	// ```
	AllFields *externalRef0.AllFields `form:"all_fields,omitempty" json:"all_fields,omitempty"`

	// ExcludeFields Comma separated list of field references to exclude from the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to exclude the `country` subfield of the `extensions` field:
	//
	// ```
	// exclude_fields=extensions/country
	// ```
	//
	// When this parameter isn't used no field will be excluded.
	//
	// Fields in this list will be excluded even if they are explicitly included using the
	// `fields` parameter.
	ExcludeFields *externalRef0.ExcludeFields `form:"exclude_fields,omitempty" json:"exclude_fields,omitempty"`

	// Fields Comma separated list of field references to include in the result.
	//
	// Each field reference is a field name, or a sequence of field names separated by slashes. For
	// example, to get the `name` field and the `country` subfield of the `extensions` field:
	//
	// ```
	// fields=name,extensions/country
	// ```
	//
	// When this parameter isn't used all the fields will be returned.
	Fields *externalRef0.Fields `form:"fields,omitempty" json:"fields,omitempty"`

	// Filter Search criteria.
	//
	// Contains one or more search criteria, separated by semicolons. Each search criteria is a
	// tuple containing an operator, a field reference and one or more values. The operator can
	// be any of the following strings:
	//
	// | Operator | Meaning                                                     |
	// |----------|-------------------------------------------------------------|
	// | `cont`   | Matches if the field contains the value                     |
	// | `eq`     | Matches if the field is equal to the value                  |
	// | `gt`     | Matches if the field is greater than the value              |
	// | `gte`    | Matches if the field is greater than or equal to the value  |
	// | `in`     | Matches if the field is one of the values                   |
	// | `lt`     | Matches if the field is less than the value                 |
	// | `lte`    | Matches if the field is less than or equal to the the value |
	// | `ncont`  | Matches if the field does not contain the value             |
	// | `neq`    | Matches if the field is not equal to the value              |
	// | `nin`    | Matches if the field is not one of the values               |
	//
	// The field reference is the name of one of the fields of the object, or a sequence of
	// name of fields separated by slashes. For example, to use the `country` sub-field inside
	// the `extensions` field:
	//
	// ```
	// filter=(eq,extensions/country,EQ)
	// ```
	//
	// The values are the arguments of the operator. For example, the `eq` operator compares
	// checks if the value of the field is equal to the value.
	//
	// The `in` and `nin` operators support multiple values. For example, to check if the `country`
	// sub-field inside the `extensions` field is either `ES` or `US:
	//
	// ```
	// filter=(in,extensions/country,ES,US)
	// ```
	//
	// When values contain commas, slashes or spaces they need to be surrounded by single quotes.
	// For example, to check if the `name` field is the string `my cluster`:
	//
	// ```
	// filter=(eq,name,'my cluster')
	// ```
	//
	// When multiple criteria separated by semicolons are used, all of them must match for the
	// complete condition to match. For example, the following will check if the `name` is
	// `my cluster` *and* the `country` extension is `ES`:
	//
	// ```
	// filter=(eq,name,'my cluster');(eq,extensions/country,ES)
	// ```
	//
	// When this parameter isn't used all the results will be returned.
	Filter *externalRef0.Filter `form:"filter,omitempty" json:"filter,omitempty"`
}

// CreateSubscriptionJSONRequestBody defines body for CreateSubscription for application/json ContentType.
type CreateSubscriptionJSONRequestBody = Subscription

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// GetAllVersions Get API versions
	// (GET /o2ims-infrastructureCluster/api_versions)
	GetAllVersions(w http.ResponseWriter, r *http.Request)
	// GetAlarmDictionaries Get alarm dictionaries
	// (GET /o2ims-infrastructureCluster/v1/alarmDictionaries)
	GetAlarmDictionaries(w http.ResponseWriter, r *http.Request, params GetAlarmDictionariesParams)
	// GetAlarmDictionary Get an alarm dictionary
	// (GET /o2ims-infrastructureCluster/v1/alarmDictionaries/{alarmDictionaryId})
	GetAlarmDictionary(w http.ResponseWriter, r *http.Request, alarmDictionaryId externalRef0.AlarmDictionaryId)
	// GetMinorVersions Get minor API versions
	// (GET /o2ims-infrastructureCluster/v1/api_versions)
	GetMinorVersions(w http.ResponseWriter, r *http.Request)
	// GetClusterResourceTypes Get cluster resource types
	// (GET /o2ims-infrastructureCluster/v1/clusterResourceTypes)
	GetClusterResourceTypes(w http.ResponseWriter, r *http.Request, params GetClusterResourceTypesParams)
	// GetClusterResourceType Get a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/clusterResourceTypes/{clusterResourceTypeId})
	GetClusterResourceType(w http.ResponseWriter, r *http.Request, clusterResourceTypeId ClusterResourceTypeId)
	// GetClusterResources Get cluster resources
	// (GET /o2ims-infrastructureCluster/v1/clusterResources)
	GetClusterResources(w http.ResponseWriter, r *http.Request, params GetClusterResourcesParams)
	// GetClusterResource Get a cluster resource
	// (GET /o2ims-infrastructureCluster/v1/clusterResources/{clusterResourceId})
	GetClusterResource(w http.ResponseWriter, r *http.Request, clusterResourceId ClusterResourceId)
	// GetNodeClusterTypes Get node cluster types
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes)
	GetNodeClusterTypes(w http.ResponseWriter, r *http.Request, params GetNodeClusterTypesParams)
	// GetNodeClusterType Get a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId})
	GetNodeClusterType(w http.ResponseWriter, r *http.Request, nodeClusterTypeId NodeClusterTypeId)
	// GetNodeClusterTypeAlarmDictionary Get an alarm dictionary for a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId}/alarmDictionary)
	GetNodeClusterTypeAlarmDictionary(w http.ResponseWriter, r *http.Request, nodeClusterTypeId NodeClusterTypeId)
	// GetNodeClusters Get node clusters
	// (GET /o2ims-infrastructureCluster/v1/nodeClusters)
	GetNodeClusters(w http.ResponseWriter, r *http.Request, params GetNodeClustersParams)
	// GetNodeCluster Get a node cluster
	// (GET /o2ims-infrastructureCluster/v1/nodeClusters/{nodeClusterId})
	GetNodeCluster(w http.ResponseWriter, r *http.Request, nodeClusterId NodeClusterId)
	// GetSubscriptions Get subscriptions
	// (GET /o2ims-infrastructureCluster/v1/subscriptions)
	GetSubscriptions(w http.ResponseWriter, r *http.Request, params GetSubscriptionsParams)
	// CreateSubscription Create subscriptions
	// (POST /o2ims-infrastructureCluster/v1/subscriptions)
	CreateSubscription(w http.ResponseWriter, r *http.Request)
	// DeleteSubscription Delete subscription
	// (DELETE /o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId})
	DeleteSubscription(w http.ResponseWriter, r *http.Request, subscriptionId SubscriptionId)
	// GetSubscription Get subscription
	// (GET /o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId})
	GetSubscription(w http.ResponseWriter, r *http.Request, subscriptionId SubscriptionId)
}

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

type MiddlewareFunc func(http.Handler) http.Handler

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "alarmDictionaryId" -------------
	var alarmDictionaryId externalRef0.AlarmDictionaryId

	err = runtime.BindStyledParameterWithOptions("simple", "alarmDictionaryId", r.PathValue("alarmDictionaryId"), &alarmDictionaryId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "alarmDictionaryId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "clusterResourceTypeId" -------------
	var clusterResourceTypeId ClusterResourceTypeId

	err = runtime.BindStyledParameterWithOptions("simple", "clusterResourceTypeId", r.PathValue("clusterResourceTypeId"), &clusterResourceTypeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "clusterResourceTypeId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "clusterResourceId" -------------
	var clusterResourceId ClusterResourceId

	err = runtime.BindStyledParameterWithOptions("simple", "clusterResourceId", r.PathValue("clusterResourceId"), &clusterResourceId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "clusterResourceId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "nodeClusterTypeId" -------------
	var nodeClusterTypeId NodeClusterTypeId

	err = runtime.BindStyledParameterWithOptions("simple", "nodeClusterTypeId", r.PathValue("nodeClusterTypeId"), &nodeClusterTypeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "nodeClusterTypeId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "nodeClusterTypeId" -------------
	var nodeClusterTypeId NodeClusterTypeId

	err = runtime.BindStyledParameterWithOptions("simple", "nodeClusterTypeId", r.PathValue("nodeClusterTypeId"), &nodeClusterTypeId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "nodeClusterTypeId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "nodeClusterId" -------------
	var nodeClusterId NodeClusterId

	err = runtime.BindStyledParameterWithOptions("simple", "nodeClusterId", r.PathValue("nodeClusterId"), &nodeClusterId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "nodeClusterId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

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

	// ------------- Optional query parameter "all_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "all_fields", r.URL.Query(), &params.AllFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "all_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "all_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "exclude_fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "exclude_fields", r.URL.Query(), &params.ExcludeFields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "exclude_fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "exclude_fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "fields", r.URL.Query(), &params.Fields, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "fields"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "fields", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filter"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		}
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "subscriptionId" -------------
	var subscriptionId SubscriptionId

	err = runtime.BindStyledParameterWithOptions("simple", "subscriptionId", r.PathValue("subscriptionId"), &subscriptionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "subscriptionId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error
	_ = err

	// ------------- Path parameter "subscriptionId" -------------
	var subscriptionId SubscriptionId

	err = runtime.BindStyledParameterWithOptions("simple", "subscriptionId", r.PathValue("subscriptionId"), &subscriptionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "subscriptionId", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

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

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

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

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

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

type RequiredParamError struct {
	ParamName string
}

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

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

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

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

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

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

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

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

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

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

// ServeMux is an abstraction of [http.ServeMux].
type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

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

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

func HandlerFromMuxWithBaseURL(si ServerInterface, m ServeMux, baseURL string) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{
		BaseURL:    baseURL,
		BaseRouter: m,
	})
}

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

	if m == nil {
		m = http.NewServeMux()
	}
	if options.ErrorHandlerFunc == nil {
		options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}

	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
		ErrorHandlerFunc:   options.ErrorHandlerFunc,
	}

	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/api_versions", wrapper.GetAllVersions)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/api_versions", wrapper.GetMinorVersions)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/nodeClusterTypes", wrapper.GetNodeClusterTypes)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId}", wrapper.GetNodeClusterType)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId}/alarmDictionary", wrapper.GetNodeClusterTypeAlarmDictionary)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/nodeClusters", wrapper.GetNodeClusters)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/nodeClusters/{nodeClusterId}", wrapper.GetNodeCluster)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/clusterResourceTypes", wrapper.GetClusterResourceTypes)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/clusterResourceTypes/{clusterResourceTypeId}", wrapper.GetClusterResourceType)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/clusterResources", wrapper.GetClusterResources)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/clusterResources/{clusterResourceId}", wrapper.GetClusterResource)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/subscriptions", wrapper.GetSubscriptions)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/subscriptions", wrapper.CreateSubscription)
	m.HandleFunc(http.MethodDelete+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId}", wrapper.DeleteSubscription)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId}", wrapper.GetSubscription)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/alarmDictionaries", wrapper.GetAlarmDictionaries)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/o2ims-infrastructureCluster/v1/alarmDictionaries/{alarmDictionaryId}", wrapper.GetAlarmDictionary)

	return m
}

type GetAllVersionsRequestObject struct {
}

type GetAllVersionsResponseObject interface {
	VisitGetAllVersionsResponse(w http.ResponseWriter) error
}

type GetAllVersions200JSONResponse externalRef0.APIVersions

func (response GetAllVersions200JSONResponse) VisitGetAllVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetAllVersions400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAllVersions400ApplicationProblemPlusJSONResponse) VisitGetAllVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetAllVersions401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAllVersions401ApplicationProblemPlusJSONResponse) VisitGetAllVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetAllVersions403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAllVersions403ApplicationProblemPlusJSONResponse) VisitGetAllVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetAllVersions500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAllVersions500ApplicationProblemPlusJSONResponse) VisitGetAllVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionariesRequestObject struct {
	Params GetAlarmDictionariesParams
}

type GetAlarmDictionariesResponseObject interface {
	VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error
}

type GetAlarmDictionaries200JSONResponse []externalRef0.AlarmDictionary

func (response GetAlarmDictionaries200JSONResponse) VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionaries400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionaries400ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionaries401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionaries401ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionaries403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionaries403ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionaries500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionaries500ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionariesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionaryRequestObject struct {
	AlarmDictionaryId externalRef0.AlarmDictionaryId `json:"alarmDictionaryId"`
}

type GetAlarmDictionaryResponseObject interface {
	VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error
}

type GetAlarmDictionary200JSONResponse externalRef0.AlarmDictionary

func (response GetAlarmDictionary200JSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionary400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionary400ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionary401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionary401ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionary403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionary403ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionary404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionary404ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetAlarmDictionary500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetAlarmDictionary500ApplicationProblemPlusJSONResponse) VisitGetAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetMinorVersionsRequestObject struct {
}

type GetMinorVersionsResponseObject interface {
	VisitGetMinorVersionsResponse(w http.ResponseWriter) error
}

type GetMinorVersions200JSONResponse externalRef0.APIVersions

func (response GetMinorVersions200JSONResponse) VisitGetMinorVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetMinorVersions400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetMinorVersions400ApplicationProblemPlusJSONResponse) VisitGetMinorVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetMinorVersions401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetMinorVersions401ApplicationProblemPlusJSONResponse) VisitGetMinorVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetMinorVersions403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetMinorVersions403ApplicationProblemPlusJSONResponse) VisitGetMinorVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetMinorVersions500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetMinorVersions500ApplicationProblemPlusJSONResponse) VisitGetMinorVersionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypesRequestObject struct {
	Params GetClusterResourceTypesParams
}

type GetClusterResourceTypesResponseObject interface {
	VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error
}

type GetClusterResourceTypes200JSONResponse []ClusterResourceType

func (response GetClusterResourceTypes200JSONResponse) VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypes400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceTypes400ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypes401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceTypes401ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypes403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceTypes403ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypes500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceTypes500ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceTypeRequestObject struct {
	ClusterResourceTypeId ClusterResourceTypeId `json:"clusterResourceTypeId"`
}

type GetClusterResourceTypeResponseObject interface {
	VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error
}

type GetClusterResourceType200JSONResponse ClusterResourceType

func (response GetClusterResourceType200JSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceType400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceType400ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceType401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceType401ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceType403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceType403ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceType404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceType404ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceType500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResourceType500ApplicationProblemPlusJSONResponse) VisitGetClusterResourceTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourcesRequestObject struct {
	Params GetClusterResourcesParams
}

type GetClusterResourcesResponseObject interface {
	VisitGetClusterResourcesResponse(w http.ResponseWriter) error
}

type GetClusterResources200JSONResponse []ClusterResource

func (response GetClusterResources200JSONResponse) VisitGetClusterResourcesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResources400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResources400ApplicationProblemPlusJSONResponse) VisitGetClusterResourcesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResources401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResources401ApplicationProblemPlusJSONResponse) VisitGetClusterResourcesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResources403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResources403ApplicationProblemPlusJSONResponse) VisitGetClusterResourcesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResources500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResources500ApplicationProblemPlusJSONResponse) VisitGetClusterResourcesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResourceRequestObject struct {
	ClusterResourceId ClusterResourceId `json:"clusterResourceId"`
}

type GetClusterResourceResponseObject interface {
	VisitGetClusterResourceResponse(w http.ResponseWriter) error
}

type GetClusterResource200JSONResponse ClusterResource

func (response GetClusterResource200JSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResource400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResource400ApplicationProblemPlusJSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResource401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResource401ApplicationProblemPlusJSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResource403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResource403ApplicationProblemPlusJSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResource404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResource404ApplicationProblemPlusJSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetClusterResource500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetClusterResource500ApplicationProblemPlusJSONResponse) VisitGetClusterResourceResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypesRequestObject struct {
	Params GetNodeClusterTypesParams
}

type GetNodeClusterTypesResponseObject interface {
	VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error
}

type GetNodeClusterTypes200JSONResponse []NodeClusterType

func (response GetNodeClusterTypes200JSONResponse) VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypes400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypes400ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypes401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypes401ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypes403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypes403ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypes500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypes500ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypesResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeRequestObject struct {
	NodeClusterTypeId NodeClusterTypeId `json:"nodeClusterTypeId"`
}

type GetNodeClusterTypeResponseObject interface {
	VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error
}

type GetNodeClusterType200JSONResponse NodeClusterType

func (response GetNodeClusterType200JSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterType400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterType400ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterType401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterType401ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterType403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterType403ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterType404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterType404ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterType500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterType500ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionaryRequestObject struct {
	NodeClusterTypeId NodeClusterTypeId `json:"nodeClusterTypeId"`
}

type GetNodeClusterTypeAlarmDictionaryResponseObject interface {
	VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error
}

type GetNodeClusterTypeAlarmDictionary200JSONResponse externalRef0.AlarmDictionary

func (response GetNodeClusterTypeAlarmDictionary200JSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionary400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypeAlarmDictionary400ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionary401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypeAlarmDictionary401ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionary403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypeAlarmDictionary403ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionary404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypeAlarmDictionary404ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterTypeAlarmDictionary500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusterTypeAlarmDictionary500ApplicationProblemPlusJSONResponse) VisitGetNodeClusterTypeAlarmDictionaryResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClustersRequestObject struct {
	Params GetNodeClustersParams
}

type GetNodeClustersResponseObject interface {
	VisitGetNodeClustersResponse(w http.ResponseWriter) error
}

type GetNodeClusters200JSONResponse []NodeCluster

func (response GetNodeClusters200JSONResponse) VisitGetNodeClustersResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusters400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusters400ApplicationProblemPlusJSONResponse) VisitGetNodeClustersResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusters401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusters401ApplicationProblemPlusJSONResponse) VisitGetNodeClustersResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusters403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusters403ApplicationProblemPlusJSONResponse) VisitGetNodeClustersResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusters500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeClusters500ApplicationProblemPlusJSONResponse) VisitGetNodeClustersResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeClusterRequestObject struct {
	NodeClusterId NodeClusterId `json:"nodeClusterId"`
}

type GetNodeClusterResponseObject interface {
	VisitGetNodeClusterResponse(w http.ResponseWriter) error
}

type GetNodeCluster200JSONResponse NodeCluster

func (response GetNodeCluster200JSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeCluster400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeCluster400ApplicationProblemPlusJSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeCluster401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeCluster401ApplicationProblemPlusJSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeCluster403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeCluster403ApplicationProblemPlusJSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeCluster404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeCluster404ApplicationProblemPlusJSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetNodeCluster500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetNodeCluster500ApplicationProblemPlusJSONResponse) VisitGetNodeClusterResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptionsRequestObject struct {
	Params GetSubscriptionsParams
}

type GetSubscriptionsResponseObject interface {
	VisitGetSubscriptionsResponse(w http.ResponseWriter) error
}

type GetSubscriptions200JSONResponse []Subscription

func (response GetSubscriptions200JSONResponse) VisitGetSubscriptionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptions400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscriptions400ApplicationProblemPlusJSONResponse) VisitGetSubscriptionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptions401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscriptions401ApplicationProblemPlusJSONResponse) VisitGetSubscriptionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptions403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscriptions403ApplicationProblemPlusJSONResponse) VisitGetSubscriptionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptions500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscriptions500ApplicationProblemPlusJSONResponse) VisitGetSubscriptionsResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type CreateSubscriptionRequestObject struct {
	Body *CreateSubscriptionJSONRequestBody
}

type CreateSubscriptionResponseObject interface {
	VisitCreateSubscriptionResponse(w http.ResponseWriter) error
}

type CreateSubscription201JSONResponse Subscription

func (response CreateSubscription201JSONResponse) VisitCreateSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)
	_, err := buf.WriteTo(w)
	return err
}

type CreateSubscription400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response CreateSubscription400ApplicationProblemPlusJSONResponse) VisitCreateSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type CreateSubscription401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response CreateSubscription401ApplicationProblemPlusJSONResponse) VisitCreateSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type CreateSubscription403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response CreateSubscription403ApplicationProblemPlusJSONResponse) VisitCreateSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type CreateSubscription500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response CreateSubscription500ApplicationProblemPlusJSONResponse) VisitCreateSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type DeleteSubscriptionRequestObject struct {
	SubscriptionId SubscriptionId `json:"subscriptionId"`
}

type DeleteSubscriptionResponseObject interface {
	VisitDeleteSubscriptionResponse(w http.ResponseWriter) error
}

type DeleteSubscription200Response struct {
}

func (response DeleteSubscription200Response) VisitDeleteSubscriptionResponse(w http.ResponseWriter) error {
	w.WriteHeader(200)
	return nil
}

type DeleteSubscription401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response DeleteSubscription401ApplicationProblemPlusJSONResponse) VisitDeleteSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type DeleteSubscription403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response DeleteSubscription403ApplicationProblemPlusJSONResponse) VisitDeleteSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type DeleteSubscription404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response DeleteSubscription404ApplicationProblemPlusJSONResponse) VisitDeleteSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type DeleteSubscription500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response DeleteSubscription500ApplicationProblemPlusJSONResponse) VisitDeleteSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscriptionRequestObject struct {
	SubscriptionId SubscriptionId `json:"subscriptionId"`
}

type GetSubscriptionResponseObject interface {
	VisitGetSubscriptionResponse(w http.ResponseWriter) error
}

type GetSubscription200JSONResponse Subscription

func (response GetSubscription200JSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscription400ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscription400ApplicationProblemPlusJSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(400)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscription401ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscription401ApplicationProblemPlusJSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(401)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscription403ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscription403ApplicationProblemPlusJSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(403)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscription404ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscription404ApplicationProblemPlusJSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(404)
	_, err := buf.WriteTo(w)
	return err
}

type GetSubscription500ApplicationProblemPlusJSONResponse externalRef0.ProblemDetails

func (response GetSubscription500ApplicationProblemPlusJSONResponse) VisitGetSubscriptionResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// GetAllVersions Get API versions
	// (GET /o2ims-infrastructureCluster/api_versions)
	GetAllVersions(ctx context.Context, request GetAllVersionsRequestObject) (GetAllVersionsResponseObject, error)
	// GetAlarmDictionaries Get alarm dictionaries
	// (GET /o2ims-infrastructureCluster/v1/alarmDictionaries)
	GetAlarmDictionaries(ctx context.Context, request GetAlarmDictionariesRequestObject) (GetAlarmDictionariesResponseObject, error)
	// GetAlarmDictionary Get an alarm dictionary
	// (GET /o2ims-infrastructureCluster/v1/alarmDictionaries/{alarmDictionaryId})
	GetAlarmDictionary(ctx context.Context, request GetAlarmDictionaryRequestObject) (GetAlarmDictionaryResponseObject, error)
	// GetMinorVersions Get minor API versions
	// (GET /o2ims-infrastructureCluster/v1/api_versions)
	GetMinorVersions(ctx context.Context, request GetMinorVersionsRequestObject) (GetMinorVersionsResponseObject, error)
	// GetClusterResourceTypes Get cluster resource types
	// (GET /o2ims-infrastructureCluster/v1/clusterResourceTypes)
	GetClusterResourceTypes(ctx context.Context, request GetClusterResourceTypesRequestObject) (GetClusterResourceTypesResponseObject, error)
	// GetClusterResourceType Get a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/clusterResourceTypes/{clusterResourceTypeId})
	GetClusterResourceType(ctx context.Context, request GetClusterResourceTypeRequestObject) (GetClusterResourceTypeResponseObject, error)
	// GetClusterResources Get cluster resources
	// (GET /o2ims-infrastructureCluster/v1/clusterResources)
	GetClusterResources(ctx context.Context, request GetClusterResourcesRequestObject) (GetClusterResourcesResponseObject, error)
	// GetClusterResource Get a cluster resource
	// (GET /o2ims-infrastructureCluster/v1/clusterResources/{clusterResourceId})
	GetClusterResource(ctx context.Context, request GetClusterResourceRequestObject) (GetClusterResourceResponseObject, error)
	// GetNodeClusterTypes Get node cluster types
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes)
	GetNodeClusterTypes(ctx context.Context, request GetNodeClusterTypesRequestObject) (GetNodeClusterTypesResponseObject, error)
	// GetNodeClusterType Get a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId})
	GetNodeClusterType(ctx context.Context, request GetNodeClusterTypeRequestObject) (GetNodeClusterTypeResponseObject, error)
	// GetNodeClusterTypeAlarmDictionary Get an alarm dictionary for a node cluster type
	// (GET /o2ims-infrastructureCluster/v1/nodeClusterTypes/{nodeClusterTypeId}/alarmDictionary)
	GetNodeClusterTypeAlarmDictionary(ctx context.Context, request GetNodeClusterTypeAlarmDictionaryRequestObject) (GetNodeClusterTypeAlarmDictionaryResponseObject, error)
	// GetNodeClusters Get node clusters
	// (GET /o2ims-infrastructureCluster/v1/nodeClusters)
	GetNodeClusters(ctx context.Context, request GetNodeClustersRequestObject) (GetNodeClustersResponseObject, error)
	// GetNodeCluster Get a node cluster
	// (GET /o2ims-infrastructureCluster/v1/nodeClusters/{nodeClusterId})
	GetNodeCluster(ctx context.Context, request GetNodeClusterRequestObject) (GetNodeClusterResponseObject, error)
	// GetSubscriptions Get subscriptions
	// (GET /o2ims-infrastructureCluster/v1/subscriptions)
	GetSubscriptions(ctx context.Context, request GetSubscriptionsRequestObject) (GetSubscriptionsResponseObject, error)
	// CreateSubscription Create subscriptions
	// (POST /o2ims-infrastructureCluster/v1/subscriptions)
	CreateSubscription(ctx context.Context, request CreateSubscriptionRequestObject) (CreateSubscriptionResponseObject, error)
	// DeleteSubscription Delete subscription
	// (DELETE /o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId})
	DeleteSubscription(ctx context.Context, request DeleteSubscriptionRequestObject) (DeleteSubscriptionResponseObject, error)
	// GetSubscription Get subscription
	// (GET /o2ims-infrastructureCluster/v1/subscriptions/{subscriptionId})
	GetSubscription(ctx context.Context, request GetSubscriptionRequestObject) (GetSubscriptionResponseObject, error)
}

type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, error)
type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc

type StrictHTTPServerOptions struct {
	RequestErrorHandlerFunc  func(w http.ResponseWriter, r *http.Request, err error)
	ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
		RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		},
		ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		},
	}}
}

func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
	if options.RequestErrorHandlerFunc == nil {
		options.RequestErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}
	if options.ResponseErrorHandlerFunc == nil {
		options.ResponseErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
	options     StrictHTTPServerOptions
}

// GetAllVersions operation middleware
func (sh *strictHandler) GetAllVersions(w http.ResponseWriter, r *http.Request) {
	var request GetAllVersionsRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAllVersions(ctx, request.(GetAllVersionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAllVersions")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAllVersionsResponseObject); ok {
		if err := validResponse.VisitGetAllVersionsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAlarmDictionaries operation middleware
func (sh *strictHandler) GetAlarmDictionaries(w http.ResponseWriter, r *http.Request, params GetAlarmDictionariesParams) {
	var request GetAlarmDictionariesRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAlarmDictionaries(ctx, request.(GetAlarmDictionariesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAlarmDictionaries")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAlarmDictionariesResponseObject); ok {
		if err := validResponse.VisitGetAlarmDictionariesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetAlarmDictionary operation middleware
func (sh *strictHandler) GetAlarmDictionary(w http.ResponseWriter, r *http.Request, alarmDictionaryId externalRef0.AlarmDictionaryId) {
	var request GetAlarmDictionaryRequestObject

	request.AlarmDictionaryId = alarmDictionaryId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAlarmDictionary(ctx, request.(GetAlarmDictionaryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAlarmDictionary")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAlarmDictionaryResponseObject); ok {
		if err := validResponse.VisitGetAlarmDictionaryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetMinorVersions operation middleware
func (sh *strictHandler) GetMinorVersions(w http.ResponseWriter, r *http.Request) {
	var request GetMinorVersionsRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetMinorVersions(ctx, request.(GetMinorVersionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetMinorVersions")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetMinorVersionsResponseObject); ok {
		if err := validResponse.VisitGetMinorVersionsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetClusterResourceTypes operation middleware
func (sh *strictHandler) GetClusterResourceTypes(w http.ResponseWriter, r *http.Request, params GetClusterResourceTypesParams) {
	var request GetClusterResourceTypesRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetClusterResourceTypes(ctx, request.(GetClusterResourceTypesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetClusterResourceTypes")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetClusterResourceTypesResponseObject); ok {
		if err := validResponse.VisitGetClusterResourceTypesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetClusterResourceType operation middleware
func (sh *strictHandler) GetClusterResourceType(w http.ResponseWriter, r *http.Request, clusterResourceTypeId ClusterResourceTypeId) {
	var request GetClusterResourceTypeRequestObject

	request.ClusterResourceTypeId = clusterResourceTypeId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetClusterResourceType(ctx, request.(GetClusterResourceTypeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetClusterResourceType")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetClusterResourceTypeResponseObject); ok {
		if err := validResponse.VisitGetClusterResourceTypeResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetClusterResources operation middleware
func (sh *strictHandler) GetClusterResources(w http.ResponseWriter, r *http.Request, params GetClusterResourcesParams) {
	var request GetClusterResourcesRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetClusterResources(ctx, request.(GetClusterResourcesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetClusterResources")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetClusterResourcesResponseObject); ok {
		if err := validResponse.VisitGetClusterResourcesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetClusterResource operation middleware
func (sh *strictHandler) GetClusterResource(w http.ResponseWriter, r *http.Request, clusterResourceId ClusterResourceId) {
	var request GetClusterResourceRequestObject

	request.ClusterResourceId = clusterResourceId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetClusterResource(ctx, request.(GetClusterResourceRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetClusterResource")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetClusterResourceResponseObject); ok {
		if err := validResponse.VisitGetClusterResourceResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetNodeClusterTypes operation middleware
func (sh *strictHandler) GetNodeClusterTypes(w http.ResponseWriter, r *http.Request, params GetNodeClusterTypesParams) {
	var request GetNodeClusterTypesRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeClusterTypes(ctx, request.(GetNodeClusterTypesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeClusterTypes")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetNodeClusterTypesResponseObject); ok {
		if err := validResponse.VisitGetNodeClusterTypesResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetNodeClusterType operation middleware
func (sh *strictHandler) GetNodeClusterType(w http.ResponseWriter, r *http.Request, nodeClusterTypeId NodeClusterTypeId) {
	var request GetNodeClusterTypeRequestObject

	request.NodeClusterTypeId = nodeClusterTypeId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeClusterType(ctx, request.(GetNodeClusterTypeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeClusterType")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetNodeClusterTypeResponseObject); ok {
		if err := validResponse.VisitGetNodeClusterTypeResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetNodeClusterTypeAlarmDictionary operation middleware
func (sh *strictHandler) GetNodeClusterTypeAlarmDictionary(w http.ResponseWriter, r *http.Request, nodeClusterTypeId NodeClusterTypeId) {
	var request GetNodeClusterTypeAlarmDictionaryRequestObject

	request.NodeClusterTypeId = nodeClusterTypeId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeClusterTypeAlarmDictionary(ctx, request.(GetNodeClusterTypeAlarmDictionaryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeClusterTypeAlarmDictionary")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetNodeClusterTypeAlarmDictionaryResponseObject); ok {
		if err := validResponse.VisitGetNodeClusterTypeAlarmDictionaryResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetNodeClusters operation middleware
func (sh *strictHandler) GetNodeClusters(w http.ResponseWriter, r *http.Request, params GetNodeClustersParams) {
	var request GetNodeClustersRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeClusters(ctx, request.(GetNodeClustersRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeClusters")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetNodeClustersResponseObject); ok {
		if err := validResponse.VisitGetNodeClustersResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetNodeCluster operation middleware
func (sh *strictHandler) GetNodeCluster(w http.ResponseWriter, r *http.Request, nodeClusterId NodeClusterId) {
	var request GetNodeClusterRequestObject

	request.NodeClusterId = nodeClusterId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetNodeCluster(ctx, request.(GetNodeClusterRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetNodeCluster")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetNodeClusterResponseObject); ok {
		if err := validResponse.VisitGetNodeClusterResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetSubscriptions operation middleware
func (sh *strictHandler) GetSubscriptions(w http.ResponseWriter, r *http.Request, params GetSubscriptionsParams) {
	var request GetSubscriptionsRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetSubscriptions(ctx, request.(GetSubscriptionsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSubscriptions")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetSubscriptionsResponseObject); ok {
		if err := validResponse.VisitGetSubscriptionsResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// CreateSubscription operation middleware
func (sh *strictHandler) CreateSubscription(w http.ResponseWriter, r *http.Request) {
	var request CreateSubscriptionRequestObject

	var body CreateSubscriptionJSONRequestBody
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.CreateSubscription(ctx, request.(CreateSubscriptionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateSubscription")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(CreateSubscriptionResponseObject); ok {
		if err := validResponse.VisitCreateSubscriptionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// DeleteSubscription operation middleware
func (sh *strictHandler) DeleteSubscription(w http.ResponseWriter, r *http.Request, subscriptionId SubscriptionId) {
	var request DeleteSubscriptionRequestObject

	request.SubscriptionId = subscriptionId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteSubscription(ctx, request.(DeleteSubscriptionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteSubscription")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(DeleteSubscriptionResponseObject); ok {
		if err := validResponse.VisitDeleteSubscriptionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetSubscription operation middleware
func (sh *strictHandler) GetSubscription(w http.ResponseWriter, r *http.Request, subscriptionId SubscriptionId) {
	var request GetSubscriptionRequestObject

	request.SubscriptionId = subscriptionId

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetSubscription(ctx, request.(GetSubscriptionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSubscription")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetSubscriptionResponseObject); ok {
		if err := validResponse.VisitGetSubscriptionResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}

// Base64 encoded, compressed with deflate, json marshaled OpenAPI spec.
// Stored as a slice of fixed-width chunks rather than one concatenated
// const string: with thousands of chunks the chained `+` fold is several
// times slower for the Go compiler than parsing a slice literal.
var swaggerSpec = []string{
	"7H1rc9u4kvZfQel9q05yVhff4kk8NbXlYztnVCeJvb6cra3INYbIpoUxCTAAaEeT8X/fwoV3UKIkx5Nk",
	"OV8mlnBpNLqffroBUl96HotiRoFK0Tv40osxxxFI4PovL0yEBH4OgiXcg7GvPvRBeJzEkjDaO+hdUfIp",
	"AUR8oJIEBDhiAcLI9kTcdh1OaK/fg884ikPoHfR2X/vedH93OphuB1uDPX/HG7x+PQ0Gr/b39vb3f9qC",
	"YGu71+8RNUWM5azX71EcqZ51mfo9Dp8SwsHvHUieQL8nvBlEWAkbMB5h2TvoJQlRLeU8VoMIyQm97T0+",
	"9qvjXc7jTdaJ1AS1xW7j/Tevfno12A3ebA32YPpqMH0d4MHr4DXs7AZv3njBVqvFWuE2XDCLIkZ/wzH5",
	"jcVA1f9xiHl0TDy1Vszn7ddPke6K/Kzv0210XaivsO7wLYHQF/X1Xs6IQFfnY/QpAT5HmV8gJQIIKZCc",
	"YYlwGCLlQSF8RlhKTqaJBIEwB0SoFyY++IhQJGegTCRmVCjrmNCbm5sJxWH4W6Dntx+kitBzFjWRtusV",
	"l+xDgJNQrTnAoQDVPglDPFV6N+pppQT4rOVsUsQRiyKMBCgNSPBRSIRUe68FQhwC4EA9EEgyZIdCAWdR",
	"uuYklHrFJ9ibVTshIhC2H6q19hHjSE32KdFfZ9OoL0VBiOkciRCLGYghesv4hFqD6xelUALceCyhks9v",
	"kEimZiwWmG/gswQqCKPixsxykG2MHcEq/Ze85cgOZ9tN6H/PQO0uEQULIYL+TaJEgI8oswt4IGGIppDK",
	"5muVGJUb+yDCaLbaEME9UES0zHNtV/A5DolHZDjPTSwRhN6qJhN6Y4S+yQWquqTWdH1NDcZX1kXJAFuZ",
	"V/AEdmXXWfCk57eqW5DGblQvazEIU38DM7Pm1bAfbW1MQZCayYyWGRAHmXCqLW2D3V9/10MJvL7rF4C5",
	"N0MeJxI4wXoPjxiVmFCBGAW1VRHjgES5Yb+yTRARj4WMiiHSJlBprk1gQmUSh4A8M77yEEwRi4FjyXg/",
	"s5HccNR2FoW4x2GijOFyBlk/5GE6oVPVeJ5ucsDCkD2oCYxWhN7jP9Fp2udP9B6wlmCd//6c0D8H2X+F",
	"f67xnxpLmSuVN2pk9B5LbwbCIozViJfuiPpIK6FRLnQDn27MX+6xiEDwKcGh8qEFw5mxbuWysW45YOUA",
	"coZp03jpWHCzwliMO+U0YxG6TC5tNkHeUzTqK1y6xhCEWLjAwljL1piPVV1gPrYZi1qjaBjLZyAQZTI1",
	"jgbZ7FjWKJrlUiMtsws7llX+4rGW6f9P5ZGXWa9SsFCdFN6pAQrjWEC1f7Hp7+DJeiyZ0LSrbd8YT1Ax",
	"nCTCQVAGdklUEB8mdHn8UCD7ywv45AD0/sl/vcxCyGWuFkUh1MCY3yaRSvuyBVqwqsqqhfh0UwBAFsWY",
	"g5hQbwbeXbYfZgfZUucfphJpt1KYa/Y4nUAgkcQx4xJFSSiJgvAUiKta1AKk82eqnNCqLhtCsZaPyBlw",
	"dHNycaP29ubqoq5gQp0KvuhfXbwsh2mr5NRHVGTEop+agZpAxFizGkXnKICvljEFJBLOWUJ9azaE3oaA",
	"PiVMghhO6OJ1FxmJNWcTh9BNNE9T1Bun3Wg28Le81d8q68l2IIusDXFY25XiI31NSIwVRChKhESR8lsU",
	"MG4YqsmXpA7MPlHEQC1JN3LYXh5bNbNxrZyo/KmwUvR3TP2/V9wr20ClIrXbLfXxc5N7Vbd+OUMzvHU5",
	"RcsEyeV42cjPNM9azM8o8+HIjLNCaUP1SqevSrj/amdn+9X+3uD1dOvVYG97Hw+mgbc78HZebU29/T3Y",
	"xtid1Zdl2SyjL4y1YtmmuDZ3yWbtskVdqM0WKZJptqAVVljsVl0cxq93/a0pHuBXAIO9YDsYTOH13iDY",
	"3d2b7mxv7+97gXtxFWE2Wdlj2ljnhlZjRzNMb+EDUyvxsFlhdcFjaoZWroynLJGK1RN6D1QyPkeeHkJx",
	"gnyMfi/mKrpIAqauyahIIuAXS3SbhU0Uc3ZPLDgrV05HSFPSomK0tpcsXxlvLuCJEv5St6iKcFrgIxkS",
	"mihzgLbQAHmaxPbRNhqgiPkkmPfRDhogHxTGmp2nSdQ7+LjV3+7vXGeiECrhFnhVFpceDlFSszLJEIeY",
	"gwAqDfYVR9FlC9lOE4ZZnUPg3oCr83cpfTAtVT5GREr8UgtMY4JTr6rxDnpxfPLu5PLk5RCNbaElZkRJ",
	"zyaUufTsY4k1PAjkQ0CoKeZ5IVbsbXe4M9zPKgA5odQDm5CnabaaXhFLLbtQ3CSOQ2KGijlh/FR/cyGx",
	"1BnoiHEUMyELHxsHrimu0qqhiElEex1toRdH5yeHlycvFVXZRi/enx6P3/7PS73McpZT1tKELlfTQsUs",
	"0kbaekK1lrkhTYSizHJKCjKfagVVBnwCDRV0wnjBphZpaEJbGtJyDZV3fEMFPRbx+2MVBZog6tqh6KPy",
	"OUUr0Ea2E8p6VWEac0kCrORPz3ocdcRxBkkipZgo7fhCvEQPM6LVqTfZHtIQgaZYMbM0NhIJkWgRtbIP",
	"MOd43qsfH7WL0KmcFbWpZEVi6kE73Gx5cjVeOq+2bfNdQUvDdlKUJqvO/WsSYYo4YB9PQ0CFL1MncR8U",
	"1mbJCbg2DN/kDTg8KxpMVRoVPgSYzISKGDylBR+9UGFDKdrH3Cd/gP8S5XaHXtzBPDMbnSxjEjLlUloG",
	"g/YkN+cJzbiBMeyCgjPTbsCnCKIp8FNH4Eur4Uwnp5X9EgXpQkLvtLvfgmpaMeel5mt4XXX2D7ai4dog",
	"9/7wBfbvMMCcrmU+2eCnEY5jvb421lgBNNdRsV5w2U76C45Zs54tUM9N4NogH9Jdayx13ZPpRW6+GsRs",
	"6NzOdf6YHl5fWm4ny53MOZpLT4stPDNch5W7DPhDnqu2M1zVIRW2RbhuhQUSojjUZMb2L0JBQcJ61G4R",
	"IQlQ+WHV8kcqWWly6zcIC0FuqSMTfJix9HKAondSmNSsdUJo9/KYCHONgDB6vIL7Sfgs00XM7WkwikDO",
	"mD6L9AvDqr9rIYXdA0enRyFLfHRBTNmxBev4J2dJ7KBlp7FxX3Ouq+stt7qpuTfhsSjmxNbAqyEmjW/6",
	"apJtU9iLp2Zswp13piG4dsWHFBinuQRiS5+6MsuokDzxZM1+N2WaG2JxTZLvHYGbFrQK7i5XCn0C8Fgj",
	"8LYobY6Xz6mt04GjwzXIVLVw68LWxfSqCdn6zpqpI5o4fXdJXGtPyoqxzU3InsADSxP8OH7YvKxVvbE0",
	"0lKXXJ0Tb+KWzR6xKvEqFp5XrnDXS/uVvAGH4RR7d+6wFiRhOEefEhwaC7k6H6u4hXMiE3PmgZ/wNCfz",
	"MDWfCYEwOmMmLCplTug4lUrXh4qF++qhw0zKWByMRiJiQ/vp0GOR+nt0vz1inmIev2Wr/I1NBfB7TTPr",
	"HKRl/d4BkdkqWWBq1ALpCrafQFplLo46bAPWTZedjtIzUzW5ncyo1Ge6dl04/+UQM66II+PZ+aAZN6ea",
	"xY1HE1qqtytlEQ/0XSUOAePQRyTQd5xCS57VjJn/yhlQfTBp5VLen8rQgEtidW2XVGnL9nkrIpQEzEtP",
	"k1WP04GmoMN1jhurG6XA+JSG8+brsKVcKnUbl8M6rrgdno3/DVy09WB0bxqnvnN4NnY5730+ZL7+neHW",
	"cMuJR6sJKtpJmjJfK4tYIjKOSXH8TOyPhdXYJTxeFxjw/+cQ9A56/2+UP4IwskeCo8X6drDjhJMzDgH5",
	"XNbciO2QSAwIDTg2vDzhkIHW6H5nfa3q6+kQEEpWQHF7XT7rNqxrU7U4zIJ+07Xsd3aPIpBYny7cwXxg",
	"zyox4SJLSLAQzCMqv47MFcQgCfNeFvI4hNoJHY8x1HShBTQHtU3kyleoZC65ZIcY9lxWU1LmeYk+pfAT",
	"nqaqRjMhFtI2/Rlh3we/b08y/b453iTZfQlzqtk7PD4+Oe71e+YgRv1LH9CMT44LnpyjGC7vmwvIzgxI",
	"qmiXuE7Xc3GnoMTnmAjw82NJ9f0ZJxHmc/QvmCNCrZq1zaD8mYZ2uYCVeAFhKAgcMnoLPKef99m+lyXP",
	"795g6iPsLM0zmt5zSyFgQiu980UTqhhjIZ5hjemFG7f6FrUSSLEZH7Aa80GZwwzHMVDwrSgCqDA365QU",
	"EATgSdEvidM3V3V1cZxEMfaU8WIOOMMqMRcSooZIphfxDgtpzHiZCVe3DVkcQoQWa1U1C/YXTf/BSYez",
	"nRQzxqW5lZidaqluTUUZwOrfDQ6ZWq+iH/qYwMpKBNI9lfISyRRYqSg41xegMU3UvyvOdnV5+v7wcnyk",
	"3Ozww9XhO6eTRZjiW4iAyjGVwAPsrgZmIJY112ak25uClE1NlLT26iLHVEREqg3PjqxOqCRyniYf5ycX",
	"l+fjo8vx6YcDfZ+swCvQ+P0FujBcSZjOBjT18xcRkcaAT3fG7y8qBZtUBfo756qrMSm+KxJijeRLNodk",
	"TzMwXn4iQqQ3TczOlbhf6bp2bIHnDuboxdm/XmboM6E1O84UmGn9Z0SGMCxJUhrdDpHBJxofr3rkpMId",
	"E+CfgwpUh1oYscATbhPi68qrkjbtrLgqJhxh033YolZeB/6iJ9ZBoR7pHFDctJyKSzZ5hNtGrldhINlu",
	"rsZA8gf23AykzGzW5myVoRzm0OLZQ5W2jmsRuGrN5jGNcSm9sOH7gcgZUZEuSy9WibzZDBd6oY2k/98V",
	"gl/1NtNdwUstaOTbodxNySUWxY580HWFGeYxTKB7oD7j2c0UkWjhsCnvVNKWoqSYoqmiBCnD9LWiVQQ3",
	"9Sev2lmwQD4oFPchJPfA7QM0RCi/9hNPNlXENL43XJAbnB9+QKaFIZugwkOJVh4YliJm2CTW1ixi4Ona",
	"iydow4j5ECqGMaGlz+1q3DL+hSEPoS7ofeNBz5iZy021+Vn/KGyqgQn9GC0RdSzB+g6hGKaGzZLQV5at",
	"vUyRRrPBONNgzZT1vNkjy63jZ/l57AY0WoKcJYfOdLNajKwlcm2j5hln0xCiY5CYhOadB+Xol6Xeh9nz",
	"3Avq8EvuTPQO6RzRJJrae9nZIIWnxftqmwrXAnP8NJbOuE2kSBSHWj04LR3UFuzrZblu8M6SCNNBdj4B",
	"n+MQU1s7TOFa+wwRaX5uH5Y1Dqa1Vi7LHTFKwUsf4PCxxFMsAEkSgY9YIl0wmdbbXSJenY8L92h1BCI5",
	"UGjTTiVtlhBN6FiiCM/RXHtykHCTJhbIEAmQD9lMNTbAibP8KbFMGs6Kf728PEOmAfKYX7hNt1CV9ZvY",
	"ksjQqRudD/aruyiSSONeeWhTvUFjmQKDfmzP1F/0o/kFoSRrFrGvn4SHWBrqnXBFdHWGHTIPh+QPY4do",
	"HJjAS4TO72khOddPHk56mn0eTENM7ya9vmU+qQPYuIxDoSsHaYm6gQtIJwuoGg/2PMZ9TQIYGp9cvkXn",
	"b4/Q7pvX++jj7rXTtmrKIwIB9VjC8a0umFtCpCayMooJrWyIz7wk89Asc0+HfgHD26F5WP/Xy/fvXqp0",
	"nJZNEeXPEpnbgXnlXl+1708okYX4jYVIoqzqUtF00xlMaoIFHQ49Fi11gkpEsB6Roc6164axAC/hRJoQ",
	"YCCT4UTOdhouYx+ejVGizOz0MJEztGM4pbkmQhRd8jjojcOhQEHIHvQRTcge7J051eYob6I+FB6Lzcyc",
	"hXBgSsJqy4ArAqmoDTrXf6JzFqqQVGhnTz2mhbYX2UemvbJKdgf0iocFJd/B3AsZviuddnHAYSRGjGOq",
	"dkEyj4UjFZqIP/AMnI70WKU6tNGXfmYGPkvgFIfHzBNNZPhUCY6yGIouSuHkp+EWenHqSabk39na2XvZ",
	"6/eSkuil+COGbMAxHTJ+O/LZAw0Z9v+T+L/8tPfGAHrAHP54NtbWbxQ2LpXfUfEeT0g8oEJ7tH3G6DDG",
	"3gzQjj7xKMv18PAwxPprLY3tK0bvxkcnHy5OBjvDreFMRmEBSXuLJFDGpglIekqxbU4p+j3LFnoHvV17",
	"9hJjOdMadx4p2AFHimHcFw5DbkHWlXOun/sTtshqH4ZMia/SXHbwkkX8wiGgPejT2jOlVVvG7v0T5GEY",
	"Zmcx+v6qfuWMFmVna8s++ySBSnNwE4d2k0e/C5NF5g9wrX08I4ylVl78kHgeCGFOn9lUkWtzClnXQLp6",
	"tcTHfm9vodwWyv5jY/krvNCxhH9gP73gZ+Ta/jbkuqIKHxgnf4BvBNv9NgR7y/iU+D7obXz1rWyjxkXF",
	"wM39AgScMz4sxSp9dplGqY/FaID9iNBygLCB5Prxut+zfMz4YsmVVTDFt0INlx6+9a7VnAvh5H57VM6k",
	"bNKxFFZSX6qUl0h6rdMBHNVp+qWXwX1070TeZLTw/VqP/XX6l19Ntd4YwWad9c0OtbUbYelm9dO8xFur",
	"LKwCtIttokPaDmmfA2m/BtDWLboAt6WP14Pc0Zda8euxFQybxEgsfFfiEiiePw0QV2t3G0Papki2CnIt",
	"V2OHXj8Keu1t7X0bUl3m9Ubw0wOmB2yqMQFLqD/8P8prHT64Gd6umjSnTCYilPHmjDkrwkb4d8YbL2DW",
	"APi9GvabTqM7xOv42veMIHXHXTs/djwCuxqIOF/h3ZQmH7lm6zLlZ86UXQ/eP0lq3GwLHdx2cPu9psdu",
	"qy4gLi/B2dqwO/rifB/B6qly0/v52sDx6mjsfIfCV82Pnfi1ZkJs3lblUFeHWF1K3KXEz5US133wSfF1",
	"M0rbks12TPavZrJfh8V2BLYjsD8UgX1a7lrnrWtxVvebDJdh7qZ09Zmp6kY01aWhDpY6ltqx1GdjqVUX",
	"3AxIK2/AWY2k1ghzE0v9UJ2lY6nPzFKr79N6Epbq3v8uHnQ09XulqXWLflp4HX2pvXLsK9ZWq06/KurW",
	"X4/2VYlqDaO6emqHTB1T7eqp7bG0cvFz3gpbay9wCPQvBK6Jspve/Xxm0P2KFz1duu1guIPhDob/2pue",
	"Tfj2ZPC8fhWhRQGhKx78lcWDpy8cdDWDrmbww9QMnq5cUKa3G5cJluPqJkT1GSsDT1YV6GCnY6IdE/3L",
	"CgKbAWXxRfbrXawqjdCAjhelWTra+cy0s/QTG0/CO2ub3gWAjnd+H4Da9EYrB9CKCmylOFv+/Nr+/LTr",
	"R09AvzgdUydausDSdCk5rHnRGAj5D+bPn4wJljGh/DozyRN4rAHT9lecewH+mB9192u/+tKhToc63wHq",
	"NCOMcfXWILMqmRt9Kf9I0aPBpxBcv/1+rD8XCC8FKNOyAlCr8bnKjyc1caAFmGB/BqUZEzrf61K+Hwkr",
	"jNeVbH0hH1mtvrXM5ysZ3Ndy+OfnFotKXB3X6PCuw7tvOCNbxJVWkMjMohdkwCx/z+7BaKTf7j1jQh68",
	"3toyP9pnJ13+CzOO81j7Xt/SEe9jf7WhihfE6+OZ2l+bMRuejLRD1h66XGdIh6jOd5SsMraj3miHLlvB",
	"4/Xj/wYAAP//",
}

// decodeSpec returns the embedded OpenAPI spec as raw JSON bytes,
// after base64-decoding and flate-decompressing the embedded blob.
func decodeSpec() ([]byte, error) {
	encoded := strings.Join(swaggerSpec, "")
	compressed, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		return nil, fmt.Errorf("error base64 decoding spec: %w", err)
	}
	zr := flate.NewReader(bytes.NewReader(compressed))
	var buf bytes.Buffer
	if _, err := buf.ReadFrom(zr); err != nil {
		return nil, fmt.Errorf("read flate: %w", err)
	}
	if err := zr.Close(); err != nil {
		return nil, fmt.Errorf("close flate reader: %w", err)
	}

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

// a naive cache of the decoded OpenAPI 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
	}

	for rawPath, rawFunc := range externalRef0.PathToRawSpec(path.Join(path.Dir(pathToFile), "../../common/api/openapi.yaml")) {
		if _, ok := res[rawPath]; ok {
			// it is not possible to compare functions in golang, so always overwrite the old value
		}
		res[rawPath] = rawFunc
	}
	return res
}

// GetSpec returns the OpenAPI specification corresponding to the generated
// code in this file. External references in the spec are resolved through
// PathToRawSpec; externally-referenced files must be embedded in their
// corresponding Go packages (via the import-mapping feature). URL-based
// external refs are not supported.
func GetSpec() (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
}

// GetSpecJSON returns the raw JSON bytes of the embedded OpenAPI
// specification: decompressed but not unmarshaled. External references
// are not resolved here; the bytes are the spec exactly as embedded by
// codegen. The result is cached at package init time, so repeated calls
// are cheap.
func GetSpecJSON() ([]byte, error) {
	return rawSpec()
}

// GetSwagger returns the OpenAPI specification corresponding to the
// generated code in this file.
//
// Deprecated: GetSwagger predates kin-openapi renaming openapi3.Swagger
// to openapi3.T. Use [GetSpec] instead. This wrapper is retained for
// backwards compatibility.
func GetSwagger() (*openapi3.T, error) {
	return GetSpec()
}
