func (a *Client) GetPublicTest(params *GetPublicTestParams) (*GetPublicTestOK, error) {
	if params == nil {
		params = NewGetPublicTestParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicTest",
		Method:             "GET",
		PathPattern:        "/public/test",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicTestReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicTestOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicTest: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
/*
GetPublicTest tests the connection to the API server and returns its version you can use this to make sure the API is reachable and matches the expected version
package public
import (
	"fmt"
	"github.com/go-openapi/runtime"
	strfmt "github.com/go-openapi/strfmt"
)
func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
	return &Client{transport: transport, formats: formats}
}
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}
func (a *Client) GetPublicAuth(params *GetPublicAuthParams) (*GetPublicAuthOK, error) {
	if params == nil {
		params = NewGetPublicAuthParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicAuth",
		Method:             "GET",
		PathPattern:        "/public/auth",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicAuthReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicAuthOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicAuth: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetContractSize(params *GetPublicGetContractSizeParams) (*GetPublicGetContractSizeOK, error) {
	if params == nil {
		params = NewGetPublicGetContractSizeParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetContractSize",
		Method:             "GET",
		PathPattern:        "/public/get_contract_size",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetContractSizeReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetContractSizeOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetContractSize: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetCurrencies(params *GetPublicGetCurrenciesParams) (*GetPublicGetCurrenciesOK, error) {
	if params == nil {
		params = NewGetPublicGetCurrenciesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetCurrencies",
		Method:             "GET",
		PathPattern:        "/public/get_currencies",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetCurrenciesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetCurrenciesOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetCurrencies: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetFundingChartData(params *GetPublicGetFundingChartDataParams) (*GetPublicGetFundingChartDataOK, error) {
	if params == nil {
		params = NewGetPublicGetFundingChartDataParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetFundingChartData",
		Method:             "GET",
		PathPattern:        "/public/get_funding_chart_data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetFundingChartDataReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetFundingChartDataOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetFundingChartData: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetHistoricalVolatility(params *GetPublicGetHistoricalVolatilityParams) (*GetPublicGetHistoricalVolatilityOK, error) {
	if params == nil {
		params = NewGetPublicGetHistoricalVolatilityParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetHistoricalVolatility",
		Method:             "GET",
		PathPattern:        "/public/get_historical_volatility",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetHistoricalVolatilityReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetHistoricalVolatilityOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetHistoricalVolatility: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetInstruments(params *GetPublicGetInstrumentsParams) (*GetPublicGetInstrumentsOK, error) {
	if params == nil {
		params = NewGetPublicGetInstrumentsParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetInstruments",
		Method:             "GET",
		PathPattern:        "/public/get_instruments",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetInstrumentsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetInstrumentsOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetInstruments: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicGetTradingviewChartData(params *GetPublicGetTradingviewChartDataParams) (*GetPublicGetTradingviewChartDataOK, error) {
	if params == nil {
		params = NewGetPublicGetTradingviewChartDataParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicGetTradingviewChartData",
		Method:             "GET",
		PathPattern:        "/public/get_tradingview_chart_data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicGetTradingviewChartDataReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicGetTradingviewChartDataOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicGetTradingviewChartData: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicHello(params *GetPublicHelloParams) (*GetPublicHelloOK, error) {
	if params == nil {
		params = NewGetPublicHelloParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicHello",
		Method:             "GET",
		PathPattern:        "/public/hello",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicHelloReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicHelloOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicHello: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicSetHeartbeat(params *GetPublicSetHeartbeatParams) (*GetPublicSetHeartbeatOK, error) {
	if params == nil {
		params = NewGetPublicSetHeartbeatParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicSetHeartbeat",
		Method:             "GET",
		PathPattern:        "/public/set_heartbeat",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicSetHeartbeatReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicSetHeartbeatOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicSetHeartbeat: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) GetPublicSubscribe(params *GetPublicSubscribeParams) (*GetPublicSubscribeOK, error) {
	if params == nil {
		params = NewGetPublicSubscribeParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPublicSubscribe",
		Method:             "GET",
		PathPattern:        "/public/subscribe",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPublicSubscribeReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetPublicSubscribeOK)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for GetPublicSubscribe: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}