github.com/ActiveState/cli@v0.0.0-20240508170324-6801f60cd051/pkg/platform/api/mono/mono_client/users/users_client.go

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

package users

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

import (
	"fmt"

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

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

/*
Client for users 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 {
	AddEmail(params *AddEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddEmailOK, error)

	AddUser(params *AddUserParams, opts ...ClientOption) (*AddUserOK, error)

	DeleteEmail(params *DeleteEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteEmailOK, error)

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

	EditUser(params *EditUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EditUserOK, error)

	GetDomainsByUser(params *GetDomainsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDomainsByUserOK, error)

	GetEmailVerificationLink(params *GetEmailVerificationLinkParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEmailVerificationLinkOK, error)

	GetEmailsByUser(params *GetEmailsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEmailsByUserOK, error)

	GetInvitationByCode(params *GetInvitationByCodeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetInvitationByCodeOK, error)

	GetInvitationsByUser(params *GetInvitationsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetInvitationsByUserOK, error)

	GetUser(params *GetUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserOK, error)

	GetUserByID(params *GetUserByIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserByIDOK, error)

	ListInvitations(params *ListInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListInvitationsOK, error)

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

	SearchEmails(params *SearchEmailsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SearchEmailsOK, error)

	SearchUsernames(params *SearchUsernamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SearchUsernamesOK, error)

	SendEmailVerification(params *SendEmailVerificationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendEmailVerificationOK, error)

	SetPreferredEmail(params *SetPreferredEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SetPreferredEmailOK, error)

	UniqueUsername(params *UniqueUsernameParams, opts ...ClientOption) (*UniqueUsernameOK, error)

	VerifyEmail(params *VerifyEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*VerifyEmailOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  AddEmail creates new email for a user

  Create new email
*/
func (a *Client) AddEmail(params *AddEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addEmail",
		Method:             "POST",
		PathPattern:        "/users/{username}/emails",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AddEmailReader{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.(*AddEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for addEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  AddUser creates a new user

  Create a new user
*/
func (a *Client) AddUser(params *AddUserParams, opts ...ClientOption) (*AddUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addUser",
		Method:             "POST",
		PathPattern:        "/users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AddUserReader{formats: a.formats},
		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.(*AddUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for addUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteEmail deletes email for a user

  Delete email
*/
func (a *Client) DeleteEmail(params *DeleteEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteEmail",
		Method:             "DELETE",
		PathPattern:        "/users/{username}/emails",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteEmailReader{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.(*DeleteEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteUser deletes a user

  Delete a user
*/
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:        "/users/{username}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "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
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  EditUser edits a user

  Edit a user record
*/
func (a *Client) EditUser(params *EditUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EditUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewEditUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "editUser",
		Method:             "POST",
		PathPattern:        "/users/{username}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &EditUserReader{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.(*EditUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for editUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetDomainsByUser retrieves a user s verified domains

  Return a list of domains suitable for auto-invite
*/
func (a *Client) GetDomainsByUser(params *GetDomainsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDomainsByUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDomainsByUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDomainsByUser",
		Method:             "GET",
		PathPattern:        "/users/{username}/domains",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetDomainsByUserReader{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.(*GetDomainsByUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDomainsByUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetEmailVerificationLink gets the verification link for the given unverified email

  Returns the link needed to verify ownership of the provided email address, if it exists and is unverified. Only available to superusers.
*/
func (a *Client) GetEmailVerificationLink(params *GetEmailVerificationLinkParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEmailVerificationLinkOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEmailVerificationLinkParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEmailVerificationLink",
		Method:             "GET",
		PathPattern:        "/users/verification/{email}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetEmailVerificationLinkReader{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.(*GetEmailVerificationLinkOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getEmailVerificationLink: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetEmailsByUser retrieves a user s emails

  Return a list of emails matching username
*/
func (a *Client) GetEmailsByUser(params *GetEmailsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEmailsByUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEmailsByUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getEmailsByUser",
		Method:             "GET",
		PathPattern:        "/users/{username}/emails",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetEmailsByUserReader{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.(*GetEmailsByUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getEmailsByUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetInvitationByCode returns the invitation with the corresponding code

  Returns the invitation with the corresponding code
*/
func (a *Client) GetInvitationByCode(params *GetInvitationByCodeParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetInvitationByCodeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetInvitationByCodeParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getInvitationByCode",
		Method:             "GET",
		PathPattern:        "/invitations/code/{code}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetInvitationByCodeReader{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.(*GetInvitationByCodeOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getInvitationByCode: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetInvitationsByUser lists of pending invitations for the logged in user

  Has this user been invited to any organizations
*/
func (a *Client) GetInvitationsByUser(params *GetInvitationsByUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetInvitationsByUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetInvitationsByUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getInvitationsByUser",
		Method:             "GET",
		PathPattern:        "/invitations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetInvitationsByUserReader{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.(*GetInvitationsByUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getInvitationsByUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetUser retrieves a user record

  Return a specific user matching username
*/
func (a *Client) GetUser(params *GetUserParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getUser",
		Method:             "GET",
		PathPattern:        "/users/{username}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetUserReader{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.(*GetUserOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getUser: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetUserByID retrieves a user record by their user ID

  Return a specific user matching user ID
*/
func (a *Client) GetUserByID(params *GetUserByIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetUserByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUserByIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getUserByID",
		Method:             "GET",
		PathPattern:        "/users/id/{userID}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetUserByIDReader{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.(*GetUserByIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getUserByID: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  ListInvitations lists of pending invitations for an email address

  Has this email address been invited to any organizations
*/
func (a *Client) ListInvitations(params *ListInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListInvitationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewListInvitationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "listInvitations",
		Method:             "GET",
		PathPattern:        "/invitations/{email}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ListInvitationsReader{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.(*ListInvitationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for listInvitations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  ListUsers lists of visible users

  Retrieve all users from the system that the user has access to
*/
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:        "/users",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "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
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for listUsers: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  SearchEmails Search for users by email address, requires superuser
*/
func (a *Client) SearchEmails(params *SearchEmailsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SearchEmailsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSearchEmailsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "searchEmails",
		Method:             "POST",
		PathPattern:        "/users/search_emails",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &SearchEmailsReader{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.(*SearchEmailsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for searchEmails: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  SearchUsernames Search for users, requires superuser
*/
func (a *Client) SearchUsernames(params *SearchUsernamesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SearchUsernamesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSearchUsernamesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "searchUsernames",
		Method:             "POST",
		PathPattern:        "/users/search_usernames",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &SearchUsernamesReader{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.(*SearchUsernamesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for searchUsernames: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  SendEmailVerification sends a verification email to user

  Send a verification email to user
*/
func (a *Client) SendEmailVerification(params *SendEmailVerificationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SendEmailVerificationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSendEmailVerificationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "sendEmailVerification",
		Method:             "POST",
		PathPattern:        "/users/{username}/emails/{email}/verification/send",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &SendEmailVerificationReader{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.(*SendEmailVerificationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for sendEmailVerification: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  SetPreferredEmail updates preferred email

  Update preferred email
*/
func (a *Client) SetPreferredEmail(params *SetPreferredEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SetPreferredEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSetPreferredEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "setPreferredEmail",
		Method:             "PATCH",
		PathPattern:        "/users/{username}/emails/{email}/preferred",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &SetPreferredEmailReader{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.(*SetPreferredEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for setPreferredEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  UniqueUsername checks if a username is already taken in the system

  Is the supplied username already assigned
*/
func (a *Client) UniqueUsername(params *UniqueUsernameParams, opts ...ClientOption) (*UniqueUsernameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUniqueUsernameParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "uniqueUsername",
		Method:             "GET",
		PathPattern:        "/users/uniqueUsername/{username}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UniqueUsernameReader{formats: a.formats},
		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.(*UniqueUsernameOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for uniqueUsername: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  VerifyEmail verifies the designated email

  Verify the designated email
*/
func (a *Client) VerifyEmail(params *VerifyEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*VerifyEmailOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewVerifyEmailParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "verifyEmail",
		Method:             "POST",
		PathPattern:        "/users/{username}/emails/{email}/verification/check",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &VerifyEmailReader{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.(*VerifyEmailOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for verifyEmail: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

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