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

package tenant_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 tenant service API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

// New creates a new tenant 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 tenant 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 tenant 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 {
	AcceptInvitation(params *AcceptInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AcceptInvitationOK, error)

	AcknowledgeCNPolicy(params *AcknowledgeCNPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AcknowledgeCNPolicyOK, error)

	CreatePOCApplication(params *CreatePOCApplicationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePOCApplicationOK, error)

	CreateAuth0User(params *CreateAuth0UserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateAuth0UserOK, error)

	CreateProject(params *CreateProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateProjectOK, error)

	DeleteProject(params *DeleteProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteProjectOK, error)

	DeleteProjectUser(params *DeleteProjectUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteProjectUserOK, error)

	DeleteUser(params *DeleteUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteUserOK, error)

	GetExpWhiteList(params *GetExpWhiteListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetExpWhiteListOK, error)

	GetMspConfig(params *GetMspConfigParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetMspConfigOK, error)

	GetMspCustomer(params *GetMspCustomerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetMspCustomerOK, error)

	GetOrgByCompanyName(params *GetOrgByCompanyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrgByCompanyNameOK, error)

	GetOrganization(params *GetOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationOK, error)

	GetPartnerByCustomerID(params *GetPartnerByCustomerIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPartnerByCustomerIDOK, error)

	GetUserProfile(params *GetUserProfileParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserProfileOK, error)

	InviteUser(params *InviteUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InviteUserOK, error)

	InviteUserToOrg(params *InviteUserToOrgParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InviteUserToOrgOK, error)

	ListLoginUserRoles(params *ListLoginUserRolesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListLoginUserRolesOK, error)

	ListOrgActiveAuthMethods(params *ListOrgActiveAuthMethodsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListOrgActiveAuthMethodsOK, error)

	ListOrganizations(params *ListOrganizationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListOrganizationsOK, error)

	ListProjectUsers(params *ListProjectUsersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListProjectUsersOK, error)

	ListProjects(params *ListProjectsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListProjectsOK, error)

	ListRolesByUserID(params *ListRolesByUserIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListRolesByUserIDOK, error)

	ListUsers(params *ListUsersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListUsersOK, error)

	ListUsersByScope(params *ListUsersByScopeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListUsersByScopeOK, error)

	OpenOrgSso(params *OpenOrgSsoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*OpenOrgSsoOK, error)

	OrgBindThirdParty(params *OrgBindThirdPartyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*OrgBindThirdPartyOK, error)

	Registration(params *RegistrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RegistrationOK, error)

	SendVerificationEmail(params *SendVerificationEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendVerificationEmailOK, error)

	TenantServiceGetClientIP(params *TenantServiceGetClientIPParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceGetClientIPOK, error)

	TenantServiceListTenantAccessLogs(params *TenantServiceListTenantAccessLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceListTenantAccessLogsOK, error)

	TenantServiceUpdateProject(params *TenantServiceUpdateProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceUpdateProjectOK, error)

	UpdateOrganization(params *UpdateOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateOrganizationOK, error)

	UpdateProjectUserRole(params *UpdateProjectUserRoleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateProjectUserRoleOK, error)

	UpdateUser(params *UpdateUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateUserOK, error)

	UpdateUserProfile(params *UpdateUserProfileParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateUserProfileOK, error)

	ValiadteToken(params *ValiadteTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ValiadteTokenOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
AcceptInvitation accept invitation API
*/
func (a *Client) AcceptInvitation(params *AcceptInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AcceptInvitationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAcceptInvitationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AcceptInvitation",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/acception",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AcceptInvitationReader{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.(*AcceptInvitationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*AcceptInvitationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
AcknowledgeCNPolicy acknowledge c n policy API
*/
func (a *Client) AcknowledgeCNPolicy(params *AcknowledgeCNPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AcknowledgeCNPolicyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAcknowledgeCNPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AcknowledgeCNPolicy",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/cn-policy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AcknowledgeCNPolicyReader{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.(*AcknowledgeCNPolicyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*AcknowledgeCNPolicyDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
CreatePOCApplication create p o c application API
*/
func (a *Client) CreatePOCApplication(params *CreatePOCApplicationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreatePOCApplicationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreatePOCApplicationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Create POC Application",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/poc-applications",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreatePOCApplicationReader{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.(*CreatePOCApplicationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreatePOCApplicationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

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

/*
DeleteProject delete project API
*/
func (a *Client) DeleteProject(params *DeleteProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteProjectOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteProjectParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteProject",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteProjectReader{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.(*DeleteProjectOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteProjectDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteProjectUser delete project user API
*/
func (a *Client) DeleteProjectUser(params *DeleteProjectUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteProjectUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteProjectUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteProjectUser",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/users/{user_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteProjectUserReader{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.(*DeleteProjectUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteProjectUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
DeleteUser delete user API
*/
func (a *Client) DeleteUser(params *DeleteUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "DeleteUser",
		Method:             "DELETE",
		PathPattern:        "/api/v1/orgs/{org_id}/users/{user_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteUserReader{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.(*DeleteUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*DeleteUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
GetExpWhiteList get exp white list API
*/
func (a *Client) GetExpWhiteList(params *GetExpWhiteListParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetExpWhiteListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetExpWhiteListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetExpWhiteList",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/exp-whitelist",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetExpWhiteListReader{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.(*GetExpWhiteListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetExpWhiteListDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

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

/*
GetOrgByCompanyName get org by company name API
*/
func (a *Client) GetOrgByCompanyName(params *GetOrgByCompanyNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrgByCompanyNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrgByCompanyNameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetOrgByCompanyName",
		Method:             "GET",
		PathPattern:        "/api/v1/org/{company_name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetOrgByCompanyNameReader{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.(*GetOrgByCompanyNameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetOrgByCompanyNameDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

/*
GetPartnerByCustomerID get partner by customer Id API
*/
func (a *Client) GetPartnerByCustomerID(params *GetPartnerByCustomerIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetPartnerByCustomerIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPartnerByCustomerIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetPartnerByCustomerId",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/partner",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPartnerByCustomerIDReader{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.(*GetPartnerByCustomerIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*GetPartnerByCustomerIDDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

/*
InviteUser invite user API
*/
func (a *Client) InviteUser(params *InviteUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InviteUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewInviteUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "InviteUser",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &InviteUserReader{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.(*InviteUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*InviteUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
InviteUserToOrg invite user to org API
*/
func (a *Client) InviteUserToOrg(params *InviteUserToOrgParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*InviteUserToOrgOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewInviteUserToOrgParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "InviteUserToOrg",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &InviteUserToOrgReader{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.(*InviteUserToOrgOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*InviteUserToOrgDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

/*
ListOrgActiveAuthMethods list org active auth methods API
*/
func (a *Client) ListOrgActiveAuthMethods(params *ListOrgActiveAuthMethodsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListOrgActiveAuthMethodsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListOrgActiveAuthMethodsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListOrgActiveAuthMethods",
		Method:             "GET",
		PathPattern:        "/api/v1/auth-method",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListOrgActiveAuthMethodsReader{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.(*ListOrgActiveAuthMethodsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListOrgActiveAuthMethodsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

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

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

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

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

/*
ListUsers list users API
*/
func (a *Client) ListUsers(params *ListUsersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListUsersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListUsersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListUsers",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListUsersReader{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.(*ListUsersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListUsersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ListUsersByScope list users by scope API
*/
func (a *Client) ListUsersByScope(params *ListUsersByScopeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListUsersByScopeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListUsersByScopeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "ListUsersByScope",
		Method:             "GET",
		PathPattern:        "/api/v1/scope-users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ListUsersByScopeReader{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.(*ListUsersByScopeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ListUsersByScopeDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
OpenOrgSso open org sso API
*/
func (a *Client) OpenOrgSso(params *OpenOrgSsoParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*OpenOrgSsoOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewOpenOrgSsoParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "OpenOrgSso",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/opensso",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &OpenOrgSsoReader{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.(*OpenOrgSsoOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*OpenOrgSsoDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
OrgBindThirdParty org bind third party API
*/
func (a *Client) OrgBindThirdParty(params *OrgBindThirdPartyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*OrgBindThirdPartyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewOrgBindThirdPartyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Org Bind Third Party",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/{org_id}/bind_third_party",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &OrgBindThirdPartyReader{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.(*OrgBindThirdPartyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*OrgBindThirdPartyDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
Registration submits register request
*/
func (a *Client) Registration(params *RegistrationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RegistrationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewRegistrationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Registration",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &RegistrationReader{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.(*RegistrationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*RegistrationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
SendVerificationEmail send verification email API
*/
func (a *Client) SendVerificationEmail(params *SendVerificationEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendVerificationEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSendVerificationEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Send Verification Email",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/verification-email",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &SendVerificationEmailReader{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.(*SendVerificationEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*SendVerificationEmailDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
TenantServiceGetClientIP tenant service get client IP API
*/
func (a *Client) TenantServiceGetClientIP(params *TenantServiceGetClientIPParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceGetClientIPOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewTenantServiceGetClientIPParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "TenantService_GetClientIP",
		Method:             "GET",
		PathPattern:        "/api/v1/my-ip",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &TenantServiceGetClientIPReader{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.(*TenantServiceGetClientIPOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*TenantServiceGetClientIPDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
TenantServiceListTenantAccessLogs tenant service list tenant access logs API
*/
func (a *Client) TenantServiceListTenantAccessLogs(params *TenantServiceListTenantAccessLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceListTenantAccessLogsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewTenantServiceListTenantAccessLogsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "TenantService_ListTenantAccessLogs",
		Method:             "GET",
		PathPattern:        "/api/v1/orgs/{org_id}/access-logs",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &TenantServiceListTenantAccessLogsReader{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.(*TenantServiceListTenantAccessLogsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*TenantServiceListTenantAccessLogsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
TenantServiceUpdateProject tenant service update project API
*/
func (a *Client) TenantServiceUpdateProject(params *TenantServiceUpdateProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TenantServiceUpdateProjectOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewTenantServiceUpdateProjectParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "TenantService_UpdateProject",
		Method:             "PATCH",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &TenantServiceUpdateProjectReader{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.(*TenantServiceUpdateProjectOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*TenantServiceUpdateProjectDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdateOrganization update organization API
*/
func (a *Client) UpdateOrganization(params *UpdateOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateOrganizationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateOrganizationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateOrganization",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateOrganizationReader{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.(*UpdateOrganizationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateOrganizationDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdateProjectUserRole update project user role API
*/
func (a *Client) UpdateProjectUserRole(params *UpdateProjectUserRoleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateProjectUserRoleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateProjectUserRoleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateProjectUserRole",
		Method:             "PATCH",
		PathPattern:        "/api/v1/orgs/{org_id}/projects/{project_id}/users/{user_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateProjectUserRoleReader{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.(*UpdateProjectUserRoleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateProjectUserRoleDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdateUser update user API
*/
func (a *Client) UpdateUser(params *UpdateUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateUser",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/users/{user_id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateUserReader{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.(*UpdateUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateUserDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
UpdateUserProfile updates user profile must be defined after update user to get higher priority
*/
func (a *Client) UpdateUserProfile(params *UpdateUserProfileParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateUserProfileOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateUserProfileParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "UpdateUserProfile",
		Method:             "PUT",
		PathPattern:        "/api/v1/orgs/{org_id}/users/me",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateUserProfileReader{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.(*UpdateUserProfileOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*UpdateUserProfileDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
ValiadteToken valiadte token API
*/
func (a *Client) ValiadteToken(params *ValiadteTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ValiadteTokenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewValiadteTokenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "Valiadte Token",
		Method:             "POST",
		PathPattern:        "/api/v1/orgs/validate_thirdparty_token",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ValiadteTokenReader{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.(*ValiadteTokenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ValiadteTokenDefault)
	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
}