func (a *Client) GetPlatformsMixin0(params *GetPlatformsMixin0Params, opts ...ClientOption) (*GetPlatformsMixin0OK, error) {
	if params == nil {
		params = NewGetPlatformsMixin0Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-platformsMixin0",
		Method:             "GET",
		PathPattern:        "/ioarules/entities/platforms/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPlatformsMixin0Reader{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.(*GetPlatformsMixin0OK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetPlatformsMixin0Default)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
GetPlatformsMixin0 gets platforms by ID
package custom_ioa
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 {
	CreateRule(params *CreateRuleParams, opts ...ClientOption) (*CreateRuleCreated, error)
	CreateRuleGroupMixin0(params *CreateRuleGroupMixin0Params, opts ...ClientOption) (*CreateRuleGroupMixin0Created, error)
	DeleteRuleGroupsMixin0(params *DeleteRuleGroupsMixin0Params, opts ...ClientOption) (*DeleteRuleGroupsMixin0OK, error)
	DeleteRules(params *DeleteRulesParams, opts ...ClientOption) (*DeleteRulesOK, error)
	GetPatterns(params *GetPatternsParams, opts ...ClientOption) (*GetPatternsOK, error)
	GetPlatformsMixin0(params *GetPlatformsMixin0Params, opts ...ClientOption) (*GetPlatformsMixin0OK, error)
	GetRuleGroupsMixin0(params *GetRuleGroupsMixin0Params, opts ...ClientOption) (*GetRuleGroupsMixin0OK, error)
	GetRuleTypes(params *GetRuleTypesParams, opts ...ClientOption) (*GetRuleTypesOK, error)
	GetRulesGet(params *GetRulesGetParams, opts ...ClientOption) (*GetRulesGetOK, error)
	GetRulesMixin0(params *GetRulesMixin0Params, opts ...ClientOption) (*GetRulesMixin0OK, error)
	QueryPatterns(params *QueryPatternsParams, opts ...ClientOption) (*QueryPatternsOK, error)
	QueryPlatformsMixin0(params *QueryPlatformsMixin0Params, opts ...ClientOption) (*QueryPlatformsMixin0OK, error)
	QueryRuleGroupsFull(params *QueryRuleGroupsFullParams, opts ...ClientOption) (*QueryRuleGroupsFullOK, error)
	QueryRuleGroupsMixin0(params *QueryRuleGroupsMixin0Params, opts ...ClientOption) (*QueryRuleGroupsMixin0OK, error)
	QueryRuleTypes(params *QueryRuleTypesParams, opts ...ClientOption) (*QueryRuleTypesOK, error)
	QueryRulesMixin0(params *QueryRulesMixin0Params, opts ...ClientOption) (*QueryRulesMixin0OK, error)
	UpdateRuleGroupMixin0(params *UpdateRuleGroupMixin0Params, opts ...ClientOption) (*UpdateRuleGroupMixin0OK, error)
	UpdateRules(params *UpdateRulesParams, opts ...ClientOption) (*UpdateRulesOK, error)
	Validate(params *ValidateParams, opts ...ClientOption) (*ValidateOK, error)
	SetTransport(transport runtime.ClientTransport)
}
func (a *Client) CreateRule(params *CreateRuleParams, opts ...ClientOption) (*CreateRuleCreated, error) {
	if params == nil {
		params = NewCreateRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "create-rule",
		Method:             "POST",
		PathPattern:        "/ioarules/entities/rules/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateRuleReader{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.(*CreateRuleCreated)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for create-rule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) CreateRuleGroupMixin0(params *CreateRuleGroupMixin0Params, opts ...ClientOption) (*CreateRuleGroupMixin0Created, error) {
	if params == nil {
		params = NewCreateRuleGroupMixin0Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "create-rule-groupMixin0",
		Method:             "POST",
		PathPattern:        "/ioarules/entities/rule-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateRuleGroupMixin0Reader{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.(*CreateRuleGroupMixin0Created)
	if ok {
		return success, nil
	}
	msg := fmt.Sprintf("unexpected success response for create-rule-groupMixin0: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}
func (a *Client) DeleteRuleGroupsMixin0(params *DeleteRuleGroupsMixin0Params, opts ...ClientOption) (*DeleteRuleGroupsMixin0OK, error) {
	if params == nil {
		params = NewDeleteRuleGroupsMixin0Params()
	}
	op := &runtime.ClientOperation{
		ID:                 "delete-rule-groupsMixin0",
		Method:             "DELETE",
		PathPattern:        "/ioarules/entities/rule-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteRuleGroupsMixin0Reader{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.(*DeleteRuleGroupsMixin0OK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*DeleteRuleGroupsMixin0Default)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeleteRules(params *DeleteRulesParams, opts ...ClientOption) (*DeleteRulesOK, error) {
	if params == nil {
		params = NewDeleteRulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "delete-rules",
		Method:             "DELETE",
		PathPattern:        "/ioarules/entities/rules/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteRulesReader{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.(*DeleteRulesOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*DeleteRulesDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) GetPatterns(params *GetPatternsParams, opts ...ClientOption) (*GetPatternsOK, error) {
	if params == nil {
		params = NewGetPatternsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "get-patterns",
		Method:             "GET",
		PathPattern:        "/ioarules/entities/pattern-severities/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetPatternsReader{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.(*GetPatternsOK)
	if ok {
		return success, nil
	}
	unexpectedSuccess := result.(*GetPatternsDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}