associations_client.go

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

package associations

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

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

// ClientService is the interface for Client methods
type ClientService interface {
	DeleteBacsID(params *DeleteBacsIDParams) (*DeleteBacsIDNoContent, error)

	DeleteConfirmationOfPayeeID(params *DeleteConfirmationOfPayeeIDParams) (*DeleteConfirmationOfPayeeIDNoContent, error)

	DeleteGocardlessID(params *DeleteGocardlessIDParams) (*DeleteGocardlessIDNoContent, error)

	DeleteLhvAssociationID(params *DeleteLhvAssociationIDParams) (*DeleteLhvAssociationIDNoContent, error)

	DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationID(params *DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams) (*DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDNoContent, error)

	DeleteLhvAssociationIDMasterAccountsMasterAccountID(params *DeleteLhvAssociationIDMasterAccountsMasterAccountIDParams) (*DeleteLhvAssociationIDMasterAccountsMasterAccountIDNoContent, error)

	DeleteMandatemanagementID(params *DeleteMandatemanagementIDParams) (*DeleteMandatemanagementIDNoContent, error)

	DeletePayportID(params *DeletePayportIDParams) (*DeletePayportIDNoContent, error)

	DeleteReconciliationAssociationID(params *DeleteReconciliationAssociationIDParams) (*DeleteReconciliationAssociationIDNoContent, error)

	DeleteSepaLiquidityID(params *DeleteSepaLiquidityIDParams) (*DeleteSepaLiquidityIDNoContent, error)

	DeleteSepactLiquidityAssociationID(params *DeleteSepactLiquidityAssociationIDParams) (*DeleteSepactLiquidityAssociationIDNoContent, error)

	DeleteSepaddID(params *DeleteSepaddIDParams) (*DeleteSepaddIDNoContent, error)

	DeleteSepainstantID(params *DeleteSepainstantIDParams) (*DeleteSepainstantIDNoContent, error)

	DeleteSepasctID(params *DeleteSepasctIDParams) (*DeleteSepasctIDNoContent, error)

	DeleteStarlingID(params *DeleteStarlingIDParams) (*DeleteStarlingIDNoContent, error)

	DeleteSwiftID(params *DeleteSwiftIDParams) (*DeleteSwiftIDNoContent, error)

	DeleteVocalinkreportID(params *DeleteVocalinkreportIDParams) (*DeleteVocalinkreportIDNoContent, error)

	GetBacs(params *GetBacsParams) (*GetBacsOK, error)

	GetBacsID(params *GetBacsIDParams) (*GetBacsIDOK, error)

	GetConfirmationOfPayee(params *GetConfirmationOfPayeeParams) (*GetConfirmationOfPayeeOK, error)

	GetConfirmationOfPayeeID(params *GetConfirmationOfPayeeIDParams) (*GetConfirmationOfPayeeIDOK, error)

	GetGocardless(params *GetGocardlessParams) (*GetGocardlessOK, error)

	GetGocardlessID(params *GetGocardlessIDParams) (*GetGocardlessIDOK, error)

	GetLhv(params *GetLhvParams) (*GetLhvOK, error)

	GetLhvAssociationID(params *GetLhvAssociationIDParams) (*GetLhvAssociationIDOK, error)

	GetLhvAssociationIDAgencySynchronisations(params *GetLhvAssociationIDAgencySynchronisationsParams) (*GetLhvAssociationIDAgencySynchronisationsOK, error)

	GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationID(params *GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams) (*GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDOK, error)

	GetLhvAssociationIDMasterAccounts(params *GetLhvAssociationIDMasterAccountsParams) (*GetLhvAssociationIDMasterAccountsOK, error)

	GetLhvAssociationIDMasterAccountsMasterAccountID(params *GetLhvAssociationIDMasterAccountsMasterAccountIDParams) (*GetLhvAssociationIDMasterAccountsMasterAccountIDOK, error)

	GetMandatemanagementID(params *GetMandatemanagementIDParams) (*GetMandatemanagementIDOK, error)

	GetPayport(params *GetPayportParams) (*GetPayportOK, error)

	GetPayportID(params *GetPayportIDParams) (*GetPayportIDOK, error)

	GetReconciliation(params *GetReconciliationParams) (*GetReconciliationOK, error)

	GetReconciliationAssociationID(params *GetReconciliationAssociationIDParams) (*GetReconciliationAssociationIDOK, error)

	GetSepaLiquidity(params *GetSepaLiquidityParams) (*GetSepaLiquidityOK, error)

	GetSepaLiquidityID(params *GetSepaLiquidityIDParams) (*GetSepaLiquidityIDOK, error)

	GetSepactLiquidity(params *GetSepactLiquidityParams) (*GetSepactLiquidityOK, error)

	GetSepactLiquidityAssociationID(params *GetSepactLiquidityAssociationIDParams) (*GetSepactLiquidityAssociationIDOK, error)

	GetSepadd(params *GetSepaddParams) (*GetSepaddOK, error)

	GetSepaddID(params *GetSepaddIDParams) (*GetSepaddIDOK, error)

	GetSepainstant(params *GetSepainstantParams) (*GetSepainstantOK, error)

	GetSepainstantID(params *GetSepainstantIDParams) (*GetSepainstantIDOK, error)

	GetSepasct(params *GetSepasctParams) (*GetSepasctOK, error)

	GetSepasctID(params *GetSepasctIDParams) (*GetSepasctIDOK, error)

	GetStarling(params *GetStarlingParams) (*GetStarlingOK, error)

	GetStarlingID(params *GetStarlingIDParams) (*GetStarlingIDOK, error)

	GetSwift(params *GetSwiftParams) (*GetSwiftOK, error)

	GetSwiftID(params *GetSwiftIDParams) (*GetSwiftIDOK, error)

	GetVocalinkreport(params *GetVocalinkreportParams) (*GetVocalinkreportOK, error)

	GetVocalinkreportID(params *GetVocalinkreportIDParams) (*GetVocalinkreportIDOK, error)

	PatchGocardlessID(params *PatchGocardlessIDParams) (*PatchGocardlessIDOK, error)

	PatchLhvAssociationID(params *PatchLhvAssociationIDParams) (*PatchLhvAssociationIDOK, error)

	PatchSepactLiquidityAssociationID(params *PatchSepactLiquidityAssociationIDParams) (*PatchSepactLiquidityAssociationIDOK, error)

	PatchSepaddID(params *PatchSepaddIDParams) (*PatchSepaddIDOK, error)

	PatchSepainstantID(params *PatchSepainstantIDParams) (*PatchSepainstantIDOK, error)

	PatchSwiftID(params *PatchSwiftIDParams) (*PatchSwiftIDOK, error)

	PostBacs(params *PostBacsParams) (*PostBacsCreated, error)

	PostConfirmationOfPayee(params *PostConfirmationOfPayeeParams) (*PostConfirmationOfPayeeCreated, error)

	PostGocardless(params *PostGocardlessParams) (*PostGocardlessCreated, error)

	PostLhv(params *PostLhvParams) (*PostLhvCreated, error)

	PostLhvAssociationIDAgencySynchronisations(params *PostLhvAssociationIDAgencySynchronisationsParams) (*PostLhvAssociationIDAgencySynchronisationsCreated, error)

	PostLhvAssociationIDMasterAccounts(params *PostLhvAssociationIDMasterAccountsParams) (*PostLhvAssociationIDMasterAccountsCreated, error)

	PostMandatemanagement(params *PostMandatemanagementParams) (*PostMandatemanagementCreated, error)

	PostPayport(params *PostPayportParams) (*PostPayportCreated, error)

	PostReconciliation(params *PostReconciliationParams) (*PostReconciliationCreated, error)

	PostSepaLiquidity(params *PostSepaLiquidityParams) (*PostSepaLiquidityCreated, error)

	PostSepactLiquidity(params *PostSepactLiquidityParams) (*PostSepactLiquidityCreated, error)

	PostSepadd(params *PostSepaddParams) (*PostSepaddCreated, error)

	PostSepainstant(params *PostSepainstantParams) (*PostSepainstantCreated, error)

	PostSepasct(params *PostSepasctParams) (*PostSepasctCreated, error)

	PostStarling(params *PostStarlingParams) (*PostStarlingCreated, error)

	PostSwift(params *PostSwiftParams) (*PostSwiftCreated, error)

	PostVocalinkreport(params *PostVocalinkreportParams) (*PostVocalinkreportCreated, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  DeleteBacsID deletes organisation association for b a c s
*/
func (a *Client) DeleteBacsID(params *DeleteBacsIDParams) (*DeleteBacsIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteBacsIDParams()
	}

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

/*
  DeleteConfirmationOfPayeeID deletes organisation association
*/
func (a *Client) DeleteConfirmationOfPayeeID(params *DeleteConfirmationOfPayeeIDParams) (*DeleteConfirmationOfPayeeIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteConfirmationOfPayeeIDParams()
	}

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

/*
  DeleteGocardlessID deletes gocardless gateway association
*/
func (a *Client) DeleteGocardlessID(params *DeleteGocardlessIDParams) (*DeleteGocardlessIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteGocardlessIDParams()
	}

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

/*
  DeleteLhvAssociationID deletes organisation lhv association
*/
func (a *Client) DeleteLhvAssociationID(params *DeleteLhvAssociationIDParams) (*DeleteLhvAssociationIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteLhvAssociationIDParams()
	}

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

/*
  DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationID deletes l h v organisation association agency synchronisation details
*/
func (a *Client) DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationID(params *DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams) (*DeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams()
	}

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

/*
  DeleteLhvAssociationIDMasterAccountsMasterAccountID deletes organisation association master account
*/
func (a *Client) DeleteLhvAssociationIDMasterAccountsMasterAccountID(params *DeleteLhvAssociationIDMasterAccountsMasterAccountIDParams) (*DeleteLhvAssociationIDMasterAccountsMasterAccountIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteLhvAssociationIDMasterAccountsMasterAccountIDParams()
	}

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

/*
  DeleteMandatemanagementID deletes mandate management association
*/
func (a *Client) DeleteMandatemanagementID(params *DeleteMandatemanagementIDParams) (*DeleteMandatemanagementIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteMandatemanagementIDParams()
	}

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

/*
  DeletePayportID deletes service association
*/
func (a *Client) DeletePayportID(params *DeletePayportIDParams) (*DeletePayportIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePayportIDParams()
	}

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

/*
  DeleteReconciliationAssociationID deletes organisation reconciliation service association
*/
func (a *Client) DeleteReconciliationAssociationID(params *DeleteReconciliationAssociationIDParams) (*DeleteReconciliationAssociationIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteReconciliationAssociationIDParams()
	}

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

/*
  DeleteSepaLiquidityID deletes organisation sepa liquidity association
*/
func (a *Client) DeleteSepaLiquidityID(params *DeleteSepaLiquidityIDParams) (*DeleteSepaLiquidityIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSepaLiquidityIDParams()
	}

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

/*
  DeleteSepactLiquidityAssociationID deletes s c t liquidity service association
*/
func (a *Client) DeleteSepactLiquidityAssociationID(params *DeleteSepactLiquidityAssociationIDParams) (*DeleteSepactLiquidityAssociationIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSepactLiquidityAssociationIDParams()
	}

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

/*
  DeleteSepaddID deletes organisation spea dd association
*/
func (a *Client) DeleteSepaddID(params *DeleteSepaddIDParams) (*DeleteSepaddIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSepaddIDParams()
	}

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

/*
  DeleteSepainstantID deletes organisation spea instant association
*/
func (a *Client) DeleteSepainstantID(params *DeleteSepainstantIDParams) (*DeleteSepainstantIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSepainstantIDParams()
	}

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

/*
  DeleteSepasctID deletes organisation spea sct association
*/
func (a *Client) DeleteSepasctID(params *DeleteSepasctIDParams) (*DeleteSepasctIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSepasctIDParams()
	}

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

/*
  DeleteStarlingID deletes organisation association
*/
func (a *Client) DeleteStarlingID(params *DeleteStarlingIDParams) (*DeleteStarlingIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteStarlingIDParams()
	}

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

/*
  DeleteSwiftID deletes organisation s w i f t association
*/
func (a *Client) DeleteSwiftID(params *DeleteSwiftIDParams) (*DeleteSwiftIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSwiftIDParams()
	}

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

/*
  DeleteVocalinkreportID deletes organisation association
*/
func (a *Client) DeleteVocalinkreportID(params *DeleteVocalinkreportIDParams) (*DeleteVocalinkreportIDNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVocalinkreportIDParams()
	}

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

/*
  GetBacs lists all organisation associations for b a c s
*/
func (a *Client) GetBacs(params *GetBacsParams) (*GetBacsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetBacsParams()
	}

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

/*
  GetBacsID fetches organisation association for b a c s
*/
func (a *Client) GetBacsID(params *GetBacsIDParams) (*GetBacsIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetBacsIDParams()
	}

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

/*
  GetConfirmationOfPayee lists all organisation associations
*/
func (a *Client) GetConfirmationOfPayee(params *GetConfirmationOfPayeeParams) (*GetConfirmationOfPayeeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetConfirmationOfPayeeParams()
	}

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

/*
  GetConfirmationOfPayeeID fetches organisation association
*/
func (a *Client) GetConfirmationOfPayeeID(params *GetConfirmationOfPayeeIDParams) (*GetConfirmationOfPayeeIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetConfirmationOfPayeeIDParams()
	}

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

/*
  GetGocardless lists all organisation gocardless gateway associations
*/
func (a *Client) GetGocardless(params *GetGocardlessParams) (*GetGocardlessOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetGocardlessParams()
	}

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

/*
  GetGocardlessID fetches organisation gocardless gateway association
*/
func (a *Client) GetGocardlessID(params *GetGocardlessIDParams) (*GetGocardlessIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetGocardlessIDParams()
	}

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

/*
  GetLhv lists all organisation lhv associations
*/
func (a *Client) GetLhv(params *GetLhvParams) (*GetLhvOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvParams()
	}

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

/*
  GetLhvAssociationID fetches organisation lhv association
*/
func (a *Client) GetLhvAssociationID(params *GetLhvAssociationIDParams) (*GetLhvAssociationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvAssociationIDParams()
	}

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

/*
  GetLhvAssociationIDAgencySynchronisations lists l h v agency synchronisation details
*/
func (a *Client) GetLhvAssociationIDAgencySynchronisations(params *GetLhvAssociationIDAgencySynchronisationsParams) (*GetLhvAssociationIDAgencySynchronisationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvAssociationIDAgencySynchronisationsParams()
	}

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

/*
  GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationID fetches l h v agency synchronisation details
*/
func (a *Client) GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationID(params *GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams) (*GetLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvAssociationIDAgencySynchronisationsAgencySynchronisationIDParams()
	}

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

/*
  GetLhvAssociationIDMasterAccounts lists master accounts
*/
func (a *Client) GetLhvAssociationIDMasterAccounts(params *GetLhvAssociationIDMasterAccountsParams) (*GetLhvAssociationIDMasterAccountsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvAssociationIDMasterAccountsParams()
	}

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

/*
  GetLhvAssociationIDMasterAccountsMasterAccountID fetches master account
*/
func (a *Client) GetLhvAssociationIDMasterAccountsMasterAccountID(params *GetLhvAssociationIDMasterAccountsMasterAccountIDParams) (*GetLhvAssociationIDMasterAccountsMasterAccountIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLhvAssociationIDMasterAccountsMasterAccountIDParams()
	}

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

/*
  GetMandatemanagementID fetches mandate management association
*/
func (a *Client) GetMandatemanagementID(params *GetMandatemanagementIDParams) (*GetMandatemanagementIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMandatemanagementIDParams()
	}

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

/*
  GetPayport lists all organisation associations
*/
func (a *Client) GetPayport(params *GetPayportParams) (*GetPayportOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPayportParams()
	}

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

/*
  GetPayportID fetches service association
*/
func (a *Client) GetPayportID(params *GetPayportIDParams) (*GetPayportIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPayportIDParams()
	}

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

/*
  GetReconciliation lists all organisation reconcilation service associations
*/
func (a *Client) GetReconciliation(params *GetReconciliationParams) (*GetReconciliationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReconciliationParams()
	}

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

/*
  GetReconciliationAssociationID fetches organisation reconciliation service association
*/
func (a *Client) GetReconciliationAssociationID(params *GetReconciliationAssociationIDParams) (*GetReconciliationAssociationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReconciliationAssociationIDParams()
	}

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

/*
  GetSepaLiquidity lists all organisation sepa liquidity associations
*/
func (a *Client) GetSepaLiquidity(params *GetSepaLiquidityParams) (*GetSepaLiquidityOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepaLiquidityParams()
	}

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

/*
  GetSepaLiquidityID fetches organisation sepa liquidity association
*/
func (a *Client) GetSepaLiquidityID(params *GetSepaLiquidityIDParams) (*GetSepaLiquidityIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepaLiquidityIDParams()
	}

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

/*
  GetSepactLiquidity lists all s c t liquidity service associations
*/
func (a *Client) GetSepactLiquidity(params *GetSepactLiquidityParams) (*GetSepactLiquidityOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepactLiquidityParams()
	}

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

/*
  GetSepactLiquidityAssociationID fetches s c t liquidity service association
*/
func (a *Client) GetSepactLiquidityAssociationID(params *GetSepactLiquidityAssociationIDParams) (*GetSepactLiquidityAssociationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepactLiquidityAssociationIDParams()
	}

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

/*
  GetSepadd lists all organisation sepa dd associations
*/
func (a *Client) GetSepadd(params *GetSepaddParams) (*GetSepaddOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepaddParams()
	}

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

/*
  GetSepaddID fetches organisation sepa dd association
*/
func (a *Client) GetSepaddID(params *GetSepaddIDParams) (*GetSepaddIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepaddIDParams()
	}

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

/*
  GetSepainstant lists all organisation sepa instant associations
*/
func (a *Client) GetSepainstant(params *GetSepainstantParams) (*GetSepainstantOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepainstantParams()
	}

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

/*
  GetSepainstantID fetches organisation sepa instant association
*/
func (a *Client) GetSepainstantID(params *GetSepainstantIDParams) (*GetSepainstantIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepainstantIDParams()
	}

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

/*
  GetSepasct lists all organisation sepa sct associations
*/
func (a *Client) GetSepasct(params *GetSepasctParams) (*GetSepasctOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepasctParams()
	}

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

/*
  GetSepasctID fetches organisation sepa sct association
*/
func (a *Client) GetSepasctID(params *GetSepasctIDParams) (*GetSepasctIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSepasctIDParams()
	}

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

/*
  GetStarling lists all organisation associations
*/
func (a *Client) GetStarling(params *GetStarlingParams) (*GetStarlingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStarlingParams()
	}

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

/*
  GetStarlingID fetches organisation association
*/
func (a *Client) GetStarlingID(params *GetStarlingIDParams) (*GetStarlingIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStarlingIDParams()
	}

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

/*
  GetSwift lists all organisation s w i f t associations
*/
func (a *Client) GetSwift(params *GetSwiftParams) (*GetSwiftOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSwiftParams()
	}

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

/*
  GetSwiftID fetches organisation s w i f t association
*/
func (a *Client) GetSwiftID(params *GetSwiftIDParams) (*GetSwiftIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSwiftIDParams()
	}

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

/*
  GetVocalinkreport lists all organisation associations
*/
func (a *Client) GetVocalinkreport(params *GetVocalinkreportParams) (*GetVocalinkreportOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVocalinkreportParams()
	}

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

/*
  GetVocalinkreportID fetches organisation association
*/
func (a *Client) GetVocalinkreportID(params *GetVocalinkreportIDParams) (*GetVocalinkreportIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVocalinkreportIDParams()
	}

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

/*
  PatchGocardlessID patches go cardless association by id
*/
func (a *Client) PatchGocardlessID(params *PatchGocardlessIDParams) (*PatchGocardlessIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchGocardlessIDParams()
	}

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

/*
  PatchLhvAssociationID patches organisation lhv association
*/
func (a *Client) PatchLhvAssociationID(params *PatchLhvAssociationIDParams) (*PatchLhvAssociationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchLhvAssociationIDParams()
	}

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

/*
  PatchSepactLiquidityAssociationID patches s c t liquidity service association
*/
func (a *Client) PatchSepactLiquidityAssociationID(params *PatchSepactLiquidityAssociationIDParams) (*PatchSepactLiquidityAssociationIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSepactLiquidityAssociationIDParams()
	}

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

/*
  PatchSepaddID updates organisation association for sepa dd
*/
func (a *Client) PatchSepaddID(params *PatchSepaddIDParams) (*PatchSepaddIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSepaddIDParams()
	}

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

/*
  PatchSepainstantID updates sepa instant association
*/
func (a *Client) PatchSepainstantID(params *PatchSepainstantIDParams) (*PatchSepainstantIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSepainstantIDParams()
	}

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

/*
  PatchSwiftID patches organisation s w i f t association
*/
func (a *Client) PatchSwiftID(params *PatchSwiftIDParams) (*PatchSwiftIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSwiftIDParams()
	}

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

/*
  PostBacs creates organisation association for b a c s
*/
func (a *Client) PostBacs(params *PostBacsParams) (*PostBacsCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostBacsParams()
	}

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

/*
  PostConfirmationOfPayee creates organisation association with confirmation of payee
*/
func (a *Client) PostConfirmationOfPayee(params *PostConfirmationOfPayeeParams) (*PostConfirmationOfPayeeCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostConfirmationOfPayeeParams()
	}

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

/*
  PostGocardless creates organisation association for go cardless gateway
*/
func (a *Client) PostGocardless(params *PostGocardlessParams) (*PostGocardlessCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostGocardlessParams()
	}

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

/*
  PostLhv creates organisation association for lhv
*/
func (a *Client) PostLhv(params *PostLhvParams) (*PostLhvCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostLhvParams()
	}

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

/*
  PostLhvAssociationIDAgencySynchronisations creates l h v organisation association agency synchronisation details
*/
func (a *Client) PostLhvAssociationIDAgencySynchronisations(params *PostLhvAssociationIDAgencySynchronisationsParams) (*PostLhvAssociationIDAgencySynchronisationsCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostLhvAssociationIDAgencySynchronisationsParams()
	}

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

/*
  PostLhvAssociationIDMasterAccounts creates organisation association master account
*/
func (a *Client) PostLhvAssociationIDMasterAccounts(params *PostLhvAssociationIDMasterAccountsParams) (*PostLhvAssociationIDMasterAccountsCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostLhvAssociationIDMasterAccountsParams()
	}

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

/*
  PostMandatemanagement creates mandate management association for organisation
*/
func (a *Client) PostMandatemanagement(params *PostMandatemanagementParams) (*PostMandatemanagementCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostMandatemanagementParams()
	}

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

/*
  PostPayport creates payport service association
*/
func (a *Client) PostPayport(params *PostPayportParams) (*PostPayportCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostPayportParams()
	}

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

/*
  PostReconciliation creates organisation association for reconciliation service
*/
func (a *Client) PostReconciliation(params *PostReconciliationParams) (*PostReconciliationCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostReconciliationParams()
	}

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

/*
  PostSepaLiquidity creates organisation association for sepa liquidity
*/
func (a *Client) PostSepaLiquidity(params *PostSepaLiquidityParams) (*PostSepaLiquidityCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSepaLiquidityParams()
	}

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

/*
  PostSepactLiquidity creates association for s c t liquidity service
*/
func (a *Client) PostSepactLiquidity(params *PostSepactLiquidityParams) (*PostSepactLiquidityCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSepactLiquidityParams()
	}

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

/*
  PostSepadd creates organisation association for sepa dd
*/
func (a *Client) PostSepadd(params *PostSepaddParams) (*PostSepaddCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSepaddParams()
	}

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

/*
  PostSepainstant creates organisation association for sepa instant
*/
func (a *Client) PostSepainstant(params *PostSepainstantParams) (*PostSepainstantCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSepainstantParams()
	}

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

/*
  PostSepasct creates organisation association for sepa sct
*/
func (a *Client) PostSepasct(params *PostSepasctParams) (*PostSepasctCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSepasctParams()
	}

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

/*
  PostStarling creates organisation association
*/
func (a *Client) PostStarling(params *PostStarlingParams) (*PostStarlingCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostStarlingParams()
	}

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

/*
  PostSwift creates organisation s w i f t association
*/
func (a *Client) PostSwift(params *PostSwiftParams) (*PostSwiftCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSwiftParams()
	}

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

/*
  PostVocalinkreport creates organisation association
*/
func (a *Client) PostVocalinkreport(params *PostVocalinkreportParams) (*PostVocalinkreportCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVocalinkreportParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVocalinkreport",
		Method:             "POST",
		PathPattern:        "/vocalinkreport",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json", "application/vnd.api+json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVocalinkreportReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostVocalinkreportCreated)
	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 PostVocalinkreport: 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
}