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

// All Code Copyright(c) 2018-2020 by Taxnexus, Inc.
// All rights reserved worldwide.
// Proprietary product; unlicensed use is not allowed

package cors

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

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

// ClientService is the interface for Client methods
type ClientService interface {
	GetCoordinatesObservableOptions(params *GetCoordinatesObservableOptionsParams) (*GetCoordinatesObservableOptionsOK, error)

	GetCoordinatesOptions(params *GetCoordinatesOptionsParams) (*GetCoordinatesOptionsOK, error)

	GetCountiesObservableOptions(params *GetCountiesObservableOptionsParams) (*GetCountiesObservableOptionsOK, error)

	GetCountiesOptions(params *GetCountiesOptionsParams) (*GetCountiesOptionsOK, error)

	GetCountriesObservableOptions(params *GetCountriesObservableOptionsParams) (*GetCountriesObservableOptionsOK, error)

	GetCountriesOptions(params *GetCountriesOptionsParams) (*GetCountriesOptionsOK, error)

	GetDomainsObservableOptions(params *GetDomainsObservableOptionsParams) (*GetDomainsObservableOptionsOK, error)

	GetDomainsOptions(params *GetDomainsOptionsParams) (*GetDomainsOptionsOK, error)

	GetPlacesObservableOptions(params *GetPlacesObservableOptionsParams) (*GetPlacesObservableOptionsOK, error)

	GetPlacesOptions(params *GetPlacesOptionsParams) (*GetPlacesOptionsOK, error)

	GetStatesObservableOptions(params *GetStatesObservableOptionsParams) (*GetStatesObservableOptionsOK, error)

	GetStatesOptions(params *GetStatesOptionsParams) (*GetStatesOptionsOK, error)

	GetTaxRateObservableOptions(params *GetTaxRateObservableOptionsParams) (*GetTaxRateObservableOptionsOK, error)

	GetTaxRatesOptions(params *GetTaxRatesOptionsParams) (*GetTaxRatesOptionsOK, error)

	GetTaxTypeObservableOptions(params *GetTaxTypeObservableOptionsParams) (*GetTaxTypeObservableOptionsOK, error)

	GetTaxTypesOptions(params *GetTaxTypesOptionsParams) (*GetTaxTypesOptionsOK, error)

	GetTaxnexusCodesObservableOptions(params *GetTaxnexusCodesObservableOptionsParams) (*GetTaxnexusCodesObservableOptionsOK, error)

	GetTaxnexusCodesOptions(params *GetTaxnexusCodesOptionsParams) (*GetTaxnexusCodesOptionsOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  GetCoordinatesObservableOptions CORS support
*/
func (a *Client) GetCoordinatesObservableOptions(params *GetCoordinatesObservableOptionsParams) (*GetCoordinatesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCoordinatesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCoordinatesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/coordinates/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCoordinatesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCoordinatesObservableOptionsOK)
	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 getCoordinatesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCoordinatesOptions CORS support
*/
func (a *Client) GetCoordinatesOptions(params *GetCoordinatesOptionsParams) (*GetCoordinatesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCoordinatesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCoordinatesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/coordinates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCoordinatesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCoordinatesOptionsOK)
	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 getCoordinatesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCountiesObservableOptions CORS support
*/
func (a *Client) GetCountiesObservableOptions(params *GetCountiesObservableOptionsParams) (*GetCountiesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCountiesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCountiesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/counties/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCountiesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCountiesObservableOptionsOK)
	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 getCountiesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCountiesOptions CORS support
*/
func (a *Client) GetCountiesOptions(params *GetCountiesOptionsParams) (*GetCountiesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCountiesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCountiesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/counties",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCountiesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCountiesOptionsOK)
	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 getCountiesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCountriesObservableOptions CORS support
*/
func (a *Client) GetCountriesObservableOptions(params *GetCountriesObservableOptionsParams) (*GetCountriesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCountriesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCountriesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/countries/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCountriesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCountriesObservableOptionsOK)
	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 getCountriesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCountriesOptions CORS support
*/
func (a *Client) GetCountriesOptions(params *GetCountriesOptionsParams) (*GetCountriesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCountriesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCountriesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/countries",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCountriesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCountriesOptionsOK)
	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 getCountriesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetDomainsObservableOptions CORS support
*/
func (a *Client) GetDomainsObservableOptions(params *GetDomainsObservableOptionsParams) (*GetDomainsObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDomainsObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDomainsObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/domains/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetDomainsObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDomainsObservableOptionsOK)
	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 getDomainsObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetDomainsOptions CORS support
*/
func (a *Client) GetDomainsOptions(params *GetDomainsOptionsParams) (*GetDomainsOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDomainsOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDomainsOptions",
		Method:             "OPTIONS",
		PathPattern:        "/domains",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetDomainsOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDomainsOptionsOK)
	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 getDomainsOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlacesObservableOptions CORS support
*/
func (a *Client) GetPlacesObservableOptions(params *GetPlacesObservableOptionsParams) (*GetPlacesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlacesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPlacesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/places/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlacesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlacesObservableOptionsOK)
	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 getPlacesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetPlacesOptions CORS support
*/
func (a *Client) GetPlacesOptions(params *GetPlacesOptionsParams) (*GetPlacesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPlacesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPlacesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/places",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPlacesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPlacesOptionsOK)
	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 getPlacesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetStatesObservableOptions CORS support
*/
func (a *Client) GetStatesObservableOptions(params *GetStatesObservableOptionsParams) (*GetStatesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStatesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getStatesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/states/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetStatesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetStatesObservableOptionsOK)
	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 getStatesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetStatesOptions CORS support
*/
func (a *Client) GetStatesOptions(params *GetStatesOptionsParams) (*GetStatesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStatesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getStatesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/states",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetStatesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetStatesOptionsOK)
	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 getStatesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxRateObservableOptions CORS support
*/
func (a *Client) GetTaxRateObservableOptions(params *GetTaxRateObservableOptionsParams) (*GetTaxRateObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxRateObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxRateObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxrates/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxRateObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxRateObservableOptionsOK)
	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 getTaxRateObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxRatesOptions CORS support
*/
func (a *Client) GetTaxRatesOptions(params *GetTaxRatesOptionsParams) (*GetTaxRatesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxRatesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxRatesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxrates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxRatesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxRatesOptionsOK)
	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 getTaxRatesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxTypeObservableOptions CORS support
*/
func (a *Client) GetTaxTypeObservableOptions(params *GetTaxTypeObservableOptionsParams) (*GetTaxTypeObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxTypeObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxTypeObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxtypes/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxTypeObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxTypeObservableOptionsOK)
	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 getTaxTypeObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxTypesOptions CORS support
*/
func (a *Client) GetTaxTypesOptions(params *GetTaxTypesOptionsParams) (*GetTaxTypesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxTypesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxTypesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxtypes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxTypesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxTypesOptionsOK)
	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 getTaxTypesOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxnexusCodesObservableOptions CORS support
*/
func (a *Client) GetTaxnexusCodesObservableOptions(params *GetTaxnexusCodesObservableOptionsParams) (*GetTaxnexusCodesObservableOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxnexusCodesObservableOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxnexusCodesObservableOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxnexuscodes/observable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxnexusCodesObservableOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxnexusCodesObservableOptionsOK)
	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 getTaxnexusCodesObservableOptions: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetTaxnexusCodesOptions CORS support
*/
func (a *Client) GetTaxnexusCodesOptions(params *GetTaxnexusCodesOptionsParams) (*GetTaxnexusCodesOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTaxnexusCodesOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getTaxnexusCodesOptions",
		Method:             "OPTIONS",
		PathPattern:        "/taxnexuscodes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTaxnexusCodesOptionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetTaxnexusCodesOptionsOK)
	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 getTaxnexusCodesOptions: 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
}
