func (a *Client) GetCIDGroupByID(params *GetCIDGroupByIDParams, opts ...ClientOption) (*GetCIDGroupByIDOK, *GetCIDGroupByIDMultiStatus, error) {
	if params == nil {
		params = NewGetCIDGroupByIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCIDGroupById",
		Method:             "GET",
		PathPattern:        "/mssp/entities/cid-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCIDGroupByIDReader{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, nil, err
	}
	switch value := result.(type) {
	case *GetCIDGroupByIDOK:
		return value, nil, nil
	case *GetCIDGroupByIDMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*GetCIDGroupByIDDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
GetCIDGroupByID gets c ID groups by ID
package mssp
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 {
	AddCIDGroupMembers(params *AddCIDGroupMembersParams, opts ...ClientOption) (*AddCIDGroupMembersOK, *AddCIDGroupMembersMultiStatus, error)
	AddRole(params *AddRoleParams, opts ...ClientOption) (*AddRoleOK, *AddRoleMultiStatus, error)
	AddUserGroupMembers(params *AddUserGroupMembersParams, opts ...ClientOption) (*AddUserGroupMembersOK, *AddUserGroupMembersMultiStatus, error)
	CreateCIDGroups(params *CreateCIDGroupsParams, opts ...ClientOption) (*CreateCIDGroupsOK, *CreateCIDGroupsMultiStatus, error)
	CreateUserGroups(params *CreateUserGroupsParams, opts ...ClientOption) (*CreateUserGroupsOK, *CreateUserGroupsMultiStatus, error)
	DeleteCIDGroupMembers(params *DeleteCIDGroupMembersParams, opts ...ClientOption) (*DeleteCIDGroupMembersOK, *DeleteCIDGroupMembersMultiStatus, error)
	DeleteCIDGroups(params *DeleteCIDGroupsParams, opts ...ClientOption) (*DeleteCIDGroupsOK, *DeleteCIDGroupsMultiStatus, error)
	DeleteUserGroupMembers(params *DeleteUserGroupMembersParams, opts ...ClientOption) (*DeleteUserGroupMembersOK, *DeleteUserGroupMembersMultiStatus, error)
	DeleteUserGroups(params *DeleteUserGroupsParams, opts ...ClientOption) (*DeleteUserGroupsOK, *DeleteUserGroupsMultiStatus, error)
	DeletedRoles(params *DeletedRolesParams, opts ...ClientOption) (*DeletedRolesOK, *DeletedRolesMultiStatus, error)
	GetCIDGroupByID(params *GetCIDGroupByIDParams, opts ...ClientOption) (*GetCIDGroupByIDOK, *GetCIDGroupByIDMultiStatus, error)
	GetCIDGroupMembersBy(params *GetCIDGroupMembersByParams, opts ...ClientOption) (*GetCIDGroupMembersByOK, *GetCIDGroupMembersByMultiStatus, error)
	GetChildren(params *GetChildrenParams, opts ...ClientOption) (*GetChildrenOK, *GetChildrenMultiStatus, error)
	GetRolesByID(params *GetRolesByIDParams, opts ...ClientOption) (*GetRolesByIDOK, *GetRolesByIDMultiStatus, error)
	GetUserGroupMembersByID(params *GetUserGroupMembersByIDParams, opts ...ClientOption) (*GetUserGroupMembersByIDOK, *GetUserGroupMembersByIDMultiStatus, error)
	GetUserGroupsByID(params *GetUserGroupsByIDParams, opts ...ClientOption) (*GetUserGroupsByIDOK, *GetUserGroupsByIDMultiStatus, error)
	QueryCIDGroupMembers(params *QueryCIDGroupMembersParams, opts ...ClientOption) (*QueryCIDGroupMembersOK, error)
	QueryCIDGroups(params *QueryCIDGroupsParams, opts ...ClientOption) (*QueryCIDGroupsOK, error)
	QueryChildren(params *QueryChildrenParams, opts ...ClientOption) (*QueryChildrenOK, error)
	QueryRoles(params *QueryRolesParams, opts ...ClientOption) (*QueryRolesOK, error)
	QueryUserGroupMembers(params *QueryUserGroupMembersParams, opts ...ClientOption) (*QueryUserGroupMembersOK, error)
	QueryUserGroups(params *QueryUserGroupsParams, opts ...ClientOption) (*QueryUserGroupsOK, error)
	UpdateCIDGroups(params *UpdateCIDGroupsParams, opts ...ClientOption) (*UpdateCIDGroupsOK, *UpdateCIDGroupsMultiStatus, error)
	UpdateUserGroups(params *UpdateUserGroupsParams, opts ...ClientOption) (*UpdateUserGroupsOK, *UpdateUserGroupsMultiStatus, error)
	SetTransport(transport runtime.ClientTransport)
}
func (a *Client) AddCIDGroupMembers(params *AddCIDGroupMembersParams, opts ...ClientOption) (*AddCIDGroupMembersOK, *AddCIDGroupMembersMultiStatus, error) {
	if params == nil {
		params = NewAddCIDGroupMembersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addCIDGroupMembers",
		Method:             "POST",
		PathPattern:        "/mssp/entities/cid-group-members/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddCIDGroupMembersReader{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, nil, err
	}
	switch value := result.(type) {
	case *AddCIDGroupMembersOK:
		return value, nil, nil
	case *AddCIDGroupMembersMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*AddCIDGroupMembersDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AddRole(params *AddRoleParams, opts ...ClientOption) (*AddRoleOK, *AddRoleMultiStatus, error) {
	if params == nil {
		params = NewAddRoleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addRole",
		Method:             "POST",
		PathPattern:        "/mssp/entities/mssp-roles/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddRoleReader{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, nil, err
	}
	switch value := result.(type) {
	case *AddRoleOK:
		return value, nil, nil
	case *AddRoleMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*AddRoleDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) AddUserGroupMembers(params *AddUserGroupMembersParams, opts ...ClientOption) (*AddUserGroupMembersOK, *AddUserGroupMembersMultiStatus, error) {
	if params == nil {
		params = NewAddUserGroupMembersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addUserGroupMembers",
		Method:             "POST",
		PathPattern:        "/mssp/entities/user-group-members/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddUserGroupMembersReader{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, nil, err
	}
	switch value := result.(type) {
	case *AddUserGroupMembersOK:
		return value, nil, nil
	case *AddUserGroupMembersMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*AddUserGroupMembersDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) CreateCIDGroups(params *CreateCIDGroupsParams, opts ...ClientOption) (*CreateCIDGroupsOK, *CreateCIDGroupsMultiStatus, error) {
	if params == nil {
		params = NewCreateCIDGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createCIDGroups",
		Method:             "POST",
		PathPattern:        "/mssp/entities/cid-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateCIDGroupsReader{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, nil, err
	}
	switch value := result.(type) {
	case *CreateCIDGroupsOK:
		return value, nil, nil
	case *CreateCIDGroupsMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*CreateCIDGroupsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) CreateUserGroups(params *CreateUserGroupsParams, opts ...ClientOption) (*CreateUserGroupsOK, *CreateUserGroupsMultiStatus, error) {
	if params == nil {
		params = NewCreateUserGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createUserGroups",
		Method:             "POST",
		PathPattern:        "/mssp/entities/user-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateUserGroupsReader{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, nil, err
	}
	switch value := result.(type) {
	case *CreateUserGroupsOK:
		return value, nil, nil
	case *CreateUserGroupsMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*CreateUserGroupsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeleteCIDGroupMembers(params *DeleteCIDGroupMembersParams, opts ...ClientOption) (*DeleteCIDGroupMembersOK, *DeleteCIDGroupMembersMultiStatus, error) {
	if params == nil {
		params = NewDeleteCIDGroupMembersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCIDGroupMembers",
		Method:             "DELETE",
		PathPattern:        "/mssp/entities/cid-group-members/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteCIDGroupMembersReader{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, nil, err
	}
	switch value := result.(type) {
	case *DeleteCIDGroupMembersOK:
		return value, nil, nil
	case *DeleteCIDGroupMembersMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*DeleteCIDGroupMembersDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeleteCIDGroups(params *DeleteCIDGroupsParams, opts ...ClientOption) (*DeleteCIDGroupsOK, *DeleteCIDGroupsMultiStatus, error) {
	if params == nil {
		params = NewDeleteCIDGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteCIDGroups",
		Method:             "DELETE",
		PathPattern:        "/mssp/entities/cid-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteCIDGroupsReader{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, nil, err
	}
	switch value := result.(type) {
	case *DeleteCIDGroupsOK:
		return value, nil, nil
	case *DeleteCIDGroupsMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*DeleteCIDGroupsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeleteUserGroupMembers(params *DeleteUserGroupMembersParams, opts ...ClientOption) (*DeleteUserGroupMembersOK, *DeleteUserGroupMembersMultiStatus, error) {
	if params == nil {
		params = NewDeleteUserGroupMembersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteUserGroupMembers",
		Method:             "DELETE",
		PathPattern:        "/mssp/entities/user-group-members/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteUserGroupMembersReader{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, nil, err
	}
	switch value := result.(type) {
	case *DeleteUserGroupMembersOK:
		return value, nil, nil
	case *DeleteUserGroupMembersMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*DeleteUserGroupMembersDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeleteUserGroups(params *DeleteUserGroupsParams, opts ...ClientOption) (*DeleteUserGroupsOK, *DeleteUserGroupsMultiStatus, error) {
	if params == nil {
		params = NewDeleteUserGroupsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteUserGroups",
		Method:             "DELETE",
		PathPattern:        "/mssp/entities/user-groups/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteUserGroupsReader{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, nil, err
	}
	switch value := result.(type) {
	case *DeleteUserGroupsOK:
		return value, nil, nil
	case *DeleteUserGroupsMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*DeleteUserGroupsDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
func (a *Client) DeletedRoles(params *DeletedRolesParams, opts ...ClientOption) (*DeletedRolesOK, *DeletedRolesMultiStatus, error) {
	if params == nil {
		params = NewDeletedRolesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deletedRoles",
		Method:             "DELETE",
		PathPattern:        "/mssp/entities/mssp-roles/v1",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeletedRolesReader{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, nil, err
	}
	switch value := result.(type) {
	case *DeletedRolesOK:
		return value, nil, nil
	case *DeletedRolesMultiStatus:
		return nil, value, nil
	}
	unexpectedSuccess := result.(*DeletedRolesDefault)
	return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}