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

package user_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"
	httptransport "github.com/go-openapi/runtime/client"
	"github.com/go-openapi/strfmt"
)

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

// New creates a new user service API client with basic auth credentials.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - user: user for basic authentication header.
// - password: password for basic authentication header.
func NewClientWithBasicAuth(host, basePath, scheme, user, password string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BasicAuth(user, password)
	return &Client{transport: transport, formats: strfmt.Default}
}

// New creates a new user service API client with a bearer token for authentication.
// It takes the following parameters:
// - host: http host (github.com).
// - basePath: any base path for the API client ("/v1", "/v3").
// - scheme: http scheme ("http", "https").
// - bearerToken: bearer token for Bearer authentication header.
func NewClientWithBearerToken(host, basePath, scheme, bearerToken string) ClientService {
	transport := httptransport.New(host, basePath, []string{scheme})
	transport.DefaultAuthentication = httptransport.BearerToken(bearerToken)
	return &Client{transport: transport, formats: strfmt.Default}
}

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

// ClientOption may be used to customize the behavior of Client methods.
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	CreateJsmTicket(params *CreateJsmTicketParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateJsmTicketOK, error)

	CreatePlgOnBoardingSurvey(params *CreatePlgOnBoardingSurveyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePlgOnBoardingSurveyOK, error)

	CreateSQLUser(params *CreateSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateSQLUserOK, error)

	CreateUserVisitHistory(params *CreateUserVisitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateUserVisitHistoryOK, error)

	DeleteSQLUser(params *DeleteSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSQLUserOK, error)

	GetJsmTicketParamInfo(params *GetJsmTicketParamInfoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetJsmTicketParamInfoOK, error)

	GetUserLastVisitHistory(params *GetUserLastVisitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserLastVisitHistoryOK, error)

	GetUserLoginExtInfo(params *GetUserLoginExtInfoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserLoginExtInfoOK, error)

	GetUserOrgsProjects(params *GetUserOrgsProjectsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserOrgsProjectsOK, error)

	GetUserProfileV2(params *GetUserProfileV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserProfileV2OK, error)

	GetUserServicesAgreement(params *GetUserServicesAgreementParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserServicesAgreementOK, error)

	GetUserUIPrivileges(params *GetUserUIPrivilegesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserUIPrivilegesOK, error)

	ListSQLUsers(params *ListSQLUsersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListSQLUsersOK, error)

	QuerySQLUser(params *QuerySQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*QuerySQLUserOK, error)

	SaveUserServicesAgreement(params *SaveUserServicesAgreementParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SaveUserServicesAgreementOK, error)

	UpdateSQLUser(params *UpdateSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateSQLUserOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
CreateJsmTicket create jsm ticket API
*/
func (a *Client) CreateJsmTicket(params *CreateJsmTicketParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateJsmTicketOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateJsmTicketParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateJsmTicket",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/support/create",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateJsmTicketReader{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.(*CreateJsmTicketOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateJsmTicketDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreatePlgOnBoardingSurvey create plg on boarding survey API
*/
func (a *Client) CreatePlgOnBoardingSurvey(params *CreatePlgOnBoardingSurveyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePlgOnBoardingSurveyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePlgOnBoardingSurveyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreatePlgOnBoardingSurvey",
		Method:             "POST",
		PathPattern:        "/api/v1/user/plg-on-boarding-survey/create",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreatePlgOnBoardingSurveyReader{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.(*CreatePlgOnBoardingSurveyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreatePlgOnBoardingSurveyDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateSQLUser create Sql user API
*/
func (a *Client) CreateSQLUser(params *CreateSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateSQLUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateSQLUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateSqlUser",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/sql-user/create",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateSQLUserReader{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.(*CreateSQLUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateSQLUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreateUserVisitHistory create user visit history API
*/
func (a *Client) CreateUserVisitHistory(params *CreateUserVisitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateUserVisitHistoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateUserVisitHistoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "CreateUserVisitHistory",
		Method:             "POST",
		PathPattern:        "/api/v1/user/history/user-visit",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateUserVisitHistoryReader{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.(*CreateUserVisitHistoryOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateUserVisitHistoryDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteSQLUser delete Sql user API
*/
func (a *Client) DeleteSQLUser(params *DeleteSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSQLUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSQLUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteSqlUser",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/sql-user/delete",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSQLUserReader{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.(*DeleteSQLUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteSQLUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetJsmTicketParamInfo get jsm ticket param info API
*/
func (a *Client) GetJsmTicketParamInfo(params *GetJsmTicketParamInfoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetJsmTicketParamInfoOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetJsmTicketParamInfoParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetJsmTicketParamInfo",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/support/preload",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetJsmTicketParamInfoReader{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.(*GetJsmTicketParamInfoOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetJsmTicketParamInfoDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserLastVisitHistory get user last visit history API
*/
func (a *Client) GetUserLastVisitHistory(params *GetUserLastVisitHistoryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserLastVisitHistoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserLastVisitHistoryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserLastVisitHistory",
		Method:             "GET",
		PathPattern:        "/api/v1/user/history/user-visit",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserLastVisitHistoryReader{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.(*GetUserLastVisitHistoryOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserLastVisitHistoryDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserLoginExtInfo get user login ext info API
*/
func (a *Client) GetUserLoginExtInfo(params *GetUserLoginExtInfoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserLoginExtInfoOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserLoginExtInfoParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserLoginExtInfo",
		Method:             "GET",
		PathPattern:        "/api/v1/user/user-ext",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserLoginExtInfoReader{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.(*GetUserLoginExtInfoOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserLoginExtInfoDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserOrgsProjects get user orgs projects API
*/
func (a *Client) GetUserOrgsProjects(params *GetUserOrgsProjectsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserOrgsProjectsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserOrgsProjectsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserOrgsProjects",
		Method:             "GET",
		PathPattern:        "/api/v1/user/scope",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserOrgsProjectsReader{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.(*GetUserOrgsProjectsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserOrgsProjectsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserProfileV2 get user profile v2 API
*/
func (a *Client) GetUserProfileV2(params *GetUserProfileV2Params, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserProfileV2OK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserProfileV2Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserProfileV2",
		Method:             "GET",
		PathPattern:        "/api/v1/user/me",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserProfileV2Reader{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.(*GetUserProfileV2OK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserProfileV2Default)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserServicesAgreement get user services agreement API
*/
func (a *Client) GetUserServicesAgreement(params *GetUserServicesAgreementParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserServicesAgreementOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserServicesAgreementParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserServicesAgreement",
		Method:             "GET",
		PathPattern:        "/api/v1/msp/services-agreement",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserServicesAgreementReader{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.(*GetUserServicesAgreementOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserServicesAgreementDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetUserUIPrivileges get user UI privileges API
*/
func (a *Client) GetUserUIPrivileges(params *GetUserUIPrivilegesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserUIPrivilegesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserUIPrivilegesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetUserUIPrivileges",
		Method:             "GET",
		PathPattern:        "/api/v1/user/privileges",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetUserUIPrivilegesReader{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.(*GetUserUIPrivilegesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetUserUIPrivilegesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListSQLUsers list Sql users API
*/
func (a *Client) ListSQLUsers(params *ListSQLUsersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListSQLUsersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListSQLUsersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListSqlUsers",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/sql-user/list",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListSQLUsersReader{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.(*ListSQLUsersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListSQLUsersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
QuerySQLUser query Sql user API
*/
func (a *Client) QuerySQLUser(params *QuerySQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*QuerySQLUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewQuerySQLUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QuerySqlUser",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/sql-user/query",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QuerySQLUserReader{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.(*QuerySQLUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*QuerySQLUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
SaveUserServicesAgreement save user services agreement API
*/
func (a *Client) SaveUserServicesAgreement(params *SaveUserServicesAgreementParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SaveUserServicesAgreementOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSaveUserServicesAgreementParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "SaveUserServicesAgreement",
		Method:             "POST",
		PathPattern:        "/api/v1/msp/services-agreement",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &SaveUserServicesAgreementReader{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.(*SaveUserServicesAgreementOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*SaveUserServicesAgreementDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdateSQLUser update Sql user API
*/
func (a *Client) UpdateSQLUser(params *UpdateSQLUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateSQLUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateSQLUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateSqlUser",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/clusters/{cluster_id}/sql-user/update",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateSQLUserReader{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.(*UpdateSQLUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateSQLUserDefault)
	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
}