// Code generated by go-swagger; DO NOT EDIT.

package cluster

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// CreatePrivateEndpointReader is a Reader for the CreatePrivateEndpoint structure.
type CreatePrivateEndpointReader struct {
	formats strfmt.Registry
}

// ReadResponse reads a server response into the received o.
func (o *CreatePrivateEndpointReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
	switch response.Code() {
	case 200:
		result := NewCreatePrivateEndpointOK()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	case 400:
		result := NewCreatePrivateEndpointBadRequest()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	case 401:
		result := NewCreatePrivateEndpointUnauthorized()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	case 403:
		result := NewCreatePrivateEndpointForbidden()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	case 404:
		result := NewCreatePrivateEndpointNotFound()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	case 429:
		result := NewCreatePrivateEndpointTooManyRequests()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	case 500:
		result := NewCreatePrivateEndpointInternalServerError()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return nil, result
	default:
		result := NewCreatePrivateEndpointDefault(response.Code())
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		if response.Code()/100 == 2 {
			return result, nil
		}
		return nil, result
	}
}

// NewCreatePrivateEndpointOK creates a CreatePrivateEndpointOK with default headers values
func NewCreatePrivateEndpointOK() *CreatePrivateEndpointOK {
	return &CreatePrivateEndpointOK{}
}

/*
CreatePrivateEndpointOK describes a response with status code 200, with default header values.

A successful response.
*/
type CreatePrivateEndpointOK struct {
	Payload *CreatePrivateEndpointOKBody
}

// IsSuccess returns true when this create private endpoint o k response has a 2xx status code
func (o *CreatePrivateEndpointOK) IsSuccess() bool {
	return true
}

// IsRedirect returns true when this create private endpoint o k response has a 3xx status code
func (o *CreatePrivateEndpointOK) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint o k response has a 4xx status code
func (o *CreatePrivateEndpointOK) IsClientError() bool {
	return false
}

// IsServerError returns true when this create private endpoint o k response has a 5xx status code
func (o *CreatePrivateEndpointOK) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint o k response a status code equal to that given
func (o *CreatePrivateEndpointOK) IsCode(code int) bool {
	return code == 200
}

// Code gets the status code for the create private endpoint o k response
func (o *CreatePrivateEndpointOK) Code() int {
	return 200
}

func (o *CreatePrivateEndpointOK) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointOK  %+v", 200, o.Payload)
}

func (o *CreatePrivateEndpointOK) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointOK  %+v", 200, o.Payload)
}

func (o *CreatePrivateEndpointOK) GetPayload() *CreatePrivateEndpointOKBody {
	return o.Payload
}

func (o *CreatePrivateEndpointOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointOKBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointBadRequest creates a CreatePrivateEndpointBadRequest with default headers values
func NewCreatePrivateEndpointBadRequest() *CreatePrivateEndpointBadRequest {
	return &CreatePrivateEndpointBadRequest{}
}

/*
CreatePrivateEndpointBadRequest describes a response with status code 400, with default header values.

A request field is invalid.
*/
type CreatePrivateEndpointBadRequest struct {
	Payload *CreatePrivateEndpointBadRequestBody
}

// IsSuccess returns true when this create private endpoint bad request response has a 2xx status code
func (o *CreatePrivateEndpointBadRequest) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint bad request response has a 3xx status code
func (o *CreatePrivateEndpointBadRequest) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint bad request response has a 4xx status code
func (o *CreatePrivateEndpointBadRequest) IsClientError() bool {
	return true
}

// IsServerError returns true when this create private endpoint bad request response has a 5xx status code
func (o *CreatePrivateEndpointBadRequest) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint bad request response a status code equal to that given
func (o *CreatePrivateEndpointBadRequest) IsCode(code int) bool {
	return code == 400
}

// Code gets the status code for the create private endpoint bad request response
func (o *CreatePrivateEndpointBadRequest) Code() int {
	return 400
}

func (o *CreatePrivateEndpointBadRequest) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointBadRequest  %+v", 400, o.Payload)
}

func (o *CreatePrivateEndpointBadRequest) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointBadRequest  %+v", 400, o.Payload)
}

func (o *CreatePrivateEndpointBadRequest) GetPayload() *CreatePrivateEndpointBadRequestBody {
	return o.Payload
}

func (o *CreatePrivateEndpointBadRequest) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointBadRequestBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointUnauthorized creates a CreatePrivateEndpointUnauthorized with default headers values
func NewCreatePrivateEndpointUnauthorized() *CreatePrivateEndpointUnauthorized {
	return &CreatePrivateEndpointUnauthorized{}
}

/*
CreatePrivateEndpointUnauthorized describes a response with status code 401, with default header values.

The API key cannot be authenticated.
*/
type CreatePrivateEndpointUnauthorized struct {
	Payload interface{}
}

// IsSuccess returns true when this create private endpoint unauthorized response has a 2xx status code
func (o *CreatePrivateEndpointUnauthorized) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint unauthorized response has a 3xx status code
func (o *CreatePrivateEndpointUnauthorized) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint unauthorized response has a 4xx status code
func (o *CreatePrivateEndpointUnauthorized) IsClientError() bool {
	return true
}

// IsServerError returns true when this create private endpoint unauthorized response has a 5xx status code
func (o *CreatePrivateEndpointUnauthorized) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint unauthorized response a status code equal to that given
func (o *CreatePrivateEndpointUnauthorized) IsCode(code int) bool {
	return code == 401
}

// Code gets the status code for the create private endpoint unauthorized response
func (o *CreatePrivateEndpointUnauthorized) Code() int {
	return 401
}

func (o *CreatePrivateEndpointUnauthorized) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointUnauthorized  %+v", 401, o.Payload)
}

func (o *CreatePrivateEndpointUnauthorized) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointUnauthorized  %+v", 401, o.Payload)
}

func (o *CreatePrivateEndpointUnauthorized) GetPayload() interface{} {
	return o.Payload
}

func (o *CreatePrivateEndpointUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	// response payload
	if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointForbidden creates a CreatePrivateEndpointForbidden with default headers values
func NewCreatePrivateEndpointForbidden() *CreatePrivateEndpointForbidden {
	return &CreatePrivateEndpointForbidden{}
}

/*
CreatePrivateEndpointForbidden describes a response with status code 403, with default header values.

The API key does not have permission to access the resource.
*/
type CreatePrivateEndpointForbidden struct {
	Payload *CreatePrivateEndpointForbiddenBody
}

// IsSuccess returns true when this create private endpoint forbidden response has a 2xx status code
func (o *CreatePrivateEndpointForbidden) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint forbidden response has a 3xx status code
func (o *CreatePrivateEndpointForbidden) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint forbidden response has a 4xx status code
func (o *CreatePrivateEndpointForbidden) IsClientError() bool {
	return true
}

// IsServerError returns true when this create private endpoint forbidden response has a 5xx status code
func (o *CreatePrivateEndpointForbidden) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint forbidden response a status code equal to that given
func (o *CreatePrivateEndpointForbidden) IsCode(code int) bool {
	return code == 403
}

// Code gets the status code for the create private endpoint forbidden response
func (o *CreatePrivateEndpointForbidden) Code() int {
	return 403
}

func (o *CreatePrivateEndpointForbidden) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointForbidden  %+v", 403, o.Payload)
}

func (o *CreatePrivateEndpointForbidden) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointForbidden  %+v", 403, o.Payload)
}

func (o *CreatePrivateEndpointForbidden) GetPayload() *CreatePrivateEndpointForbiddenBody {
	return o.Payload
}

func (o *CreatePrivateEndpointForbidden) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointForbiddenBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointNotFound creates a CreatePrivateEndpointNotFound with default headers values
func NewCreatePrivateEndpointNotFound() *CreatePrivateEndpointNotFound {
	return &CreatePrivateEndpointNotFound{}
}

/*
CreatePrivateEndpointNotFound describes a response with status code 404, with default header values.

The requested resource does not exist.
*/
type CreatePrivateEndpointNotFound struct {
	Payload *CreatePrivateEndpointNotFoundBody
}

// IsSuccess returns true when this create private endpoint not found response has a 2xx status code
func (o *CreatePrivateEndpointNotFound) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint not found response has a 3xx status code
func (o *CreatePrivateEndpointNotFound) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint not found response has a 4xx status code
func (o *CreatePrivateEndpointNotFound) IsClientError() bool {
	return true
}

// IsServerError returns true when this create private endpoint not found response has a 5xx status code
func (o *CreatePrivateEndpointNotFound) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint not found response a status code equal to that given
func (o *CreatePrivateEndpointNotFound) IsCode(code int) bool {
	return code == 404
}

// Code gets the status code for the create private endpoint not found response
func (o *CreatePrivateEndpointNotFound) Code() int {
	return 404
}

func (o *CreatePrivateEndpointNotFound) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointNotFound  %+v", 404, o.Payload)
}

func (o *CreatePrivateEndpointNotFound) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointNotFound  %+v", 404, o.Payload)
}

func (o *CreatePrivateEndpointNotFound) GetPayload() *CreatePrivateEndpointNotFoundBody {
	return o.Payload
}

func (o *CreatePrivateEndpointNotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointNotFoundBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointTooManyRequests creates a CreatePrivateEndpointTooManyRequests with default headers values
func NewCreatePrivateEndpointTooManyRequests() *CreatePrivateEndpointTooManyRequests {
	return &CreatePrivateEndpointTooManyRequests{}
}

/*
CreatePrivateEndpointTooManyRequests describes a response with status code 429, with default header values.

You have exceed the rate limit.
*/
type CreatePrivateEndpointTooManyRequests struct {
	Payload *CreatePrivateEndpointTooManyRequestsBody
}

// IsSuccess returns true when this create private endpoint too many requests response has a 2xx status code
func (o *CreatePrivateEndpointTooManyRequests) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint too many requests response has a 3xx status code
func (o *CreatePrivateEndpointTooManyRequests) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint too many requests response has a 4xx status code
func (o *CreatePrivateEndpointTooManyRequests) IsClientError() bool {
	return true
}

// IsServerError returns true when this create private endpoint too many requests response has a 5xx status code
func (o *CreatePrivateEndpointTooManyRequests) IsServerError() bool {
	return false
}

// IsCode returns true when this create private endpoint too many requests response a status code equal to that given
func (o *CreatePrivateEndpointTooManyRequests) IsCode(code int) bool {
	return code == 429
}

// Code gets the status code for the create private endpoint too many requests response
func (o *CreatePrivateEndpointTooManyRequests) Code() int {
	return 429
}

func (o *CreatePrivateEndpointTooManyRequests) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointTooManyRequests  %+v", 429, o.Payload)
}

func (o *CreatePrivateEndpointTooManyRequests) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointTooManyRequests  %+v", 429, o.Payload)
}

func (o *CreatePrivateEndpointTooManyRequests) GetPayload() *CreatePrivateEndpointTooManyRequestsBody {
	return o.Payload
}

func (o *CreatePrivateEndpointTooManyRequests) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointTooManyRequestsBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointInternalServerError creates a CreatePrivateEndpointInternalServerError with default headers values
func NewCreatePrivateEndpointInternalServerError() *CreatePrivateEndpointInternalServerError {
	return &CreatePrivateEndpointInternalServerError{}
}

/*
CreatePrivateEndpointInternalServerError describes a response with status code 500, with default header values.

Server error.
*/
type CreatePrivateEndpointInternalServerError struct {
	Payload *CreatePrivateEndpointInternalServerErrorBody
}

// IsSuccess returns true when this create private endpoint internal server error response has a 2xx status code
func (o *CreatePrivateEndpointInternalServerError) IsSuccess() bool {
	return false
}

// IsRedirect returns true when this create private endpoint internal server error response has a 3xx status code
func (o *CreatePrivateEndpointInternalServerError) IsRedirect() bool {
	return false
}

// IsClientError returns true when this create private endpoint internal server error response has a 4xx status code
func (o *CreatePrivateEndpointInternalServerError) IsClientError() bool {
	return false
}

// IsServerError returns true when this create private endpoint internal server error response has a 5xx status code
func (o *CreatePrivateEndpointInternalServerError) IsServerError() bool {
	return true
}

// IsCode returns true when this create private endpoint internal server error response a status code equal to that given
func (o *CreatePrivateEndpointInternalServerError) IsCode(code int) bool {
	return code == 500
}

// Code gets the status code for the create private endpoint internal server error response
func (o *CreatePrivateEndpointInternalServerError) Code() int {
	return 500
}

func (o *CreatePrivateEndpointInternalServerError) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointInternalServerError  %+v", 500, o.Payload)
}

func (o *CreatePrivateEndpointInternalServerError) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] createPrivateEndpointInternalServerError  %+v", 500, o.Payload)
}

func (o *CreatePrivateEndpointInternalServerError) GetPayload() *CreatePrivateEndpointInternalServerErrorBody {
	return o.Payload
}

func (o *CreatePrivateEndpointInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointInternalServerErrorBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewCreatePrivateEndpointDefault creates a CreatePrivateEndpointDefault with default headers values
func NewCreatePrivateEndpointDefault(code int) *CreatePrivateEndpointDefault {
	return &CreatePrivateEndpointDefault{
		_statusCode: code,
	}
}

/*
CreatePrivateEndpointDefault describes a response with status code -1, with default header values.

An unexpected error response.
*/
type CreatePrivateEndpointDefault struct {
	_statusCode int

	Payload *CreatePrivateEndpointDefaultBody
}

// IsSuccess returns true when this create private endpoint default response has a 2xx status code
func (o *CreatePrivateEndpointDefault) IsSuccess() bool {
	return o._statusCode/100 == 2
}

// IsRedirect returns true when this create private endpoint default response has a 3xx status code
func (o *CreatePrivateEndpointDefault) IsRedirect() bool {
	return o._statusCode/100 == 3
}

// IsClientError returns true when this create private endpoint default response has a 4xx status code
func (o *CreatePrivateEndpointDefault) IsClientError() bool {
	return o._statusCode/100 == 4
}

// IsServerError returns true when this create private endpoint default response has a 5xx status code
func (o *CreatePrivateEndpointDefault) IsServerError() bool {
	return o._statusCode/100 == 5
}

// IsCode returns true when this create private endpoint default response a status code equal to that given
func (o *CreatePrivateEndpointDefault) IsCode(code int) bool {
	return o._statusCode == code
}

// Code gets the status code for the create private endpoint default response
func (o *CreatePrivateEndpointDefault) Code() int {
	return o._statusCode
}

func (o *CreatePrivateEndpointDefault) Error() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] CreatePrivateEndpoint default  %+v", o._statusCode, o.Payload)
}

func (o *CreatePrivateEndpointDefault) String() string {
	return fmt.Sprintf("[POST /api/v1beta/projects/{project_id}/clusters/{cluster_id}/private_endpoints][%d] CreatePrivateEndpoint default  %+v", o._statusCode, o.Payload)
}

func (o *CreatePrivateEndpointDefault) GetPayload() *CreatePrivateEndpointDefaultBody {
	return o.Payload
}

func (o *CreatePrivateEndpointDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(CreatePrivateEndpointDefaultBody)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

/*
CreatePrivateEndpointBadRequestBody create private endpoint bad request body
swagger:model CreatePrivateEndpointBadRequestBody
*/
type CreatePrivateEndpointBadRequestBody struct {

	// code
	//
	// Error code returned with this error.
	Code int64 `json:"code,omitempty"`

	// details
	//
	// Error details returned with this error.
	Details []string `json:"details"`

	// message
	//
	// Error message returned with this error.
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint bad request body
func (o *CreatePrivateEndpointBadRequestBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint bad request body based on context it is used
func (o *CreatePrivateEndpointBadRequestBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointBadRequestBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointBadRequestBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointBadRequestBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointBody The endpoint resource to be created. Only the endpoint_name is required.
// Example: {"endpoint_name":"vpce-01234567890123456"}
swagger:model CreatePrivateEndpointBody
*/
type CreatePrivateEndpointBody struct {

	// [Output Only] The cloud provider on which the private endpoint service is hosted.
	// - `"AWS"`: the Amazon Web Services cloud provider
	// - `"GCP"`: the Google Cloud cloud provider
	// Example: AWS
	// Enum: [AWS GCP]
	CloudProvider string `json:"cloud_provider,omitempty"`

	// [Output Only] The ID of the cluster.
	// Example: 1
	ClusterID string `json:"cluster_id,omitempty"`

	// [Output Only] The name of the cluster.
	// Example: Cluster0
	ClusterName string `json:"cluster_name,omitempty"`

	// The format of the private endpoint name varies by cloud provider: `"vpce-xxxx"` for AWS and `"projects/xxx/regions/xxx/forwardingRules/xxx"` for Google Cloud.
	// Example: vpce-01234567890123456
	EndpointName string `json:"endpoint_name,omitempty"`

	// [Output Only] The ID of private endpoint. It is used when you [deleting the endpoint](#tag/Cluster/operation/DeletePrivateEndpoint).
	// Example: 1
	ID string `json:"id,omitempty"`

	// [Output Only] The detailed message when the `status` is "FAILED".
	// Example: The endpoint does not exist.
	Message string `json:"message,omitempty"`

	// [Output Only] The region where the private endpoint is hosted, such as Oregon in AWS.
	// Example: Oregon
	RegionName string `json:"region_name,omitempty"`

	// [Output Only] The service name of the private endpoint.
	// Example: com.amazonaws.vpce.us-west-2.vpce-svc-01234567890123456
	ServiceName string `json:"service_name,omitempty"`

	// [Output Only] The status of the private endpoint service.
	// Example: ACTIVE
	// Enum: [CREATING ACTIVE DELETING]
	ServiceStatus string `json:"service_status,omitempty"`

	// [Output Only] The status of the private endpoint.
	// Example: FAILED
	// Enum: [PENDING ACTIVE DELETING FAILED]
	Status string `json:"status,omitempty"`
}

// Validate validates this create private endpoint body
func (o *CreatePrivateEndpointBody) Validate(formats strfmt.Registry) error {
	var res []error

	if err := o.validateCloudProvider(formats); err != nil {
		res = append(res, err)
	}

	if err := o.validateServiceStatus(formats); err != nil {
		res = append(res, err)
	}

	if err := o.validateStatus(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var createPrivateEndpointBodyTypeCloudProviderPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["AWS","GCP"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointBodyTypeCloudProviderPropEnum = append(createPrivateEndpointBodyTypeCloudProviderPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointBodyCloudProviderAWS captures enum value "AWS"
	CreatePrivateEndpointBodyCloudProviderAWS string = "AWS"

	// CreatePrivateEndpointBodyCloudProviderGCP captures enum value "GCP"
	CreatePrivateEndpointBodyCloudProviderGCP string = "GCP"
)

// prop value enum
func (o *CreatePrivateEndpointBody) validateCloudProviderEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointBodyTypeCloudProviderPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointBody) validateCloudProvider(formats strfmt.Registry) error {
	if swag.IsZero(o.CloudProvider) { // not required
		return nil
	}

	// value enum
	if err := o.validateCloudProviderEnum("private_endpoint"+"."+"cloud_provider", "body", o.CloudProvider); err != nil {
		return err
	}

	return nil
}

var createPrivateEndpointBodyTypeServiceStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["CREATING","ACTIVE","DELETING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointBodyTypeServiceStatusPropEnum = append(createPrivateEndpointBodyTypeServiceStatusPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointBodyServiceStatusCREATING captures enum value "CREATING"
	CreatePrivateEndpointBodyServiceStatusCREATING string = "CREATING"

	// CreatePrivateEndpointBodyServiceStatusACTIVE captures enum value "ACTIVE"
	CreatePrivateEndpointBodyServiceStatusACTIVE string = "ACTIVE"

	// CreatePrivateEndpointBodyServiceStatusDELETING captures enum value "DELETING"
	CreatePrivateEndpointBodyServiceStatusDELETING string = "DELETING"
)

// prop value enum
func (o *CreatePrivateEndpointBody) validateServiceStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointBodyTypeServiceStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointBody) validateServiceStatus(formats strfmt.Registry) error {
	if swag.IsZero(o.ServiceStatus) { // not required
		return nil
	}

	// value enum
	if err := o.validateServiceStatusEnum("private_endpoint"+"."+"service_status", "body", o.ServiceStatus); err != nil {
		return err
	}

	return nil
}

var createPrivateEndpointBodyTypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["PENDING","ACTIVE","DELETING","FAILED"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointBodyTypeStatusPropEnum = append(createPrivateEndpointBodyTypeStatusPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointBodyStatusPENDING captures enum value "PENDING"
	CreatePrivateEndpointBodyStatusPENDING string = "PENDING"

	// CreatePrivateEndpointBodyStatusACTIVE captures enum value "ACTIVE"
	CreatePrivateEndpointBodyStatusACTIVE string = "ACTIVE"

	// CreatePrivateEndpointBodyStatusDELETING captures enum value "DELETING"
	CreatePrivateEndpointBodyStatusDELETING string = "DELETING"

	// CreatePrivateEndpointBodyStatusFAILED captures enum value "FAILED"
	CreatePrivateEndpointBodyStatusFAILED string = "FAILED"
)

// prop value enum
func (o *CreatePrivateEndpointBody) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointBodyTypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointBody) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(o.Status) { // not required
		return nil
	}

	// value enum
	if err := o.validateStatusEnum("private_endpoint"+"."+"status", "body", o.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this create private endpoint body based on context it is used
func (o *CreatePrivateEndpointBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointDefaultBody create private endpoint default body
swagger:model CreatePrivateEndpointDefaultBody
*/
type CreatePrivateEndpointDefaultBody struct {

	// code
	Code int32 `json:"code,omitempty"`

	// details
	Details []*CreatePrivateEndpointDefaultBodyDetailsItems0 `json:"details"`

	// message
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint default body
func (o *CreatePrivateEndpointDefaultBody) Validate(formats strfmt.Registry) error {
	var res []error

	if err := o.validateDetails(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (o *CreatePrivateEndpointDefaultBody) validateDetails(formats strfmt.Registry) error {
	if swag.IsZero(o.Details) { // not required
		return nil
	}

	for i := 0; i < len(o.Details); i++ {
		if swag.IsZero(o.Details[i]) { // not required
			continue
		}

		if o.Details[i] != nil {
			if err := o.Details[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("CreatePrivateEndpoint default" + "." + "details" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("CreatePrivateEndpoint default" + "." + "details" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// ContextValidate validate this create private endpoint default body based on the context it is used
func (o *CreatePrivateEndpointDefaultBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := o.contextValidateDetails(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (o *CreatePrivateEndpointDefaultBody) contextValidateDetails(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(o.Details); i++ {

		if o.Details[i] != nil {

			if swag.IsZero(o.Details[i]) { // not required
				return nil
			}

			if err := o.Details[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("CreatePrivateEndpoint default" + "." + "details" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("CreatePrivateEndpoint default" + "." + "details" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointDefaultBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointDefaultBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointDefaultBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointDefaultBodyDetailsItems0 create private endpoint default body details items0
swagger:model CreatePrivateEndpointDefaultBodyDetailsItems0
*/
type CreatePrivateEndpointDefaultBodyDetailsItems0 struct {

	// at type
	AtType string `json:"@type,omitempty"`
}

// Validate validates this create private endpoint default body details items0
func (o *CreatePrivateEndpointDefaultBodyDetailsItems0) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint default body details items0 based on context it is used
func (o *CreatePrivateEndpointDefaultBodyDetailsItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointDefaultBodyDetailsItems0) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointDefaultBodyDetailsItems0) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointDefaultBodyDetailsItems0
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointForbiddenBody create private endpoint forbidden body
swagger:model CreatePrivateEndpointForbiddenBody
*/
type CreatePrivateEndpointForbiddenBody struct {

	// code
	//
	// Error code returned with this error.
	Code int64 `json:"code,omitempty"`

	// details
	//
	// Error details returned with this error.
	Details []string `json:"details"`

	// message
	//
	// Error message returned with this error.
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint forbidden body
func (o *CreatePrivateEndpointForbiddenBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint forbidden body based on context it is used
func (o *CreatePrivateEndpointForbiddenBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointForbiddenBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointForbiddenBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointForbiddenBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointInternalServerErrorBody create private endpoint internal server error body
swagger:model CreatePrivateEndpointInternalServerErrorBody
*/
type CreatePrivateEndpointInternalServerErrorBody struct {

	// code
	//
	// Error code returned with this error.
	Code int64 `json:"code,omitempty"`

	// details
	//
	// Error details returned with this error.
	Details []string `json:"details"`

	// message
	//
	// Error message returned with this error.
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint internal server error body
func (o *CreatePrivateEndpointInternalServerErrorBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint internal server error body based on context it is used
func (o *CreatePrivateEndpointInternalServerErrorBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointInternalServerErrorBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointInternalServerErrorBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointInternalServerErrorBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointNotFoundBody create private endpoint not found body
swagger:model CreatePrivateEndpointNotFoundBody
*/
type CreatePrivateEndpointNotFoundBody struct {

	// code
	//
	// Error code returned with this error.
	Code int64 `json:"code,omitempty"`

	// details
	//
	// Error details returned with this error.
	Details []string `json:"details"`

	// message
	//
	// Error message returned with this error.
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint not found body
func (o *CreatePrivateEndpointNotFoundBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint not found body based on context it is used
func (o *CreatePrivateEndpointNotFoundBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointNotFoundBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointNotFoundBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointNotFoundBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointOKBody CreatePrivateEndpointResp
//
// CreatePrivateEndpointResp is the response for creating a private endpoint for a private endpoint service.
swagger:model CreatePrivateEndpointOKBody
*/
type CreatePrivateEndpointOKBody struct {

	// private endpoint
	// Required: true
	PrivateEndpoint *CreatePrivateEndpointOKBodyPrivateEndpoint `json:"private_endpoint"`
}

// Validate validates this create private endpoint o k body
func (o *CreatePrivateEndpointOKBody) Validate(formats strfmt.Registry) error {
	var res []error

	if err := o.validatePrivateEndpoint(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (o *CreatePrivateEndpointOKBody) validatePrivateEndpoint(formats strfmt.Registry) error {

	if err := validate.Required("createPrivateEndpointOK"+"."+"private_endpoint", "body", o.PrivateEndpoint); err != nil {
		return err
	}

	if o.PrivateEndpoint != nil {
		if err := o.PrivateEndpoint.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateEndpointOK" + "." + "private_endpoint")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateEndpointOK" + "." + "private_endpoint")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this create private endpoint o k body based on the context it is used
func (o *CreatePrivateEndpointOKBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := o.contextValidatePrivateEndpoint(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (o *CreatePrivateEndpointOKBody) contextValidatePrivateEndpoint(ctx context.Context, formats strfmt.Registry) error {

	if o.PrivateEndpoint != nil {

		if err := o.PrivateEndpoint.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateEndpointOK" + "." + "private_endpoint")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateEndpointOK" + "." + "private_endpoint")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointOKBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointOKBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointOKBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointOKBodyPrivateEndpoint The newly endpoint created resource.
swagger:model CreatePrivateEndpointOKBodyPrivateEndpoint
*/
type CreatePrivateEndpointOKBodyPrivateEndpoint struct {

	// [Output Only] The cloud provider on which the private endpoint service is hosted.
	// - `"AWS"`: the Amazon Web Services cloud provider
	// - `"GCP"`: the Google Cloud cloud provider
	// Example: AWS
	// Enum: [AWS GCP]
	CloudProvider string `json:"cloud_provider,omitempty"`

	// [Output Only] The ID of the cluster.
	// Example: 1
	ClusterID string `json:"cluster_id,omitempty"`

	// [Output Only] The name of the cluster.
	// Example: Cluster0
	ClusterName string `json:"cluster_name,omitempty"`

	// The format of the private endpoint name varies by cloud provider: `"vpce-xxxx"` for AWS and `"projects/xxx/regions/xxx/forwardingRules/xxx"` for Google Cloud.
	// Example: vpce-01234567890123456
	EndpointName string `json:"endpoint_name,omitempty"`

	// [Output Only] The ID of private endpoint. It is used when you [deleting the endpoint](#tag/Cluster/operation/DeletePrivateEndpoint).
	// Example: 1
	ID string `json:"id,omitempty"`

	// [Output Only] The detailed message when the `status` is "FAILED".
	// Example: The endpoint does not exist.
	Message string `json:"message,omitempty"`

	// [Output Only] The region where the private endpoint is hosted, such as Oregon in AWS.
	// Example: Oregon
	RegionName string `json:"region_name,omitempty"`

	// [Output Only] The service name of the private endpoint.
	// Example: com.amazonaws.vpce.us-west-2.vpce-svc-01234567890123456
	ServiceName string `json:"service_name,omitempty"`

	// [Output Only] The status of the private endpoint service.
	// Example: ACTIVE
	// Enum: [CREATING ACTIVE DELETING]
	ServiceStatus string `json:"service_status,omitempty"`

	// [Output Only] The status of the private endpoint.
	// Example: FAILED
	// Enum: [PENDING ACTIVE DELETING FAILED]
	Status string `json:"status,omitempty"`
}

// Validate validates this create private endpoint o k body private endpoint
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) Validate(formats strfmt.Registry) error {
	var res []error

	if err := o.validateCloudProvider(formats); err != nil {
		res = append(res, err)
	}

	if err := o.validateServiceStatus(formats); err != nil {
		res = append(res, err)
	}

	if err := o.validateStatus(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

var createPrivateEndpointOKBodyPrivateEndpointTypeCloudProviderPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["AWS","GCP"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointOKBodyPrivateEndpointTypeCloudProviderPropEnum = append(createPrivateEndpointOKBodyPrivateEndpointTypeCloudProviderPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointOKBodyPrivateEndpointCloudProviderAWS captures enum value "AWS"
	CreatePrivateEndpointOKBodyPrivateEndpointCloudProviderAWS string = "AWS"

	// CreatePrivateEndpointOKBodyPrivateEndpointCloudProviderGCP captures enum value "GCP"
	CreatePrivateEndpointOKBodyPrivateEndpointCloudProviderGCP string = "GCP"
)

// prop value enum
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateCloudProviderEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointOKBodyPrivateEndpointTypeCloudProviderPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateCloudProvider(formats strfmt.Registry) error {
	if swag.IsZero(o.CloudProvider) { // not required
		return nil
	}

	// value enum
	if err := o.validateCloudProviderEnum("createPrivateEndpointOK"+"."+"private_endpoint"+"."+"cloud_provider", "body", o.CloudProvider); err != nil {
		return err
	}

	return nil
}

var createPrivateEndpointOKBodyPrivateEndpointTypeServiceStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["CREATING","ACTIVE","DELETING"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointOKBodyPrivateEndpointTypeServiceStatusPropEnum = append(createPrivateEndpointOKBodyPrivateEndpointTypeServiceStatusPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusCREATING captures enum value "CREATING"
	CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusCREATING string = "CREATING"

	// CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusACTIVE captures enum value "ACTIVE"
	CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusACTIVE string = "ACTIVE"

	// CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusDELETING captures enum value "DELETING"
	CreatePrivateEndpointOKBodyPrivateEndpointServiceStatusDELETING string = "DELETING"
)

// prop value enum
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateServiceStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointOKBodyPrivateEndpointTypeServiceStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateServiceStatus(formats strfmt.Registry) error {
	if swag.IsZero(o.ServiceStatus) { // not required
		return nil
	}

	// value enum
	if err := o.validateServiceStatusEnum("createPrivateEndpointOK"+"."+"private_endpoint"+"."+"service_status", "body", o.ServiceStatus); err != nil {
		return err
	}

	return nil
}

var createPrivateEndpointOKBodyPrivateEndpointTypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["PENDING","ACTIVE","DELETING","FAILED"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createPrivateEndpointOKBodyPrivateEndpointTypeStatusPropEnum = append(createPrivateEndpointOKBodyPrivateEndpointTypeStatusPropEnum, v)
	}
}

const (

	// CreatePrivateEndpointOKBodyPrivateEndpointStatusPENDING captures enum value "PENDING"
	CreatePrivateEndpointOKBodyPrivateEndpointStatusPENDING string = "PENDING"

	// CreatePrivateEndpointOKBodyPrivateEndpointStatusACTIVE captures enum value "ACTIVE"
	CreatePrivateEndpointOKBodyPrivateEndpointStatusACTIVE string = "ACTIVE"

	// CreatePrivateEndpointOKBodyPrivateEndpointStatusDELETING captures enum value "DELETING"
	CreatePrivateEndpointOKBodyPrivateEndpointStatusDELETING string = "DELETING"

	// CreatePrivateEndpointOKBodyPrivateEndpointStatusFAILED captures enum value "FAILED"
	CreatePrivateEndpointOKBodyPrivateEndpointStatusFAILED string = "FAILED"
)

// prop value enum
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateStatusEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, createPrivateEndpointOKBodyPrivateEndpointTypeStatusPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(o.Status) { // not required
		return nil
	}

	// value enum
	if err := o.validateStatusEnum("createPrivateEndpointOK"+"."+"private_endpoint"+"."+"status", "body", o.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this create private endpoint o k body private endpoint based on context it is used
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointOKBodyPrivateEndpoint) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointOKBodyPrivateEndpoint
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}

/*
CreatePrivateEndpointTooManyRequestsBody create private endpoint too many requests body
swagger:model CreatePrivateEndpointTooManyRequestsBody
*/
type CreatePrivateEndpointTooManyRequestsBody struct {

	// code
	//
	// Error code returned with this error.
	Code int64 `json:"code,omitempty"`

	// details
	//
	// Error details returned with this error.
	Details []string `json:"details"`

	// message
	//
	// Error message returned with this error.
	Message string `json:"message,omitempty"`
}

// Validate validates this create private endpoint too many requests body
func (o *CreatePrivateEndpointTooManyRequestsBody) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this create private endpoint too many requests body based on context it is used
func (o *CreatePrivateEndpointTooManyRequestsBody) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (o *CreatePrivateEndpointTooManyRequestsBody) MarshalBinary() ([]byte, error) {
	if o == nil {
		return nil, nil
	}
	return swag.WriteJSON(o)
}

// UnmarshalBinary interface implementation
func (o *CreatePrivateEndpointTooManyRequestsBody) UnmarshalBinary(b []byte) error {
	var res CreatePrivateEndpointTooManyRequestsBody
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*o = res
	return nil
}