func (a *Client) QueryRemediationsFilter(params *QueryRemediationsFilterParams, opts ...ClientOption) (*QueryRemediationsFilterOK, error) {
	if params == nil {
		params = NewQueryRemediationsFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryRemediationsFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/remediations/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryRemediationsFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryRemediationsFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryRemediationsFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
QueryRemediationsFilter retrieves remediation tickets that match the provided filter criteria with scrolling enabled
package falcon_complete_dashboard
import (
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}
type ClientOption func(*runtime.ClientOperation)
type ClientService interface {
	AggregateAllowList(params *AggregateAllowListParams, opts ...ClientOption) (*AggregateAllowListOK, error)
	AggregateBlockList(params *AggregateBlockListParams, opts ...ClientOption) (*AggregateBlockListOK, error)
	AggregateDetections(params *AggregateDetectionsParams, opts ...ClientOption) (*AggregateDetectionsOK, error)
	AggregateDeviceCountCollection(params *AggregateDeviceCountCollectionParams, opts ...ClientOption) (*AggregateDeviceCountCollectionOK, error)
	AggregateEscalations(params *AggregateEscalationsParams, opts ...ClientOption) (*AggregateEscalationsOK, error)
	AggregateFCIncidents(params *AggregateFCIncidentsParams, opts ...ClientOption) (*AggregateFCIncidentsOK, error)
	AggregateRemediations(params *AggregateRemediationsParams, opts ...ClientOption) (*AggregateRemediationsOK, error)
	GetDeviceCountCollectionQueriesByFilter(params *GetDeviceCountCollectionQueriesByFilterParams, opts ...ClientOption) (*GetDeviceCountCollectionQueriesByFilterOK, error)
	QueryAllowListFilter(params *QueryAllowListFilterParams, opts ...ClientOption) (*QueryAllowListFilterOK, error)
	QueryBlockListFilter(params *QueryBlockListFilterParams, opts ...ClientOption) (*QueryBlockListFilterOK, error)
	QueryDetectionIdsByFilter(params *QueryDetectionIdsByFilterParams, opts ...ClientOption) (*QueryDetectionIdsByFilterOK, error)
	QueryEscalationsFilter(params *QueryEscalationsFilterParams, opts ...ClientOption) (*QueryEscalationsFilterOK, error)
	QueryIncidentIdsByFilter(params *QueryIncidentIdsByFilterParams, opts ...ClientOption) (*QueryIncidentIdsByFilterOK, error)
	QueryRemediationsFilter(params *QueryRemediationsFilterParams, opts ...ClientOption) (*QueryRemediationsFilterOK, error)
	SetTransport(transport runtime.ClientTransport)
}
func (a *Client) AggregateAllowList(params *AggregateAllowListParams, opts ...ClientOption) (*AggregateAllowListOK, error) {
	if params == nil {
		params = NewAggregateAllowListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateAllowList",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/allowlist/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateAllowListReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateAllowListOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateAllowListDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateBlockList(params *AggregateBlockListParams, opts ...ClientOption) (*AggregateBlockListOK, error) {
	if params == nil {
		params = NewAggregateBlockListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateBlockList",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/blocklist/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateBlockListReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateBlockListOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateBlockListDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateDetections(params *AggregateDetectionsParams, opts ...ClientOption) (*AggregateDetectionsOK, error) {
	if params == nil {
		params = NewAggregateDetectionsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateDetections",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/detects/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateDetectionsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateDetectionsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateDetectionsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateDeviceCountCollection(params *AggregateDeviceCountCollectionParams, opts ...ClientOption) (*AggregateDeviceCountCollectionOK, error) {
	if params == nil {
		params = NewAggregateDeviceCountCollectionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateDeviceCountCollection",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/devicecount-collections/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateDeviceCountCollectionReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateDeviceCountCollectionOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateDeviceCountCollectionDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateEscalations(params *AggregateEscalationsParams, opts ...ClientOption) (*AggregateEscalationsOK, error) {
	if params == nil {
		params = NewAggregateEscalationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateEscalations",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/escalations/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateEscalationsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateEscalationsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateEscalationsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateFCIncidents(params *AggregateFCIncidentsParams, opts ...ClientOption) (*AggregateFCIncidentsOK, error) {
	if params == nil {
		params = NewAggregateFCIncidentsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateFCIncidents",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/incidents/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateFCIncidentsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateFCIncidentsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateFCIncidentsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateRemediations(params *AggregateRemediationsParams, opts ...ClientOption) (*AggregateRemediationsOK, error) {
	if params == nil {
		params = NewAggregateRemediationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "AggregateRemediations",
		Method:             "POST",
		PathPattern:        "/falcon-complete-dashboards/aggregates/remediations/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateRemediationsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*AggregateRemediationsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateRemediationsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetDeviceCountCollectionQueriesByFilter(params *GetDeviceCountCollectionQueriesByFilterParams, opts ...ClientOption) (*GetDeviceCountCollectionQueriesByFilterOK, error) {
	if params == nil {
		params = NewGetDeviceCountCollectionQueriesByFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetDeviceCountCollectionQueriesByFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/devicecount-collections/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceCountCollectionQueriesByFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDeviceCountCollectionQueriesByFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetDeviceCountCollectionQueriesByFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryAllowListFilter(params *QueryAllowListFilterParams, opts ...ClientOption) (*QueryAllowListFilterOK, error) {
	if params == nil {
		params = NewQueryAllowListFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryAllowListFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/allowlist/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryAllowListFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryAllowListFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryAllowListFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryBlockListFilter(params *QueryBlockListFilterParams, opts ...ClientOption) (*QueryBlockListFilterOK, error) {
	if params == nil {
		params = NewQueryBlockListFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryBlockListFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/blocklist/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryBlockListFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryBlockListFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryBlockListFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryDetectionIdsByFilter(params *QueryDetectionIdsByFilterParams, opts ...ClientOption) (*QueryDetectionIdsByFilterOK, error) {
	if params == nil {
		params = NewQueryDetectionIdsByFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryDetectionIdsByFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/detects/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryDetectionIdsByFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryDetectionIdsByFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryDetectionIdsByFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryEscalationsFilter(params *QueryEscalationsFilterParams, opts ...ClientOption) (*QueryEscalationsFilterOK, error) {
	if params == nil {
		params = NewQueryEscalationsFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryEscalationsFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/escalations/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryEscalationsFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryEscalationsFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryEscalationsFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIncidentIdsByFilter(params *QueryIncidentIdsByFilterParams, opts ...ClientOption) (*QueryIncidentIdsByFilterOK, error) {
	if params == nil {
		params = NewQueryIncidentIdsByFilterParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIncidentIdsByFilter",
		Method:             "GET",
		PathPattern:        "/falcon-complete-dashboards/queries/incidents/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIncidentIdsByFilterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}
	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*QueryIncidentIdsByFilterOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIncidentIdsByFilterDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}