func (a *Client) SchedulerActionsDiscovery(params *SchedulerActionsDiscoveryParams) (*SchedulerActionsDiscoveryOK, error) {
	if params == nil {
		params = NewSchedulerActionsDiscoveryParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "SchedulerActionsDiscovery",
		Method:             "GET",
		PathPattern:        "/config/scheduler/actions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &SchedulerActionsDiscoveryReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*SchedulerActionsDiscoveryOK), nil
}
/*
SchedulerActionsDiscovery publishes scheduler registered actions
package config_service
import (
	"github.com/go-openapi/runtime"
	strfmt "github.com/go-openapi/strfmt"
)
func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
	return &Client{transport: transport, formats: formats}
}
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}
func (a *Client) ConfigFormsDiscovery(params *ConfigFormsDiscoveryParams) (*ConfigFormsDiscoveryOK, error) {
	if params == nil {
		params = NewConfigFormsDiscoveryParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ConfigFormsDiscovery",
		Method:             "GET",
		PathPattern:        "/config/discovery/forms/{ServiceName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ConfigFormsDiscoveryReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ConfigFormsDiscoveryOK), nil
}
func (a *Client) ControlService(params *ControlServiceParams) (*ControlServiceOK, error) {
	if params == nil {
		params = NewControlServiceParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ControlService",
		Method:             "POST",
		PathPattern:        "/config/ctl",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ControlServiceReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ControlServiceOK), nil
}
func (a *Client) CreateEncryptionKey(params *CreateEncryptionKeyParams) (*CreateEncryptionKeyOK, error) {
	if params == nil {
		params = NewCreateEncryptionKeyParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "CreateEncryptionKey",
		Method:             "POST",
		PathPattern:        "/config/encryption/create",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &CreateEncryptionKeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*CreateEncryptionKeyOK), nil
}
func (a *Client) CreatePeerFolder(params *CreatePeerFolderParams) (*CreatePeerFolderOK, error) {
	if params == nil {
		params = NewCreatePeerFolderParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "CreatePeerFolder",
		Method:             "PUT",
		PathPattern:        "/config/peers/{PeerAddress}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &CreatePeerFolderReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*CreatePeerFolderOK), nil
}
func (a *Client) DeleteDataSource(params *DeleteDataSourceParams) (*DeleteDataSourceOK, error) {
	if params == nil {
		params = NewDeleteDataSourceParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteDataSource",
		Method:             "DELETE",
		PathPattern:        "/config/datasource/{Name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &DeleteDataSourceReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDataSourceOK), nil
}
func (a *Client) DeleteEncryptionKey(params *DeleteEncryptionKeyParams) (*DeleteEncryptionKeyOK, error) {
	if params == nil {
		params = NewDeleteEncryptionKeyParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteEncryptionKey",
		Method:             "POST",
		PathPattern:        "/config/encryption/delete",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &DeleteEncryptionKeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteEncryptionKeyOK), nil
}
func (a *Client) EndpointsDiscovery(params *EndpointsDiscoveryParams) (*EndpointsDiscoveryOK, error) {
	if params == nil {
		params = NewEndpointsDiscoveryParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "EndpointsDiscovery",
		Method:             "GET",
		PathPattern:        "/config/discovery",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &EndpointsDiscoveryReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*EndpointsDiscoveryOK), nil
}
func (a *Client) ExportEncryptionKey(params *ExportEncryptionKeyParams) (*ExportEncryptionKeyOK, error) {
	if params == nil {
		params = NewExportEncryptionKeyParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ExportEncryptionKey",
		Method:             "POST",
		PathPattern:        "/config/encryption/export",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ExportEncryptionKeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ExportEncryptionKeyOK), nil
}
func (a *Client) GetConfig(params *GetConfigParams) (*GetConfigOK, error) {
	if params == nil {
		params = NewGetConfigParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetConfig",
		Method:             "GET",
		PathPattern:        "/config/{FullPath}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &GetConfigReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetConfigOK), nil
}
func (a *Client) GetDataSource(params *GetDataSourceParams) (*GetDataSourceOK, error) {
	if params == nil {
		params = NewGetDataSourceParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetDataSource",
		Method:             "GET",
		PathPattern:        "/config/datasource/{Name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &GetDataSourceReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDataSourceOK), nil
}
func (a *Client) GetVersioningPolicy(params *GetVersioningPolicyParams) (*GetVersioningPolicyOK, error) {
	if params == nil {
		params = NewGetVersioningPolicyParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVersioningPolicy",
		Method:             "GET",
		PathPattern:        "/config/versioning/{Uuid}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &GetVersioningPolicyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVersioningPolicyOK), nil
}
func (a *Client) ImportEncryptionKey(params *ImportEncryptionKeyParams) (*ImportEncryptionKeyOK, error) {
	if params == nil {
		params = NewImportEncryptionKeyParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ImportEncryptionKey",
		Method:             "PUT",
		PathPattern:        "/config/encryption/import",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ImportEncryptionKeyReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportEncryptionKeyOK), nil
}
func (a *Client) ListDataSources(params *ListDataSourcesParams) (*ListDataSourcesOK, error) {
	if params == nil {
		params = NewListDataSourcesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListDataSources",
		Method:             "GET",
		PathPattern:        "/config/datasource",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListDataSourcesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListDataSourcesOK), nil
}
func (a *Client) ListEncryptionKeys(params *ListEncryptionKeysParams) (*ListEncryptionKeysOK, error) {
	if params == nil {
		params = NewListEncryptionKeysParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListEncryptionKeys",
		Method:             "POST",
		PathPattern:        "/config/encryption/list",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListEncryptionKeysReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListEncryptionKeysOK), nil
}
func (a *Client) ListPeerFolders(params *ListPeerFoldersParams) (*ListPeerFoldersOK, error) {
	if params == nil {
		params = NewListPeerFoldersParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListPeerFolders",
		Method:             "POST",
		PathPattern:        "/config/peers/{PeerAddress}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListPeerFoldersReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListPeerFoldersOK), nil
}
func (a *Client) ListPeersAddresses(params *ListPeersAddressesParams) (*ListPeersAddressesOK, error) {
	if params == nil {
		params = NewListPeersAddressesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListPeersAddresses",
		Method:             "GET",
		PathPattern:        "/config/peers",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListPeersAddressesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListPeersAddressesOK), nil
}
func (a *Client) ListProcesses(params *ListProcessesParams) (*ListProcessesOK, error) {
	if params == nil {
		params = NewListProcessesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListProcesses",
		Method:             "POST",
		PathPattern:        "/config/processes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListProcessesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListProcessesOK), nil
}
func (a *Client) ListServices(params *ListServicesParams) (*ListServicesOK, error) {
	if params == nil {
		params = NewListServicesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListServices",
		Method:             "GET",
		PathPattern:        "/config/ctl",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListServicesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListServicesOK), nil
}
func (a *Client) ListStorageBuckets(params *ListStorageBucketsParams) (*ListStorageBucketsOK, error) {
	if params == nil {
		params = NewListStorageBucketsParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListStorageBuckets",
		Method:             "POST",
		PathPattern:        "/config/buckets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListStorageBucketsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListStorageBucketsOK), nil
}
func (a *Client) ListVersioningPolicies(params *ListVersioningPoliciesParams) (*ListVersioningPoliciesOK, error) {
	if params == nil {
		params = NewListVersioningPoliciesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListVersioningPolicies",
		Method:             "GET",
		PathPattern:        "/config/versioning",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListVersioningPoliciesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListVersioningPoliciesOK), nil
}
func (a *Client) ListVirtualNodes(params *ListVirtualNodesParams) (*ListVirtualNodesOK, error) {
	if params == nil {
		params = NewListVirtualNodesParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ListVirtualNodes",
		Method:             "GET",
		PathPattern:        "/config/virtualnodes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &ListVirtualNodesReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ListVirtualNodesOK), nil
}
func (a *Client) OpenAPIDiscovery(params *OpenAPIDiscoveryParams) (*OpenAPIDiscoveryOK, error) {
	if params == nil {
		params = NewOpenAPIDiscoveryParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "OpenApiDiscovery",
		Method:             "GET",
		PathPattern:        "/config/discovery/openapi",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &OpenAPIDiscoveryReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*OpenAPIDiscoveryOK), nil
}
func (a *Client) PutConfig(params *PutConfigParams) (*PutConfigOK, error) {
	if params == nil {
		params = NewPutConfigParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutConfig",
		Method:             "PUT",
		PathPattern:        "/config/{FullPath}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &PutConfigReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutConfigOK), nil
}
func (a *Client) PutDataSource(params *PutDataSourceParams) (*PutDataSourceOK, error) {
	if params == nil {
		params = NewPutDataSourceParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutDataSource",
		Method:             "POST",
		PathPattern:        "/config/datasource/{Name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &PutDataSourceReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutDataSourceOK), nil
}
func (a *Client) SchedulerActionFormDiscovery(params *SchedulerActionFormDiscoveryParams) (*SchedulerActionFormDiscoveryOK, error) {
	if params == nil {
		params = NewSchedulerActionFormDiscoveryParams()
	}
	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "SchedulerActionFormDiscovery",
		Method:             "GET",
		PathPattern:        "/config/scheduler/actions/{ActionName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https", "wss"},
		Params:             params,
		Reader:             &SchedulerActionFormDiscoveryReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*SchedulerActionFormDiscoveryOK), nil
}