func (a *Client) GetRuleGroups(params *GetRuleGroupsParams, opts ...ClientOption) (*GetRuleGroupsOK, error) {
	if params == nil {
		params = NewGetRuleGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-rule-groups",
		Method:             "GET",
		PathPattern:        "/fwmgr/entities/rule-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetRuleGroupsReader{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.(*GetRuleGroupsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetRuleGroupsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
GetRuleGroups gets rule group entities by ID these groups do not contain their rule entites just the rule i ds in precedence order
package firewall_management
import (
	"fmt"
	"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 {
	AggregateEvents(params *AggregateEventsParams, opts ...ClientOption) (*AggregateEventsOK, error)
	AggregatePolicyRules(params *AggregatePolicyRulesParams, opts ...ClientOption) (*AggregatePolicyRulesOK, error)
	AggregateRuleGroups(params *AggregateRuleGroupsParams, opts ...ClientOption) (*AggregateRuleGroupsOK, error)
	AggregateRules(params *AggregateRulesParams, opts ...ClientOption) (*AggregateRulesOK, error)
	CreateRuleGroup(params *CreateRuleGroupParams, opts ...ClientOption) (*CreateRuleGroupCreated, error)
	DeleteRuleGroups(params *DeleteRuleGroupsParams, opts ...ClientOption) (*DeleteRuleGroupsOK, error)
	GetEvents(params *GetEventsParams, opts ...ClientOption) (*GetEventsOK, error)
	GetFirewallFields(params *GetFirewallFieldsParams, opts ...ClientOption) (*GetFirewallFieldsOK, error)
	GetPlatforms(params *GetPlatformsParams, opts ...ClientOption) (*GetPlatformsOK, error)
	GetPolicyContainers(params *GetPolicyContainersParams, opts ...ClientOption) (*GetPolicyContainersOK, error)
	GetRuleGroups(params *GetRuleGroupsParams, opts ...ClientOption) (*GetRuleGroupsOK, error)
	GetRules(params *GetRulesParams, opts ...ClientOption) (*GetRulesOK, error)
	QueryEvents(params *QueryEventsParams, opts ...ClientOption) (*QueryEventsOK, error)
	QueryFirewallFields(params *QueryFirewallFieldsParams, opts ...ClientOption) (*QueryFirewallFieldsOK, error)
	QueryPlatforms(params *QueryPlatformsParams, opts ...ClientOption) (*QueryPlatformsOK, error)
	QueryPolicyRules(params *QueryPolicyRulesParams, opts ...ClientOption) (*QueryPolicyRulesOK, error)
	QueryRuleGroups(params *QueryRuleGroupsParams, opts ...ClientOption) (*QueryRuleGroupsOK, error)
	QueryRules(params *QueryRulesParams, opts ...ClientOption) (*QueryRulesOK, error)
	UpdatePolicyContainer(params *UpdatePolicyContainerParams, opts ...ClientOption) (*UpdatePolicyContainerOK, *UpdatePolicyContainerCreated, error)
	UpdateRuleGroup(params *UpdateRuleGroupParams, opts ...ClientOption) (*UpdateRuleGroupOK, error)
	SetTransport(transport runtime.ClientTransport)
}
func (a *Client) AggregateEvents(params *AggregateEventsParams, opts ...ClientOption) (*AggregateEventsOK, error) {
	if params == nil {
		params = NewAggregateEventsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "aggregate-events",
		Method:             "POST",
		PathPattern:        "/fwmgr/aggregates/events/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateEventsReader{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.(*AggregateEventsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateEventsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregatePolicyRules(params *AggregatePolicyRulesParams, opts ...ClientOption) (*AggregatePolicyRulesOK, error) {
	if params == nil {
		params = NewAggregatePolicyRulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "aggregate-policy-rules",
		Method:             "POST",
		PathPattern:        "/fwmgr/aggregates/policy-rules/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregatePolicyRulesReader{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.(*AggregatePolicyRulesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregatePolicyRulesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateRuleGroups(params *AggregateRuleGroupsParams, opts ...ClientOption) (*AggregateRuleGroupsOK, error) {
	if params == nil {
		params = NewAggregateRuleGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "aggregate-rule-groups",
		Method:             "POST",
		PathPattern:        "/fwmgr/aggregates/rule-groups/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateRuleGroupsReader{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.(*AggregateRuleGroupsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateRuleGroupsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AggregateRules(params *AggregateRulesParams, opts ...ClientOption) (*AggregateRulesOK, error) {
	if params == nil {
		params = NewAggregateRulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "aggregate-rules",
		Method:             "POST",
		PathPattern:        "/fwmgr/aggregates/rules/GET/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AggregateRulesReader{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.(*AggregateRulesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*AggregateRulesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) CreateRuleGroup(params *CreateRuleGroupParams, opts ...ClientOption) (*CreateRuleGroupCreated, error) {
	if params == nil {
		params = NewCreateRuleGroupParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "create-rule-group",
		Method:             "POST",
		PathPattern:        "/fwmgr/entities/rule-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateRuleGroupReader{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.(*CreateRuleGroupCreated)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for create-rule-group: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) DeleteRuleGroups(params *DeleteRuleGroupsParams, opts ...ClientOption) (*DeleteRuleGroupsOK, error) {
	if params == nil {
		params = NewDeleteRuleGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "delete-rule-groups",
		Method:             "DELETE",
		PathPattern:        "/fwmgr/entities/rule-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteRuleGroupsReader{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.(*DeleteRuleGroupsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*DeleteRuleGroupsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetEvents(params *GetEventsParams, opts ...ClientOption) (*GetEventsOK, error) {
	if params == nil {
		params = NewGetEventsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-events",
		Method:             "GET",
		PathPattern:        "/fwmgr/entities/events/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetEventsReader{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.(*GetEventsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetEventsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetFirewallFields(params *GetFirewallFieldsParams, opts ...ClientOption) (*GetFirewallFieldsOK, error) {
	if params == nil {
		params = NewGetFirewallFieldsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-firewall-fields",
		Method:             "GET",
		PathPattern:        "/fwmgr/entities/firewall-fields/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetFirewallFieldsReader{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.(*GetFirewallFieldsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetFirewallFieldsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetPlatforms(params *GetPlatformsParams, opts ...ClientOption) (*GetPlatformsOK, error) {
	if params == nil {
		params = NewGetPlatformsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-platforms",
		Method:             "GET",
		PathPattern:        "/fwmgr/entities/platforms/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPlatformsReader{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.(*GetPlatformsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetPlatformsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetPolicyContainers(params *GetPolicyContainersParams, opts ...ClientOption) (*GetPolicyContainersOK, error) {
	if params == nil {
		params = NewGetPolicyContainersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-policy-containers",
		Method:             "GET",
		PathPattern:        "/fwmgr/entities/policies/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPolicyContainersReader{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.(*GetPolicyContainersOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetPolicyContainersDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}