func (a *Client) QueryIntelRuleIds(params *QueryIntelRuleIdsParams, opts ...ClientOption) (*QueryIntelRuleIdsOK, error) {
	if params == nil {
		params = NewQueryIntelRuleIdsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelRuleIds",
		Method:             "GET",
		PathPattern:        "/intel/queries/rules/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelRuleIdsReader{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.(*QueryIntelRuleIdsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelRuleIdsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
QueryIntelRuleIds searches for rule i ds that match provided filter criteria
package intel
import (
	"io"
	"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 {
	GetIntelActorEntities(params *GetIntelActorEntitiesParams, opts ...ClientOption) (*GetIntelActorEntitiesOK, error)
	GetIntelIndicatorEntities(params *GetIntelIndicatorEntitiesParams, opts ...ClientOption) (*GetIntelIndicatorEntitiesOK, error)
	GetIntelReportEntities(params *GetIntelReportEntitiesParams, opts ...ClientOption) (*GetIntelReportEntitiesOK, error)
	GetIntelReportPDF(params *GetIntelReportPDFParams, writer io.Writer, opts ...ClientOption) (*GetIntelReportPDFOK, error)
	GetIntelRuleEntities(params *GetIntelRuleEntitiesParams, opts ...ClientOption) (*GetIntelRuleEntitiesOK, error)
	GetIntelRuleFile(params *GetIntelRuleFileParams, writer io.Writer, opts ...ClientOption) (*GetIntelRuleFileOK, error)
	GetLatestIntelRuleFile(params *GetLatestIntelRuleFileParams, writer io.Writer, opts ...ClientOption) (*GetLatestIntelRuleFileOK, error)
	QueryIntelActorEntities(params *QueryIntelActorEntitiesParams, opts ...ClientOption) (*QueryIntelActorEntitiesOK, error)
	QueryIntelActorIds(params *QueryIntelActorIdsParams, opts ...ClientOption) (*QueryIntelActorIdsOK, error)
	QueryIntelIndicatorEntities(params *QueryIntelIndicatorEntitiesParams, opts ...ClientOption) (*QueryIntelIndicatorEntitiesOK, error)
	QueryIntelIndicatorIds(params *QueryIntelIndicatorIdsParams, opts ...ClientOption) (*QueryIntelIndicatorIdsOK, error)
	QueryIntelReportEntities(params *QueryIntelReportEntitiesParams, opts ...ClientOption) (*QueryIntelReportEntitiesOK, error)
	QueryIntelReportIds(params *QueryIntelReportIdsParams, opts ...ClientOption) (*QueryIntelReportIdsOK, error)
	QueryIntelRuleIds(params *QueryIntelRuleIdsParams, opts ...ClientOption) (*QueryIntelRuleIdsOK, error)
	SetTransport(transport runtime.ClientTransport)
}
func (a *Client) GetIntelActorEntities(params *GetIntelActorEntitiesParams, opts ...ClientOption) (*GetIntelActorEntitiesOK, error) {
	if params == nil {
		params = NewGetIntelActorEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelActorEntities",
		Method:             "GET",
		PathPattern:        "/intel/entities/actors/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelActorEntitiesReader{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.(*GetIntelActorEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelActorEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetIntelIndicatorEntities(params *GetIntelIndicatorEntitiesParams, opts ...ClientOption) (*GetIntelIndicatorEntitiesOK, error) {
	if params == nil {
		params = NewGetIntelIndicatorEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelIndicatorEntities",
		Method:             "POST",
		PathPattern:        "/intel/entities/indicators/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelIndicatorEntitiesReader{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.(*GetIntelIndicatorEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelIndicatorEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetIntelReportEntities(params *GetIntelReportEntitiesParams, opts ...ClientOption) (*GetIntelReportEntitiesOK, error) {
	if params == nil {
		params = NewGetIntelReportEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelReportEntities",
		Method:             "GET",
		PathPattern:        "/intel/entities/reports/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelReportEntitiesReader{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.(*GetIntelReportEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelReportEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetIntelReportPDF(params *GetIntelReportPDFParams, writer io.Writer, opts ...ClientOption) (*GetIntelReportPDFOK, error) {
	if params == nil {
		params = NewGetIntelReportPDFParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelReportPDF",
		Method:             "GET",
		PathPattern:        "/intel/entities/report-files/v1",
		ProducesMediaTypes: []string{"application/json", "application/octet-stream", "application/pdf"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelReportPDFReader{formats: a.formats, writer: writer},
		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.(*GetIntelReportPDFOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelReportPDFDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetIntelRuleEntities(params *GetIntelRuleEntitiesParams, opts ...ClientOption) (*GetIntelRuleEntitiesOK, error) {
	if params == nil {
		params = NewGetIntelRuleEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelRuleEntities",
		Method:             "GET",
		PathPattern:        "/intel/entities/rules/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelRuleEntitiesReader{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.(*GetIntelRuleEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelRuleEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetIntelRuleFile(params *GetIntelRuleFileParams, writer io.Writer, opts ...ClientOption) (*GetIntelRuleFileOK, error) {
	if params == nil {
		params = NewGetIntelRuleFileParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetIntelRuleFile",
		Method:             "GET",
		PathPattern:        "/intel/entities/rules-files/v1",
		ProducesMediaTypes: []string{"*/*", "application/gzip", "application/json", "application/octet-stream", "application/zip"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetIntelRuleFileReader{formats: a.formats, writer: writer},
		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.(*GetIntelRuleFileOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetIntelRuleFileDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetLatestIntelRuleFile(params *GetLatestIntelRuleFileParams, writer io.Writer, opts ...ClientOption) (*GetLatestIntelRuleFileOK, error) {
	if params == nil {
		params = NewGetLatestIntelRuleFileParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "GetLatestIntelRuleFile",
		Method:             "GET",
		PathPattern:        "/intel/entities/rules-latest-files/v1",
		ProducesMediaTypes: []string{"*/*", "application/gzip", "application/json", "application/octet-stream", "application/zip"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetLatestIntelRuleFileReader{formats: a.formats, writer: writer},
		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.(*GetLatestIntelRuleFileOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetLatestIntelRuleFileDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelActorEntities(params *QueryIntelActorEntitiesParams, opts ...ClientOption) (*QueryIntelActorEntitiesOK, error) {
	if params == nil {
		params = NewQueryIntelActorEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelActorEntities",
		Method:             "GET",
		PathPattern:        "/intel/combined/actors/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelActorEntitiesReader{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.(*QueryIntelActorEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelActorEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelActorIds(params *QueryIntelActorIdsParams, opts ...ClientOption) (*QueryIntelActorIdsOK, error) {
	if params == nil {
		params = NewQueryIntelActorIdsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelActorIds",
		Method:             "GET",
		PathPattern:        "/intel/queries/actors/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelActorIdsReader{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.(*QueryIntelActorIdsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelActorIdsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelIndicatorEntities(params *QueryIntelIndicatorEntitiesParams, opts ...ClientOption) (*QueryIntelIndicatorEntitiesOK, error) {
	if params == nil {
		params = NewQueryIntelIndicatorEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelIndicatorEntities",
		Method:             "GET",
		PathPattern:        "/intel/combined/indicators/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelIndicatorEntitiesReader{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.(*QueryIntelIndicatorEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelIndicatorEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelIndicatorIds(params *QueryIntelIndicatorIdsParams, opts ...ClientOption) (*QueryIntelIndicatorIdsOK, error) {
	if params == nil {
		params = NewQueryIntelIndicatorIdsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelIndicatorIds",
		Method:             "GET",
		PathPattern:        "/intel/queries/indicators/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelIndicatorIdsReader{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.(*QueryIntelIndicatorIdsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelIndicatorIdsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelReportEntities(params *QueryIntelReportEntitiesParams, opts ...ClientOption) (*QueryIntelReportEntitiesOK, error) {
	if params == nil {
		params = NewQueryIntelReportEntitiesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelReportEntities",
		Method:             "GET",
		PathPattern:        "/intel/combined/reports/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelReportEntitiesReader{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.(*QueryIntelReportEntitiesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelReportEntitiesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) QueryIntelReportIds(params *QueryIntelReportIdsParams, opts ...ClientOption) (*QueryIntelReportIdsOK, error) {
	if params == nil {
		params = NewQueryIntelReportIdsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "QueryIntelReportIds",
		Method:             "GET",
		PathPattern:        "/intel/queries/reports/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &QueryIntelReportIdsReader{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.(*QueryIntelReportIdsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*QueryIntelReportIdsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}