github.com/aeternity/aepp-sdk-go/v4@v4.0.1/swagguard/node/client/external/external_client.go

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

package external

// 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"

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

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

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

/*
GetAccountByPubkey Get an account by public key
*/
func (a *Client) GetAccountByPubkey(params *GetAccountByPubkeyParams) (*GetAccountByPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAccountByPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetAccountByPubkey",
		Method:             "GET",
		PathPattern:        "/accounts/{pubkey}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetAccountByPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetAccountByPubkeyOK), nil

}

/*
GetAccountByPubkeyAndHash Get an account by public key after the block indicated by hash
*/
func (a *Client) GetAccountByPubkeyAndHash(params *GetAccountByPubkeyAndHashParams) (*GetAccountByPubkeyAndHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAccountByPubkeyAndHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetAccountByPubkeyAndHash",
		Method:             "GET",
		PathPattern:        "/accounts/{pubkey}/hash/{hash}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetAccountByPubkeyAndHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetAccountByPubkeyAndHashOK), nil

}

/*
GetAccountByPubkeyAndHeight Get an account by public key after the opening key block of the generation at height
*/
func (a *Client) GetAccountByPubkeyAndHeight(params *GetAccountByPubkeyAndHeightParams) (*GetAccountByPubkeyAndHeightOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAccountByPubkeyAndHeightParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetAccountByPubkeyAndHeight",
		Method:             "GET",
		PathPattern:        "/accounts/{pubkey}/height/{height}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetAccountByPubkeyAndHeightReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetAccountByPubkeyAndHeightOK), nil

}

/*
GetChannelByPubkey Get channel by public key
*/
func (a *Client) GetChannelByPubkey(params *GetChannelByPubkeyParams) (*GetChannelByPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetChannelByPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetChannelByPubkey",
		Method:             "GET",
		PathPattern:        "/channels/{pubkey}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetChannelByPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetChannelByPubkeyOK), nil

}

/*
GetContract Get a contract by pubkey
*/
func (a *Client) GetContract(params *GetContractParams) (*GetContractOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetContractParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetContract",
		Method:             "GET",
		PathPattern:        "/contracts/{pubkey}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetContractReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetContractOK), nil

}

/*
GetContractCode Get contract code by pubkey
*/
func (a *Client) GetContractCode(params *GetContractCodeParams) (*GetContractCodeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetContractCodeParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetContractCode",
		Method:             "GET",
		PathPattern:        "/contracts/{pubkey}/code",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetContractCodeReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetContractCodeOK), nil

}

/*
GetContractPoI Get a proof of inclusion for a contract
*/
func (a *Client) GetContractPoI(params *GetContractPoIParams) (*GetContractPoIOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetContractPoIParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetContractPoI",
		Method:             "GET",
		PathPattern:        "/contracts/{pubkey}/poi",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetContractPoIReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetContractPoIOK), nil

}

/*
GetContractStore Get contract store by pubkey
*/
func (a *Client) GetContractStore(params *GetContractStoreParams) (*GetContractStoreOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetContractStoreParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetContractStore",
		Method:             "GET",
		PathPattern:        "/contracts/{pubkey}/store",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetContractStoreReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetContractStoreOK), nil

}

/*
GetCurrentGeneration Get the current generation
*/
func (a *Client) GetCurrentGeneration(params *GetCurrentGenerationParams) (*GetCurrentGenerationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCurrentGenerationParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetCurrentGeneration",
		Method:             "GET",
		PathPattern:        "/generations/current",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCurrentGenerationReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetCurrentGenerationOK), nil

}

/*
GetCurrentKeyBlock Get the current key block
*/
func (a *Client) GetCurrentKeyBlock(params *GetCurrentKeyBlockParams) (*GetCurrentKeyBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCurrentKeyBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetCurrentKeyBlock",
		Method:             "GET",
		PathPattern:        "/key-blocks/current",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCurrentKeyBlockReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetCurrentKeyBlockOK), nil

}

/*
GetCurrentKeyBlockHash Get the hash of the current key block
*/
func (a *Client) GetCurrentKeyBlockHash(params *GetCurrentKeyBlockHashParams) (*GetCurrentKeyBlockHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCurrentKeyBlockHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetCurrentKeyBlockHash",
		Method:             "GET",
		PathPattern:        "/key-blocks/current/hash",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCurrentKeyBlockHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetCurrentKeyBlockHashOK), nil

}

/*
GetCurrentKeyBlockHeight Get the height of the current key block
*/
func (a *Client) GetCurrentKeyBlockHeight(params *GetCurrentKeyBlockHeightParams) (*GetCurrentKeyBlockHeightOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCurrentKeyBlockHeightParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetCurrentKeyBlockHeight",
		Method:             "GET",
		PathPattern:        "/key-blocks/current/height",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetCurrentKeyBlockHeightReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetCurrentKeyBlockHeightOK), nil

}

/*
GetGenerationByHash Get a generation by hash
*/
func (a *Client) GetGenerationByHash(params *GetGenerationByHashParams) (*GetGenerationByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetGenerationByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetGenerationByHash",
		Method:             "GET",
		PathPattern:        "/generations/hash/{hash}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetGenerationByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetGenerationByHashOK), nil

}

/*
GetGenerationByHeight Get a generation by height
*/
func (a *Client) GetGenerationByHeight(params *GetGenerationByHeightParams) (*GetGenerationByHeightOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetGenerationByHeightParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetGenerationByHeight",
		Method:             "GET",
		PathPattern:        "/generations/height/{height}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetGenerationByHeightReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetGenerationByHeightOK), nil

}

/*
GetKeyBlockByHash Get a key block by hash
*/
func (a *Client) GetKeyBlockByHash(params *GetKeyBlockByHashParams) (*GetKeyBlockByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetKeyBlockByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetKeyBlockByHash",
		Method:             "GET",
		PathPattern:        "/key-blocks/hash/{hash}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetKeyBlockByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetKeyBlockByHashOK), nil

}

/*
GetKeyBlockByHeight Get a key block by height
*/
func (a *Client) GetKeyBlockByHeight(params *GetKeyBlockByHeightParams) (*GetKeyBlockByHeightOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetKeyBlockByHeightParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetKeyBlockByHeight",
		Method:             "GET",
		PathPattern:        "/key-blocks/height/{height}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetKeyBlockByHeightReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetKeyBlockByHeightOK), nil

}

/*
GetMicroBlockHeaderByHash Get a micro block header by hash
*/
func (a *Client) GetMicroBlockHeaderByHash(params *GetMicroBlockHeaderByHashParams) (*GetMicroBlockHeaderByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMicroBlockHeaderByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetMicroBlockHeaderByHash",
		Method:             "GET",
		PathPattern:        "/micro-blocks/hash/{hash}/header",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetMicroBlockHeaderByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetMicroBlockHeaderByHashOK), nil

}

/*
GetMicroBlockTransactionByHashAndIndex Get a micro block transaction by hash and index
*/
func (a *Client) GetMicroBlockTransactionByHashAndIndex(params *GetMicroBlockTransactionByHashAndIndexParams) (*GetMicroBlockTransactionByHashAndIndexOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMicroBlockTransactionByHashAndIndexParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetMicroBlockTransactionByHashAndIndex",
		Method:             "GET",
		PathPattern:        "/micro-blocks/hash/{hash}/transactions/index/{index}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetMicroBlockTransactionByHashAndIndexReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetMicroBlockTransactionByHashAndIndexOK), nil

}

/*
GetMicroBlockTransactionsByHash Get micro block transactions by hash
*/
func (a *Client) GetMicroBlockTransactionsByHash(params *GetMicroBlockTransactionsByHashParams) (*GetMicroBlockTransactionsByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMicroBlockTransactionsByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetMicroBlockTransactionsByHash",
		Method:             "GET",
		PathPattern:        "/micro-blocks/hash/{hash}/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetMicroBlockTransactionsByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetMicroBlockTransactionsByHashOK), nil

}

/*
GetMicroBlockTransactionsCountByHash Get micro block transaction count by hash
*/
func (a *Client) GetMicroBlockTransactionsCountByHash(params *GetMicroBlockTransactionsCountByHashParams) (*GetMicroBlockTransactionsCountByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMicroBlockTransactionsCountByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetMicroBlockTransactionsCountByHash",
		Method:             "GET",
		PathPattern:        "/micro-blocks/hash/{hash}/transactions/count",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetMicroBlockTransactionsCountByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetMicroBlockTransactionsCountByHashOK), nil

}

/*
GetNameEntryByName Get name entry from naming system
*/
func (a *Client) GetNameEntryByName(params *GetNameEntryByNameParams) (*GetNameEntryByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNameEntryByNameParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetNameEntryByName",
		Method:             "GET",
		PathPattern:        "/names/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetNameEntryByNameReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetNameEntryByNameOK), nil

}

/*
GetOracleByPubkey Get an oracle by public key
*/
func (a *Client) GetOracleByPubkey(params *GetOracleByPubkeyParams) (*GetOracleByPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOracleByPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetOracleByPubkey",
		Method:             "GET",
		PathPattern:        "/oracles/{pubkey}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetOracleByPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetOracleByPubkeyOK), nil

}

/*
GetOracleQueriesByPubkey Get oracle queries by public key
*/
func (a *Client) GetOracleQueriesByPubkey(params *GetOracleQueriesByPubkeyParams) (*GetOracleQueriesByPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOracleQueriesByPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetOracleQueriesByPubkey",
		Method:             "GET",
		PathPattern:        "/oracles/{pubkey}/queries",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetOracleQueriesByPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetOracleQueriesByPubkeyOK), nil

}

/*
GetOracleQueryByPubkeyAndQueryID Get an oracle query by public key and query ID
*/
func (a *Client) GetOracleQueryByPubkeyAndQueryID(params *GetOracleQueryByPubkeyAndQueryIDParams) (*GetOracleQueryByPubkeyAndQueryIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOracleQueryByPubkeyAndQueryIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetOracleQueryByPubkeyAndQueryId",
		Method:             "GET",
		PathPattern:        "/oracles/{pubkey}/queries/{query-id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetOracleQueryByPubkeyAndQueryIDReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetOracleQueryByPubkeyAndQueryIDOK), nil

}

/*
GetPeerPubkey Get peer public key
*/
func (a *Client) GetPeerPubkey(params *GetPeerPubkeyParams) (*GetPeerPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPeerPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPeerPubkey",
		Method:             "GET",
		PathPattern:        "/peers/pubkey",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPeerPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPeerPubkeyOK), nil

}

/*
GetPendingAccountTransactionsByPubkey Get pending account transactions by public key
*/
func (a *Client) GetPendingAccountTransactionsByPubkey(params *GetPendingAccountTransactionsByPubkeyParams) (*GetPendingAccountTransactionsByPubkeyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPendingAccountTransactionsByPubkeyParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPendingAccountTransactionsByPubkey",
		Method:             "GET",
		PathPattern:        "/accounts/{pubkey}/transactions/pending",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPendingAccountTransactionsByPubkeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPendingAccountTransactionsByPubkeyOK), nil

}

/*
GetPendingKeyBlock Get the pending key block
*/
func (a *Client) GetPendingKeyBlock(params *GetPendingKeyBlockParams) (*GetPendingKeyBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPendingKeyBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetPendingKeyBlock",
		Method:             "GET",
		PathPattern:        "/key-blocks/pending",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetPendingKeyBlockReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPendingKeyBlockOK), nil

}

/*
GetStatus Get the status of a node
*/
func (a *Client) GetStatus(params *GetStatusParams) (*GetStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStatusParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetStatus",
		Method:             "GET",
		PathPattern:        "/status",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetStatusReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetStatusOK), nil

}

/*
GetTopBlock Get the top block (either key or micro block)
*/
func (a *Client) GetTopBlock(params *GetTopBlockParams) (*GetTopBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTopBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetTopBlock",
		Method:             "GET",
		PathPattern:        "/blocks/top",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTopBlockReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetTopBlockOK), nil

}

/*
GetTransactionByHash Get a transaction by hash
*/
func (a *Client) GetTransactionByHash(params *GetTransactionByHashParams) (*GetTransactionByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTransactionByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetTransactionByHash",
		Method:             "GET",
		PathPattern:        "/transactions/{hash}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTransactionByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetTransactionByHashOK), nil

}

/*
GetTransactionInfoByHash get transaction info by hash API
*/
func (a *Client) GetTransactionInfoByHash(params *GetTransactionInfoByHashParams) (*GetTransactionInfoByHashOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTransactionInfoByHashParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetTransactionInfoByHash",
		Method:             "GET",
		PathPattern:        "/transactions/{hash}/info",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{""},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetTransactionInfoByHashReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetTransactionInfoByHashOK), nil

}

/*
PostTransaction Post a new transaction
*/
func (a *Client) PostTransaction(params *PostTransactionParams) (*PostTransactionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostTransactionParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostTransaction",
		Method:             "POST",
		PathPattern:        "/transactions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostTransactionReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostTransactionOK), nil

}

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