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

package cluster_service

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

import (
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new cluster service API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for cluster service API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	CalcClusterFee(params *CalcClusterFeeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CalcClusterFeeOK, error)

	CalcNodeProfiles(params *CalcNodeProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CalcNodeProfilesOK, error)

	ChangeClusterName(params *ChangeClusterNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ChangeClusterNameOK, error)

	ChangePassword(params *ChangePasswordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ChangePasswordOK, error)

	ClusterServiceCheckAuditLogPluginStatus(params *ClusterServiceCheckAuditLogPluginStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceCheckAuditLogPluginStatusOK, error)

	ClusterServiceCreateAuditLogAccessRecord(params *ClusterServiceCreateAuditLogAccessRecordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceCreateAuditLogAccessRecordOK, error)

	ClusterServiceDeleteAuditLogAccessRecord(params *ClusterServiceDeleteAuditLogAccessRecordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceDeleteAuditLogAccessRecordOK, error)

	ClusterServiceGetAuditLogAccessRecords(params *ClusterServiceGetAuditLogAccessRecordsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetAuditLogAccessRecordsOK, error)

	ClusterServiceGetAuditLogStatus(params *ClusterServiceGetAuditLogStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetAuditLogStatusOK, error)

	ClusterServiceGetProjectCIDRWithoutRegion(params *ClusterServiceGetProjectCIDRWithoutRegionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetProjectCIDRWithoutRegionOK, error)

	ClusterServicePrecheckAuditLogConfig(params *ClusterServicePrecheckAuditLogConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServicePrecheckAuditLogConfigOK, error)

	ClusterServiceUpdateAuditLogStatus(params *ClusterServiceUpdateAuditLogStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceUpdateAuditLogStatusOK, error)

	CreateAWSVpcPeering(params *CreateAWSVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateAWSVpcPeeringOK, error)

	CreateClusterV2(params *CreateClusterV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateClusterV2OK, error)

	CreateGcpVpcPeering(params *CreateGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateGcpVpcPeeringOK, error)

	CreatePrivateEndpoint(params *CreatePrivateEndpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePrivateEndpointOK, error)

	CreateProjectCIDR(params *CreateProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateProjectCIDROK, error)

	DeleteAwsVpcPeering(params *DeleteAwsVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteAwsVpcPeeringOK, error)

	DeleteCluster(params *DeleteClusterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteClusterOK, error)

	DeleteGcpVpcPeering(params *DeleteGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteGcpVpcPeeringOK, error)

	GenClusterName(params *GenClusterNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GenClusterNameOK, error)

	GetAwsVpcPeering(params *GetAwsVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetAwsVpcPeeringOK, error)

	GetCluster(params *GetClusterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetClusterOK, error)

	GetGcpVpcPeering(params *GetGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetGcpVpcPeeringOK, error)

	GetPrivateEndpoint(params *GetPrivateEndpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPrivateEndpointOK, error)

	GetProjectCIDR(params *GetProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetProjectCIDROK, error)

	GetProjectRegionCIDR(params *GetProjectRegionCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetProjectRegionCIDROK, error)

	GetSecondaryClusterProfiles(params *GetSecondaryClusterProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSecondaryClusterProfilesOK, error)

	GetTiDBNodes(params *GetTiDBNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiDBNodesOK, error)

	GetTiFlashNodes(params *GetTiFlashNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiFlashNodesOK, error)

	GetTiKVNodes(params *GetTiKVNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiKVNodesOK, error)

	GetTrafficFilter(params *GetTrafficFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTrafficFilterOK, error)

	ListAwsVpcPeerings(params *ListAwsVpcPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListAwsVpcPeeringsOK, error)

	ListCloudProviders(params *ListCloudProvidersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListCloudProvidersOK, error)

	ListClusters(params *ListClustersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListClustersOK, error)

	ListDeletedClusters(params *ListDeletedClustersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDeletedClustersOK, error)

	ListGcpVpcPeerings(params *ListGcpVpcPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListGcpVpcPeeringsOK, error)

	MakeClusterWritable(params *MakeClusterWritableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*MakeClusterWritableOK, error)

	ScaleClusterV2(params *ScaleClusterV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ScaleClusterV2OK, error)

	SendPasswordVerifyCode(params *SendPasswordVerifyCodeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendPasswordVerifyCodeOK, error)

	UpdateTrafficFilter(params *UpdateTrafficFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateTrafficFilterOK, error)

	ValidateProjectCIDR(params *ValidateProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ValidateProjectCIDROK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  CalcClusterFee calc cluster fee API
*/
func (a *Client) CalcClusterFee(params *CalcClusterFeeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CalcClusterFeeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCalcClusterFeeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CalcClusterFee",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/cluster_fee/query",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CalcClusterFeeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CalcClusterFeeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CalcClusterFeeDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CalcNodeProfiles calc node profiles API
*/
func (a *Client) CalcNodeProfiles(params *CalcNodeProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CalcNodeProfilesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCalcNodeProfilesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CalcNodeProfiles",
		Method:             "POST",
		PathPattern:        "/api/v1/node_profiles/query",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CalcNodeProfilesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CalcNodeProfilesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CalcNodeProfilesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ChangeClusterName change cluster name API
*/
func (a *Client) ChangeClusterName(params *ChangeClusterNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ChangeClusterNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewChangeClusterNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ChangeClusterName",
		Method:             "PATCH",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ChangeClusterNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ChangeClusterNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ChangeClusterNameDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ChangePassword change password API
*/
func (a *Client) ChangePassword(params *ChangePasswordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ChangePasswordOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewChangePasswordParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ChangePassword",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/password",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ChangePasswordReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ChangePasswordOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ChangePasswordDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceCheckAuditLogPluginStatus cluster service check audit log plugin status API
*/
func (a *Client) ClusterServiceCheckAuditLogPluginStatus(params *ClusterServiceCheckAuditLogPluginStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceCheckAuditLogPluginStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceCheckAuditLogPluginStatusParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_CheckAuditLogPluginStatus",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log/plugin_status",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceCheckAuditLogPluginStatusReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceCheckAuditLogPluginStatusOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceCheckAuditLogPluginStatusDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceCreateAuditLogAccessRecord cluster service create audit log access record API
*/
func (a *Client) ClusterServiceCreateAuditLogAccessRecord(params *ClusterServiceCreateAuditLogAccessRecordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceCreateAuditLogAccessRecordOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceCreateAuditLogAccessRecordParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_CreateAuditLogAccessRecord",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log/access_records",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceCreateAuditLogAccessRecordReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceCreateAuditLogAccessRecordOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceCreateAuditLogAccessRecordDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceDeleteAuditLogAccessRecord cluster service delete audit log access record API
*/
func (a *Client) ClusterServiceDeleteAuditLogAccessRecord(params *ClusterServiceDeleteAuditLogAccessRecordParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceDeleteAuditLogAccessRecordOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceDeleteAuditLogAccessRecordParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_DeleteAuditLogAccessRecord",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log/access_records/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceDeleteAuditLogAccessRecordReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceDeleteAuditLogAccessRecordOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceDeleteAuditLogAccessRecordDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceGetAuditLogAccessRecords cluster service get audit log access records API
*/
func (a *Client) ClusterServiceGetAuditLogAccessRecords(params *ClusterServiceGetAuditLogAccessRecordsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetAuditLogAccessRecordsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceGetAuditLogAccessRecordsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_GetAuditLogAccessRecords",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log/access_records",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceGetAuditLogAccessRecordsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceGetAuditLogAccessRecordsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceGetAuditLogAccessRecordsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceGetAuditLogStatus cluster service get audit log status API
*/
func (a *Client) ClusterServiceGetAuditLogStatus(params *ClusterServiceGetAuditLogStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetAuditLogStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceGetAuditLogStatusParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_GetAuditLogStatus",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceGetAuditLogStatusReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceGetAuditLogStatusOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceGetAuditLogStatusDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceGetProjectCIDRWithoutRegion ins the frontend we ll call the c ID r API with u r ls like api v1 orgs 1 projects 1 aws cidr but in the API gate way this URL will be normalized to api v1 orgs 1 projects 1 aws cidr so we need to add a route for this URL
*/
func (a *Client) ClusterServiceGetProjectCIDRWithoutRegion(params *ClusterServiceGetProjectCIDRWithoutRegionParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceGetProjectCIDRWithoutRegionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceGetProjectCIDRWithoutRegionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_GetProjectCIDRWithoutRegion",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/{provider}/cidr",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceGetProjectCIDRWithoutRegionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceGetProjectCIDRWithoutRegionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceGetProjectCIDRWithoutRegionDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServicePrecheckAuditLogConfig cluster service precheck audit log config API
*/
func (a *Client) ClusterServicePrecheckAuditLogConfig(params *ClusterServicePrecheckAuditLogConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServicePrecheckAuditLogConfigOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServicePrecheckAuditLogConfigParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_PrecheckAuditLogConfig",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log/precheck",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServicePrecheckAuditLogConfigReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServicePrecheckAuditLogConfigOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServicePrecheckAuditLogConfigDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ClusterServiceUpdateAuditLogStatus cluster service update audit log status API
*/
func (a *Client) ClusterServiceUpdateAuditLogStatus(params *ClusterServiceUpdateAuditLogStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ClusterServiceUpdateAuditLogStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewClusterServiceUpdateAuditLogStatusParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ClusterService_UpdateAuditLogStatus",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/audit_log",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ClusterServiceUpdateAuditLogStatusReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ClusterServiceUpdateAuditLogStatusOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ClusterServiceUpdateAuditLogStatusDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateAWSVpcPeering create a w s vpc peering API
*/
func (a *Client) CreateAWSVpcPeering(params *CreateAWSVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateAWSVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateAWSVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateAWSVpcPeering",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/aws_vpc_peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateAWSVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateAWSVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateAWSVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateClusterV2 create cluster v2 API
*/
func (a *Client) CreateClusterV2(params *CreateClusterV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateClusterV2OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateClusterV2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateClusterV2",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clustersv2",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateClusterV2Reader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateClusterV2OK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateClusterV2Default)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateGcpVpcPeering create gcp vpc peering API
*/
func (a *Client) CreateGcpVpcPeering(params *CreateGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateGcpVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateGcpVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateGcpVpcPeering",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/gcp_vpc_peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateGcpVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateGcpVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateGcpVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreatePrivateEndpoint create private endpoint API
*/
func (a *Client) CreatePrivateEndpoint(params *CreatePrivateEndpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePrivateEndpointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePrivateEndpointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreatePrivateEndpoint",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/connections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreatePrivateEndpointReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreatePrivateEndpointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreatePrivateEndpointDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  CreateProjectCIDR create project c ID r API
*/
func (a *Client) CreateProjectCIDR(params *CreateProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateProjectCIDROK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateProjectCIDRParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateProjectCIDR",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/{provider}/cidr",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateProjectCIDRReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CreateProjectCIDROK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateProjectCIDRDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  DeleteAwsVpcPeering delete aws vpc peering API
*/
func (a *Client) DeleteAwsVpcPeering(params *DeleteAwsVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteAwsVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAwsVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteAwsVpcPeering",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/aws_vpc_peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteAwsVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteAwsVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteAwsVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  DeleteCluster delete cluster API
*/
func (a *Client) DeleteCluster(params *DeleteClusterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteClusterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteClusterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteCluster",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteClusterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteClusterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteClusterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  DeleteGcpVpcPeering delete gcp vpc peering API
*/
func (a *Client) DeleteGcpVpcPeering(params *DeleteGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteGcpVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteGcpVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteGcpVpcPeering",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/gcp_vpc_peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteGcpVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteGcpVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteGcpVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GenClusterName gen cluster name API
*/
func (a *Client) GenClusterName(params *GenClusterNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GenClusterNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGenClusterNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GenClusterName",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/names",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GenClusterNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GenClusterNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GenClusterNameDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetAwsVpcPeering get aws vpc peering API
*/
func (a *Client) GetAwsVpcPeering(params *GetAwsVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetAwsVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAwsVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetAwsVpcPeering",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/aws_vpc_peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetAwsVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetAwsVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetAwsVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetCluster get cluster API
*/
func (a *Client) GetCluster(params *GetClusterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetClusterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetClusterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetCluster",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetClusterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetClusterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetClusterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetGcpVpcPeering get gcp vpc peering API
*/
func (a *Client) GetGcpVpcPeering(params *GetGcpVpcPeeringParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetGcpVpcPeeringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetGcpVpcPeeringParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetGcpVpcPeering",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/gcp_vpc_peerings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetGcpVpcPeeringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetGcpVpcPeeringOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetGcpVpcPeeringDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetPrivateEndpoint get private endpoint API
*/
func (a *Client) GetPrivateEndpoint(params *GetPrivateEndpointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPrivateEndpointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPrivateEndpointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetPrivateEndpoint",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/connections",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPrivateEndpointReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPrivateEndpointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetPrivateEndpointDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetProjectCIDR get project c ID r API
*/
func (a *Client) GetProjectCIDR(params *GetProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetProjectCIDROK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetProjectCIDRParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetProjectCIDR",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/{provider}/{region}/cidr",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetProjectCIDRReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetProjectCIDROK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetProjectCIDRDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetProjectRegionCIDR get project region c ID r API
*/
func (a *Client) GetProjectRegionCIDR(params *GetProjectRegionCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetProjectRegionCIDROK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetProjectRegionCIDRParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetProjectRegionCIDR",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/cidr/regions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetProjectRegionCIDRReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetProjectRegionCIDROK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetProjectRegionCIDRDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetSecondaryClusterProfiles get secondary cluster profiles API
*/
func (a *Client) GetSecondaryClusterProfiles(params *GetSecondaryClusterProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSecondaryClusterProfilesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSecondaryClusterProfilesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetSecondaryClusterProfiles",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{id}/secondary_cluster_profiles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSecondaryClusterProfilesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSecondaryClusterProfilesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetSecondaryClusterProfilesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetTiDBNodes get ti d b nodes API
*/
func (a *Client) GetTiDBNodes(params *GetTiDBNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiDBNodesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTiDBNodesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetTiDBNodes",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/tidb_nodes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetTiDBNodesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTiDBNodesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetTiDBNodesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetTiFlashNodes get ti flash nodes API
*/
func (a *Client) GetTiFlashNodes(params *GetTiFlashNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiFlashNodesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTiFlashNodesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetTiFlashNodes",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/tiflash_nodes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetTiFlashNodesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTiFlashNodesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetTiFlashNodesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetTiKVNodes get ti k v nodes API
*/
func (a *Client) GetTiKVNodes(params *GetTiKVNodesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTiKVNodesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTiKVNodesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetTiKVNodes",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/tikv_nodes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetTiKVNodesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTiKVNodesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetTiKVNodesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  GetTrafficFilter get traffic filter API
*/
func (a *Client) GetTrafficFilter(params *GetTrafficFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetTrafficFilterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTrafficFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetTrafficFilter",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/traffic_filter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetTrafficFilterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTrafficFilterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetTrafficFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListAwsVpcPeerings list aws vpc peerings API
*/
func (a *Client) ListAwsVpcPeerings(params *ListAwsVpcPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListAwsVpcPeeringsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListAwsVpcPeeringsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListAwsVpcPeerings",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/aws_vpc_peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListAwsVpcPeeringsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListAwsVpcPeeringsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListAwsVpcPeeringsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListCloudProviders list cloud providers API
*/
func (a *Client) ListCloudProviders(params *ListCloudProvidersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListCloudProvidersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListCloudProvidersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListCloudProviders",
		Method:             "POST",
		PathPattern:        "/api/v1/cloud_providers/query",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListCloudProvidersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListCloudProvidersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListCloudProvidersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListClusters list clusters API
*/
func (a *Client) ListClusters(params *ListClustersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListClustersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListClustersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListClusters",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListClustersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListClustersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListClustersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListDeletedClusters list deleted clusters API
*/
func (a *Client) ListDeletedClusters(params *ListDeletedClustersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListDeletedClustersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListDeletedClustersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListDeletedClusters",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/recycle-bin",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListDeletedClustersReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListDeletedClustersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListDeletedClustersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ListGcpVpcPeerings list gcp vpc peerings API
*/
func (a *Client) ListGcpVpcPeerings(params *ListGcpVpcPeeringsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListGcpVpcPeeringsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListGcpVpcPeeringsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListGcpVpcPeerings",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/gcp_vpc_peerings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListGcpVpcPeeringsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ListGcpVpcPeeringsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListGcpVpcPeeringsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  MakeClusterWritable make cluster writable API
*/
func (a *Client) MakeClusterWritable(params *MakeClusterWritableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*MakeClusterWritableOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewMakeClusterWritableParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "MakeClusterWritable",
		Method:             "PATCH",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/writable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &MakeClusterWritableReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*MakeClusterWritableOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*MakeClusterWritableDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ScaleClusterV2 scale cluster v2 API
*/
func (a *Client) ScaleClusterV2(params *ScaleClusterV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ScaleClusterV2OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewScaleClusterV2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "ScaleClusterV2",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clustersv2/{cluster_id}/components",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ScaleClusterV2Reader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ScaleClusterV2OK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ScaleClusterV2Default)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  SendPasswordVerifyCode deprecateds deprecated by chenfei at 2022 06 07
*/
func (a *Client) SendPasswordVerifyCode(params *SendPasswordVerifyCodeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendPasswordVerifyCodeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSendPasswordVerifyCodeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "SendPasswordVerifyCode",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/password-verify-code",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &SendPasswordVerifyCodeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*SendPasswordVerifyCodeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*SendPasswordVerifyCodeDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  UpdateTrafficFilter update traffic filter API
*/
func (a *Client) UpdateTrafficFilter(params *UpdateTrafficFilterParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateTrafficFilterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateTrafficFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateTrafficFilter",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/traffic_filter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateTrafficFilterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*UpdateTrafficFilterOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateTrafficFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ValidateProjectCIDR validate project c ID r API
*/
func (a *Client) ValidateProjectCIDR(params *ValidateProjectCIDRParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ValidateProjectCIDROK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewValidateProjectCIDRParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ValidateProjectCIDR",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/{provider}/cidr/validation/query",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ValidateProjectCIDRReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*ValidateProjectCIDROK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ValidateProjectCIDRDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}