switch_operations_client.go

// Code generated by go-swagger; DO NOT EDIT.

package switch_operations

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new switch operations API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for switch operations API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	AddNetworkSwitchStack(params *AddNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddNetworkSwitchStackOK, error)

	CloneOrganizationSwitchDevices(params *CloneOrganizationSwitchDevicesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CloneOrganizationSwitchDevicesOK, error)

	CreateDeviceSwitchRoutingInterface(params *CreateDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDeviceSwitchRoutingInterfaceCreated, error)

	CreateDeviceSwitchRoutingStaticRoute(params *CreateDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDeviceSwitchRoutingStaticRouteCreated, error)

	CreateNetworkSwitchAccessPolicy(params *CreateNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchAccessPolicyCreated, error)

	CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerCreated, error)

	CreateNetworkSwitchLinkAggregation(params *CreateNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchLinkAggregationCreated, error)

	CreateNetworkSwitchPortSchedule(params *CreateNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchPortScheduleCreated, error)

	CreateNetworkSwitchQosRule(params *CreateNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchQosRuleCreated, error)

	CreateNetworkSwitchRoutingMulticastRendezvousPoint(params *CreateNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchRoutingMulticastRendezvousPointCreated, error)

	CreateNetworkSwitchStack(params *CreateNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackCreated, error)

	CreateNetworkSwitchStackRoutingInterface(params *CreateNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackRoutingInterfaceCreated, error)

	CreateNetworkSwitchStackRoutingStaticRoute(params *CreateNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackRoutingStaticRouteCreated, error)

	CycleDeviceSwitchPorts(params *CycleDeviceSwitchPortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CycleDeviceSwitchPortsOK, error)

	DeleteDeviceSwitchRoutingInterface(params *DeleteDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDeviceSwitchRoutingInterfaceNoContent, error)

	DeleteDeviceSwitchRoutingStaticRoute(params *DeleteDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDeviceSwitchRoutingStaticRouteNoContent, error)

	DeleteNetworkSwitchAccessPolicy(params *DeleteNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchAccessPolicyNoContent, error)

	DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerNoContent, error)

	DeleteNetworkSwitchLinkAggregation(params *DeleteNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchLinkAggregationNoContent, error)

	DeleteNetworkSwitchPortSchedule(params *DeleteNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchPortScheduleNoContent, error)

	DeleteNetworkSwitchQosRule(params *DeleteNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchQosRuleNoContent, error)

	DeleteNetworkSwitchRoutingMulticastRendezvousPoint(params *DeleteNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchRoutingMulticastRendezvousPointNoContent, error)

	DeleteNetworkSwitchStack(params *DeleteNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackNoContent, error)

	DeleteNetworkSwitchStackRoutingInterface(params *DeleteNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackRoutingInterfaceNoContent, error)

	DeleteNetworkSwitchStackRoutingStaticRoute(params *DeleteNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackRoutingStaticRouteNoContent, error)

	GetDeviceSwitchPort(params *GetDeviceSwitchPortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortOK, error)

	GetDeviceSwitchPorts(params *GetDeviceSwitchPortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsOK, error)

	GetDeviceSwitchPortsStatuses(params *GetDeviceSwitchPortsStatusesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsStatusesOK, error)

	GetDeviceSwitchPortsStatusesPackets(params *GetDeviceSwitchPortsStatusesPacketsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsStatusesPacketsOK, error)

	GetDeviceSwitchRoutingInterface(params *GetDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfaceOK, error)

	GetDeviceSwitchRoutingInterfaceDhcp(params *GetDeviceSwitchRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfaceDhcpOK, error)

	GetDeviceSwitchRoutingInterfaces(params *GetDeviceSwitchRoutingInterfacesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfacesOK, error)

	GetDeviceSwitchRoutingStaticRoute(params *GetDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingStaticRouteOK, error)

	GetDeviceSwitchRoutingStaticRoutes(params *GetDeviceSwitchRoutingStaticRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingStaticRoutesOK, error)

	GetDeviceSwitchWarmSpare(params *GetDeviceSwitchWarmSpareParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchWarmSpareOK, error)

	GetNetworkSwitchAccessControlLists(params *GetNetworkSwitchAccessControlListsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessControlListsOK, error)

	GetNetworkSwitchAccessPolicies(params *GetNetworkSwitchAccessPoliciesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessPoliciesOK, error)

	GetNetworkSwitchAccessPolicy(params *GetNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessPolicyOK, error)

	GetNetworkSwitchAlternateManagementInterface(params *GetNetworkSwitchAlternateManagementInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAlternateManagementInterfaceOK, error)

	GetNetworkSwitchDhcpServerPolicy(params *GetNetworkSwitchDhcpServerPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyOK, error)

	GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServers(params *GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersOK, error)

	GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDevice(params *GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceOK, error)

	GetNetworkSwitchDhcpV4ServersSeen(params *GetNetworkSwitchDhcpV4ServersSeenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpV4ServersSeenOK, error)

	GetNetworkSwitchDscpToCosMappings(params *GetNetworkSwitchDscpToCosMappingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDscpToCosMappingsOK, error)

	GetNetworkSwitchLinkAggregations(params *GetNetworkSwitchLinkAggregationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchLinkAggregationsOK, error)

	GetNetworkSwitchMtu(params *GetNetworkSwitchMtuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchMtuOK, error)

	GetNetworkSwitchPortSchedules(params *GetNetworkSwitchPortSchedulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchPortSchedulesOK, error)

	GetNetworkSwitchQosRule(params *GetNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRuleOK, error)

	GetNetworkSwitchQosRules(params *GetNetworkSwitchQosRulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRulesOK, error)

	GetNetworkSwitchQosRulesOrder(params *GetNetworkSwitchQosRulesOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRulesOrderOK, error)

	GetNetworkSwitchRoutingMulticast(params *GetNetworkSwitchRoutingMulticastParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastOK, error)

	GetNetworkSwitchRoutingMulticastRendezvousPoint(params *GetNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastRendezvousPointOK, error)

	GetNetworkSwitchRoutingMulticastRendezvousPoints(params *GetNetworkSwitchRoutingMulticastRendezvousPointsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastRendezvousPointsOK, error)

	GetNetworkSwitchRoutingOspf(params *GetNetworkSwitchRoutingOspfParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingOspfOK, error)

	GetNetworkSwitchSettings(params *GetNetworkSwitchSettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchSettingsOK, error)

	GetNetworkSwitchStack(params *GetNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackOK, error)

	GetNetworkSwitchStackRoutingInterface(params *GetNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfaceOK, error)

	GetNetworkSwitchStackRoutingInterfaceDhcp(params *GetNetworkSwitchStackRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfaceDhcpOK, error)

	GetNetworkSwitchStackRoutingInterfaces(params *GetNetworkSwitchStackRoutingInterfacesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfacesOK, error)

	GetNetworkSwitchStackRoutingStaticRoute(params *GetNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingStaticRouteOK, error)

	GetNetworkSwitchStackRoutingStaticRoutes(params *GetNetworkSwitchStackRoutingStaticRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingStaticRoutesOK, error)

	GetNetworkSwitchStacks(params *GetNetworkSwitchStacksParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStacksOK, error)

	GetNetworkSwitchStormControl(params *GetNetworkSwitchStormControlParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStormControlOK, error)

	GetNetworkSwitchStp(params *GetNetworkSwitchStpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStpOK, error)

	GetOrganizationConfigTemplateSwitchProfilePort(params *GetOrganizationConfigTemplateSwitchProfilePortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilePortOK, error)

	GetOrganizationConfigTemplateSwitchProfilePorts(params *GetOrganizationConfigTemplateSwitchProfilePortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilePortsOK, error)

	GetOrganizationConfigTemplateSwitchProfiles(params *GetOrganizationConfigTemplateSwitchProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilesOK, error)

	GetOrganizationSwitchPortsBySwitch(params *GetOrganizationSwitchPortsBySwitchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationSwitchPortsBySwitchOK, error)

	RemoveNetworkSwitchStack(params *RemoveNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RemoveNetworkSwitchStackOK, error)

	UpdateDeviceSwitchPort(params *UpdateDeviceSwitchPortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchPortOK, error)

	UpdateDeviceSwitchRoutingInterface(params *UpdateDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingInterfaceOK, error)

	UpdateDeviceSwitchRoutingInterfaceDhcp(params *UpdateDeviceSwitchRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingInterfaceDhcpOK, error)

	UpdateDeviceSwitchRoutingStaticRoute(params *UpdateDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingStaticRouteOK, error)

	UpdateDeviceSwitchWarmSpare(params *UpdateDeviceSwitchWarmSpareParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchWarmSpareOK, error)

	UpdateNetworkSwitchAccessControlLists(params *UpdateNetworkSwitchAccessControlListsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAccessControlListsOK, error)

	UpdateNetworkSwitchAccessPolicy(params *UpdateNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAccessPolicyOK, error)

	UpdateNetworkSwitchAlternateManagementInterface(params *UpdateNetworkSwitchAlternateManagementInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAlternateManagementInterfaceOK, error)

	UpdateNetworkSwitchDhcpServerPolicy(params *UpdateNetworkSwitchDhcpServerPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDhcpServerPolicyOK, error)

	UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerOK, error)

	UpdateNetworkSwitchDscpToCosMappings(params *UpdateNetworkSwitchDscpToCosMappingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDscpToCosMappingsOK, error)

	UpdateNetworkSwitchLinkAggregation(params *UpdateNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchLinkAggregationOK, error)

	UpdateNetworkSwitchMtu(params *UpdateNetworkSwitchMtuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchMtuOK, error)

	UpdateNetworkSwitchPortSchedule(params *UpdateNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchPortScheduleOK, error)

	UpdateNetworkSwitchQosRule(params *UpdateNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchQosRuleOK, error)

	UpdateNetworkSwitchQosRulesOrder(params *UpdateNetworkSwitchQosRulesOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchQosRulesOrderOK, error)

	UpdateNetworkSwitchRoutingMulticast(params *UpdateNetworkSwitchRoutingMulticastParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingMulticastOK, error)

	UpdateNetworkSwitchRoutingMulticastRendezvousPoint(params *UpdateNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingMulticastRendezvousPointOK, error)

	UpdateNetworkSwitchRoutingOspf(params *UpdateNetworkSwitchRoutingOspfParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingOspfOK, error)

	UpdateNetworkSwitchSettings(params *UpdateNetworkSwitchSettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchSettingsOK, error)

	UpdateNetworkSwitchStackRoutingInterface(params *UpdateNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingInterfaceOK, error)

	UpdateNetworkSwitchStackRoutingInterfaceDhcp(params *UpdateNetworkSwitchStackRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingInterfaceDhcpOK, error)

	UpdateNetworkSwitchStackRoutingStaticRoute(params *UpdateNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingStaticRouteOK, error)

	UpdateNetworkSwitchStormControl(params *UpdateNetworkSwitchStormControlParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStormControlOK, error)

	UpdateNetworkSwitchStp(params *UpdateNetworkSwitchStpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStpOK, error)

	UpdateOrganizationConfigTemplateSwitchProfilePort(params *UpdateOrganizationConfigTemplateSwitchProfilePortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateOrganizationConfigTemplateSwitchProfilePortOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
AddNetworkSwitchStack adds a switch to a stack

Add a switch to a stack
*/
func (a *Client) AddNetworkSwitchStack(params *AddNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AddNetworkSwitchStackOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddNetworkSwitchStackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "addNetworkSwitchStack",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/add",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddNetworkSwitchStackReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*AddNetworkSwitchStackOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for addNetworkSwitchStack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CloneOrganizationSwitchDevices clones port level and some switch level configuration settings from a source switch to one or more target switches

Clone port-level and some switch-level configuration settings from a source switch to one or more target switches. Cloned settings include: Aggregation Groups, Power Settings, Multicast Settings, MTU Configuration, STP Bridge priority, Port Mirroring
*/
func (a *Client) CloneOrganizationSwitchDevices(params *CloneOrganizationSwitchDevicesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CloneOrganizationSwitchDevicesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCloneOrganizationSwitchDevicesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "cloneOrganizationSwitchDevices",
		Method:             "POST",
		PathPattern:        "/organizations/{organizationId}/switch/devices/clone",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CloneOrganizationSwitchDevicesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CloneOrganizationSwitchDevicesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for cloneOrganizationSwitchDevices: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateDeviceSwitchRoutingInterface creates a layer 3 interface for a switch

Create a layer 3 interface for a switch
*/
func (a *Client) CreateDeviceSwitchRoutingInterface(params *CreateDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDeviceSwitchRoutingInterfaceCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateDeviceSwitchRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createDeviceSwitchRoutingInterface",
		Method:             "POST",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateDeviceSwitchRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateDeviceSwitchRoutingInterfaceCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createDeviceSwitchRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateDeviceSwitchRoutingStaticRoute creates a layer 3 static route for a switch

Create a layer 3 static route for a switch
*/
func (a *Client) CreateDeviceSwitchRoutingStaticRoute(params *CreateDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateDeviceSwitchRoutingStaticRouteCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateDeviceSwitchRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createDeviceSwitchRoutingStaticRoute",
		Method:             "POST",
		PathPattern:        "/devices/{serial}/switch/routing/staticRoutes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateDeviceSwitchRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateDeviceSwitchRoutingStaticRouteCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createDeviceSwitchRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchAccessPolicy creates an access policy for a switch network

Create an access policy for a switch network. If you would like to enable Meraki Authentication, set radiusServers to empty array.
*/
func (a *Client) CreateNetworkSwitchAccessPolicy(params *CreateNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchAccessPolicyCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchAccessPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchAccessPolicy",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/accessPolicies",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchAccessPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchAccessPolicyCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchAccessPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer adds a server to be trusted by dynamic a r p inspection on this network

Add a server to be trusted by Dynamic ARP Inspection on this network
*/
func (a *Client) CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy/arpInspection/trustedServers",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchLinkAggregation creates a link aggregation group

Create a link aggregation group
*/
func (a *Client) CreateNetworkSwitchLinkAggregation(params *CreateNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchLinkAggregationCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchLinkAggregationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchLinkAggregation",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/linkAggregations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchLinkAggregationReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchLinkAggregationCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchLinkAggregation: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchPortSchedule adds a switch port schedule

Add a switch port schedule
*/
func (a *Client) CreateNetworkSwitchPortSchedule(params *CreateNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchPortScheduleCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchPortScheduleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchPortSchedule",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/portSchedules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchPortScheduleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchPortScheduleCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchPortSchedule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchQosRule adds a quality of service rule

Add a quality of service rule
*/
func (a *Client) CreateNetworkSwitchQosRule(params *CreateNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchQosRuleCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchQosRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchQosRule",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/qosRules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchQosRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchQosRuleCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchQosRule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchRoutingMulticastRendezvousPoint creates a multicast rendezvous point

Create a multicast rendezvous point
*/
func (a *Client) CreateNetworkSwitchRoutingMulticastRendezvousPoint(params *CreateNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchRoutingMulticastRendezvousPointCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchRoutingMulticastRendezvousPointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchRoutingMulticastRendezvousPoint",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast/rendezvousPoints",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchRoutingMulticastRendezvousPointReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchRoutingMulticastRendezvousPointCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchRoutingMulticastRendezvousPoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchStack creates a stack

Create a stack
*/
func (a *Client) CreateNetworkSwitchStack(params *CreateNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchStackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchStack",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/stacks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchStackReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchStackCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchStack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchStackRoutingInterface creates a layer 3 interface for a switch stack

Create a layer 3 interface for a switch stack
*/
func (a *Client) CreateNetworkSwitchStackRoutingInterface(params *CreateNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackRoutingInterfaceCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchStackRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchStackRoutingInterface",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchStackRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchStackRoutingInterfaceCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchStackRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CreateNetworkSwitchStackRoutingStaticRoute creates a layer 3 static route for a switch stack

Create a layer 3 static route for a switch stack
*/
func (a *Client) CreateNetworkSwitchStackRoutingStaticRoute(params *CreateNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateNetworkSwitchStackRoutingStaticRouteCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateNetworkSwitchStackRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createNetworkSwitchStackRoutingStaticRoute",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/staticRoutes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CreateNetworkSwitchStackRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CreateNetworkSwitchStackRoutingStaticRouteCreated)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for createNetworkSwitchStackRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
CycleDeviceSwitchPorts cycles a set of switch ports

Cycle a set of switch ports
*/
func (a *Client) CycleDeviceSwitchPorts(params *CycleDeviceSwitchPortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CycleDeviceSwitchPortsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCycleDeviceSwitchPortsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "cycleDeviceSwitchPorts",
		Method:             "POST",
		PathPattern:        "/devices/{serial}/switch/ports/cycle",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CycleDeviceSwitchPortsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*CycleDeviceSwitchPortsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for cycleDeviceSwitchPorts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteDeviceSwitchRoutingInterface deletes a layer 3 interface from the switch

Delete a layer 3 interface from the switch
*/
func (a *Client) DeleteDeviceSwitchRoutingInterface(params *DeleteDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDeviceSwitchRoutingInterfaceNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceSwitchRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteDeviceSwitchRoutingInterface",
		Method:             "DELETE",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceSwitchRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteDeviceSwitchRoutingInterfaceNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteDeviceSwitchRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteDeviceSwitchRoutingStaticRoute deletes a layer 3 static route for a switch

Delete a layer 3 static route for a switch
*/
func (a *Client) DeleteDeviceSwitchRoutingStaticRoute(params *DeleteDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteDeviceSwitchRoutingStaticRouteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceSwitchRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteDeviceSwitchRoutingStaticRoute",
		Method:             "DELETE",
		PathPattern:        "/devices/{serial}/switch/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceSwitchRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteDeviceSwitchRoutingStaticRouteNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteDeviceSwitchRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchAccessPolicy deletes an access policy for a switch network

Delete an access policy for a switch network
*/
func (a *Client) DeleteNetworkSwitchAccessPolicy(params *DeleteNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchAccessPolicyNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchAccessPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchAccessPolicy",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/accessPolicies/{accessPolicyNumber}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchAccessPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchAccessPolicyNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchAccessPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer removes a server from being trusted by dynamic a r p inspection on this network

Remove a server from being trusted by Dynamic ARP Inspection on this network
*/
func (a *Client) DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy/arpInspection/trustedServers/{trustedServerId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchLinkAggregation splits a link aggregation group into separate ports

Split a link aggregation group into separate ports
*/
func (a *Client) DeleteNetworkSwitchLinkAggregation(params *DeleteNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchLinkAggregationNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchLinkAggregationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchLinkAggregation",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/linkAggregations/{linkAggregationId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchLinkAggregationReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchLinkAggregationNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchLinkAggregation: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchPortSchedule deletes a switch port schedule

Delete a switch port schedule
*/
func (a *Client) DeleteNetworkSwitchPortSchedule(params *DeleteNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchPortScheduleNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchPortScheduleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchPortSchedule",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/portSchedules/{portScheduleId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchPortScheduleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchPortScheduleNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchPortSchedule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchQosRule deletes a quality of service rule

Delete a quality of service rule
*/
func (a *Client) DeleteNetworkSwitchQosRule(params *DeleteNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchQosRuleNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchQosRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchQosRule",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/qosRules/{qosRuleId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchQosRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchQosRuleNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchQosRule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchRoutingMulticastRendezvousPoint deletes a multicast rendezvous point

Delete a multicast rendezvous point
*/
func (a *Client) DeleteNetworkSwitchRoutingMulticastRendezvousPoint(params *DeleteNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchRoutingMulticastRendezvousPointNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchRoutingMulticastRendezvousPointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchRoutingMulticastRendezvousPoint",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast/rendezvousPoints/{rendezvousPointId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchRoutingMulticastRendezvousPointReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchRoutingMulticastRendezvousPointNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchRoutingMulticastRendezvousPoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchStack deletes a stack

Delete a stack
*/
func (a *Client) DeleteNetworkSwitchStack(params *DeleteNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchStackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchStack",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchStackReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchStackNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchStack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchStackRoutingInterface deletes a layer 3 interface from a switch stack

Delete a layer 3 interface from a switch stack
*/
func (a *Client) DeleteNetworkSwitchStackRoutingInterface(params *DeleteNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackRoutingInterfaceNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchStackRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchStackRoutingInterface",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchStackRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchStackRoutingInterfaceNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchStackRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
DeleteNetworkSwitchStackRoutingStaticRoute deletes a layer 3 static route for a switch stack

Delete a layer 3 static route for a switch stack
*/
func (a *Client) DeleteNetworkSwitchStackRoutingStaticRoute(params *DeleteNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteNetworkSwitchStackRoutingStaticRouteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetworkSwitchStackRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteNetworkSwitchStackRoutingStaticRoute",
		Method:             "DELETE",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetworkSwitchStackRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*DeleteNetworkSwitchStackRoutingStaticRouteNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteNetworkSwitchStackRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchPort returns a switch port

Return a switch port
*/
func (a *Client) GetDeviceSwitchPort(params *GetDeviceSwitchPortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchPortParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchPort",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/ports/{portId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchPortReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchPortOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchPort: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchPorts lists the switch ports for a switch

List the switch ports for a switch
*/
func (a *Client) GetDeviceSwitchPorts(params *GetDeviceSwitchPortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchPortsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchPorts",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/ports",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchPortsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchPortsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchPorts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchPortsStatuses returns the status for all the ports of a switch

Return the status for all the ports of a switch
*/
func (a *Client) GetDeviceSwitchPortsStatuses(params *GetDeviceSwitchPortsStatusesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsStatusesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchPortsStatusesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchPortsStatuses",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/ports/statuses",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchPortsStatusesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchPortsStatusesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchPortsStatuses: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchPortsStatusesPackets returns the packet counters for all the ports of a switch

Return the packet counters for all the ports of a switch
*/
func (a *Client) GetDeviceSwitchPortsStatusesPackets(params *GetDeviceSwitchPortsStatusesPacketsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchPortsStatusesPacketsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchPortsStatusesPacketsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchPortsStatusesPackets",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/ports/statuses/packets",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchPortsStatusesPacketsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchPortsStatusesPacketsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchPortsStatusesPackets: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchRoutingInterface returns a layer 3 interface for a switch

Return a layer 3 interface for a switch
*/
func (a *Client) GetDeviceSwitchRoutingInterface(params *GetDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchRoutingInterface",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchRoutingInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchRoutingInterfaceDhcp returns a layer 3 interface d h c p configuration for a switch

Return a layer 3 interface DHCP configuration for a switch
*/
func (a *Client) GetDeviceSwitchRoutingInterfaceDhcp(params *GetDeviceSwitchRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfaceDhcpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchRoutingInterfaceDhcpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchRoutingInterfaceDhcp",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces/{interfaceId}/dhcp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchRoutingInterfaceDhcpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchRoutingInterfaceDhcpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchRoutingInterfaceDhcp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchRoutingInterfaces lists layer 3 interfaces for a switch

List layer 3 interfaces for a switch. Those for a stack may be found under switch stack routing.
*/
func (a *Client) GetDeviceSwitchRoutingInterfaces(params *GetDeviceSwitchRoutingInterfacesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingInterfacesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchRoutingInterfacesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchRoutingInterfaces",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchRoutingInterfacesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchRoutingInterfacesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchRoutingInterfaces: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchRoutingStaticRoute returns a layer 3 static route for a switch

Return a layer 3 static route for a switch
*/
func (a *Client) GetDeviceSwitchRoutingStaticRoute(params *GetDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingStaticRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchRoutingStaticRoute",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchRoutingStaticRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchRoutingStaticRoutes lists layer 3 static routes for a switch

List layer 3 static routes for a switch
*/
func (a *Client) GetDeviceSwitchRoutingStaticRoutes(params *GetDeviceSwitchRoutingStaticRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchRoutingStaticRoutesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchRoutingStaticRoutesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchRoutingStaticRoutes",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/routing/staticRoutes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchRoutingStaticRoutesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchRoutingStaticRoutesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchRoutingStaticRoutes: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetDeviceSwitchWarmSpare returns warm spare configuration for a switch

Return warm spare configuration for a switch
*/
func (a *Client) GetDeviceSwitchWarmSpare(params *GetDeviceSwitchWarmSpareParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetDeviceSwitchWarmSpareOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceSwitchWarmSpareParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDeviceSwitchWarmSpare",
		Method:             "GET",
		PathPattern:        "/devices/{serial}/switch/warmSpare",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceSwitchWarmSpareReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetDeviceSwitchWarmSpareOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDeviceSwitchWarmSpare: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchAccessControlLists returns the access control lists for a m s network

Return the access control lists for a MS network
*/
func (a *Client) GetNetworkSwitchAccessControlLists(params *GetNetworkSwitchAccessControlListsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessControlListsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchAccessControlListsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchAccessControlLists",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/accessControlLists",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchAccessControlListsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchAccessControlListsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchAccessControlLists: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchAccessPolicies lists the access policies for a switch network

List the access policies for a switch network. Only returns access policies with 'my RADIUS server' as authentication method
*/
func (a *Client) GetNetworkSwitchAccessPolicies(params *GetNetworkSwitchAccessPoliciesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessPoliciesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchAccessPoliciesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchAccessPolicies",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/accessPolicies",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchAccessPoliciesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchAccessPoliciesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchAccessPolicies: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchAccessPolicy returns a specific access policy for a switch network

Return a specific access policy for a switch network
*/
func (a *Client) GetNetworkSwitchAccessPolicy(params *GetNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAccessPolicyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchAccessPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchAccessPolicy",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/accessPolicies/{accessPolicyNumber}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchAccessPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchAccessPolicyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchAccessPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchAlternateManagementInterface returns the switch alternate management interface for the network

Return the switch alternate management interface for the network
*/
func (a *Client) GetNetworkSwitchAlternateManagementInterface(params *GetNetworkSwitchAlternateManagementInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchAlternateManagementInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchAlternateManagementInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchAlternateManagementInterface",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/alternateManagementInterface",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchAlternateManagementInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchAlternateManagementInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchAlternateManagementInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchDhcpServerPolicy returns the d h c p server settings

Return the DHCP server settings. Blocked/allowed servers are only applied when default policy is allow/block, respectively
*/
func (a *Client) GetNetworkSwitchDhcpServerPolicy(params *GetNetworkSwitchDhcpServerPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchDhcpServerPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchDhcpServerPolicy",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchDhcpServerPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchDhcpServerPolicyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchDhcpServerPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServers returns the list of servers trusted by dynamic a r p inspection on this network

Return the list of servers trusted by Dynamic ARP Inspection on this network. These are also known as allow listed snoop entries
*/
func (a *Client) GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServers(params *GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchDhcpServerPolicyArpInspectionTrustedServers",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy/arpInspection/trustedServers",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchDhcpServerPolicyArpInspectionTrustedServersOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchDhcpServerPolicyArpInspectionTrustedServers: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDevice returns the devices that have a dynamic a r p inspection warning and their warnings

Return the devices that have a Dynamic ARP Inspection warning and their warnings
*/
func (a *Client) GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDevice(params *GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDevice",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy/arpInspection/warnings/byDevice",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDeviceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchDhcpServerPolicyArpInspectionWarningsByDevice: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchDhcpV4ServersSeen returns the network s d h c pv4 servers seen within the selected timeframe default 1 day

Return the network's DHCPv4 servers seen within the selected timeframe (default 1 day)
*/
func (a *Client) GetNetworkSwitchDhcpV4ServersSeen(params *GetNetworkSwitchDhcpV4ServersSeenParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDhcpV4ServersSeenOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchDhcpV4ServersSeenParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchDhcpV4ServersSeen",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/dhcp/v4/servers/seen",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchDhcpV4ServersSeenReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchDhcpV4ServersSeenOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchDhcpV4ServersSeen: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchDscpToCosMappings returns the d s c p to co s mappings

Return the DSCP to CoS mappings
*/
func (a *Client) GetNetworkSwitchDscpToCosMappings(params *GetNetworkSwitchDscpToCosMappingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchDscpToCosMappingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchDscpToCosMappingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchDscpToCosMappings",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/dscpToCosMappings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchDscpToCosMappingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchDscpToCosMappingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchDscpToCosMappings: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchLinkAggregations lists link aggregation groups

List link aggregation groups
*/
func (a *Client) GetNetworkSwitchLinkAggregations(params *GetNetworkSwitchLinkAggregationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchLinkAggregationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchLinkAggregationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchLinkAggregations",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/linkAggregations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchLinkAggregationsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchLinkAggregationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchLinkAggregations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchMtu returns the m t u configuration

Return the MTU configuration
*/
func (a *Client) GetNetworkSwitchMtu(params *GetNetworkSwitchMtuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchMtuOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchMtuParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchMtu",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/mtu",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchMtuReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchMtuOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchMtu: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchPortSchedules lists switch port schedules

List switch port schedules
*/
func (a *Client) GetNetworkSwitchPortSchedules(params *GetNetworkSwitchPortSchedulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchPortSchedulesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchPortSchedulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchPortSchedules",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/portSchedules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchPortSchedulesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchPortSchedulesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchPortSchedules: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchQosRule returns a quality of service rule

Return a quality of service rule
*/
func (a *Client) GetNetworkSwitchQosRule(params *GetNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchQosRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchQosRule",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/qosRules/{qosRuleId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchQosRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchQosRuleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchQosRule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchQosRules lists quality of service rules

List quality of service rules
*/
func (a *Client) GetNetworkSwitchQosRules(params *GetNetworkSwitchQosRulesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRulesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchQosRulesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchQosRules",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/qosRules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchQosRulesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchQosRulesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchQosRules: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchQosRulesOrder returns the quality of service rule i ds by order in which they will be processed by the switch

Return the quality of service rule IDs by order in which they will be processed by the switch
*/
func (a *Client) GetNetworkSwitchQosRulesOrder(params *GetNetworkSwitchQosRulesOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchQosRulesOrderOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchQosRulesOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchQosRulesOrder",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/qosRules/order",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchQosRulesOrderReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchQosRulesOrderOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchQosRulesOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchRoutingMulticast returns multicast settings for a network

Return multicast settings for a network
*/
func (a *Client) GetNetworkSwitchRoutingMulticast(params *GetNetworkSwitchRoutingMulticastParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchRoutingMulticastParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchRoutingMulticast",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchRoutingMulticastReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchRoutingMulticastOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchRoutingMulticast: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchRoutingMulticastRendezvousPoint returns a multicast rendezvous point

Return a multicast rendezvous point
*/
func (a *Client) GetNetworkSwitchRoutingMulticastRendezvousPoint(params *GetNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastRendezvousPointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchRoutingMulticastRendezvousPointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchRoutingMulticastRendezvousPoint",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast/rendezvousPoints/{rendezvousPointId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchRoutingMulticastRendezvousPointReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchRoutingMulticastRendezvousPointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchRoutingMulticastRendezvousPoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchRoutingMulticastRendezvousPoints lists multicast rendezvous points

List multicast rendezvous points
*/
func (a *Client) GetNetworkSwitchRoutingMulticastRendezvousPoints(params *GetNetworkSwitchRoutingMulticastRendezvousPointsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingMulticastRendezvousPointsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchRoutingMulticastRendezvousPointsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchRoutingMulticastRendezvousPoints",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast/rendezvousPoints",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchRoutingMulticastRendezvousPointsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchRoutingMulticastRendezvousPointsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchRoutingMulticastRendezvousPoints: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchRoutingOspf returns layer 3 o s p f routing configuration

Return layer 3 OSPF routing configuration
*/
func (a *Client) GetNetworkSwitchRoutingOspf(params *GetNetworkSwitchRoutingOspfParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchRoutingOspfOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchRoutingOspfParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchRoutingOspf",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/routing/ospf",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchRoutingOspfReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchRoutingOspfOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchRoutingOspf: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchSettings returns the switch network settings

Returns the switch network settings
*/
func (a *Client) GetNetworkSwitchSettings(params *GetNetworkSwitchSettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchSettingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchSettingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchSettings",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/settings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchSettingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchSettingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchSettings: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStack shows a switch stack

Show a switch stack
*/
func (a *Client) GetNetworkSwitchStack(params *GetNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStack",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStackRoutingInterface returns a layer 3 interface from a switch stack

Return a layer 3 interface from a switch stack
*/
func (a *Client) GetNetworkSwitchStackRoutingInterface(params *GetNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStackRoutingInterface",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackRoutingInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStackRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStackRoutingInterfaceDhcp returns a layer 3 interface d h c p configuration for a switch stack

Return a layer 3 interface DHCP configuration for a switch stack
*/
func (a *Client) GetNetworkSwitchStackRoutingInterfaceDhcp(params *GetNetworkSwitchStackRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfaceDhcpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackRoutingInterfaceDhcpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStackRoutingInterfaceDhcp",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces/{interfaceId}/dhcp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackRoutingInterfaceDhcpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackRoutingInterfaceDhcpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStackRoutingInterfaceDhcp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStackRoutingInterfaces lists layer 3 interfaces for a switch stack

List layer 3 interfaces for a switch stack
*/
func (a *Client) GetNetworkSwitchStackRoutingInterfaces(params *GetNetworkSwitchStackRoutingInterfacesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingInterfacesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackRoutingInterfacesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStackRoutingInterfaces",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackRoutingInterfacesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackRoutingInterfacesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStackRoutingInterfaces: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStackRoutingStaticRoute returns a layer 3 static route for a switch stack

Return a layer 3 static route for a switch stack
*/
func (a *Client) GetNetworkSwitchStackRoutingStaticRoute(params *GetNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingStaticRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStackRoutingStaticRoute",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackRoutingStaticRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStackRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStackRoutingStaticRoutes lists layer 3 static routes for a switch stack

List layer 3 static routes for a switch stack
*/
func (a *Client) GetNetworkSwitchStackRoutingStaticRoutes(params *GetNetworkSwitchStackRoutingStaticRoutesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStackRoutingStaticRoutesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStackRoutingStaticRoutesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStackRoutingStaticRoutes",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/staticRoutes",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStackRoutingStaticRoutesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStackRoutingStaticRoutesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStackRoutingStaticRoutes: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStacks lists the switch stacks in a network

List the switch stacks in a network
*/
func (a *Client) GetNetworkSwitchStacks(params *GetNetworkSwitchStacksParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStacksOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStacksParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStacks",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stacks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStacksReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStacksOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStacks: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStormControl returns the storm control configuration for a switch network

Return the storm control configuration for a switch network
*/
func (a *Client) GetNetworkSwitchStormControl(params *GetNetworkSwitchStormControlParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStormControlOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStormControlParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStormControl",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stormControl",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStormControlReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStormControlOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStormControl: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetNetworkSwitchStp returns s t p settings

Returns STP settings
*/
func (a *Client) GetNetworkSwitchStp(params *GetNetworkSwitchStpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetNetworkSwitchStpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetworkSwitchStpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getNetworkSwitchStp",
		Method:             "GET",
		PathPattern:        "/networks/{networkId}/switch/stp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetNetworkSwitchStpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetNetworkSwitchStpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getNetworkSwitchStp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetOrganizationConfigTemplateSwitchProfilePort returns a switch template port

Return a switch template port
*/
func (a *Client) GetOrganizationConfigTemplateSwitchProfilePort(params *GetOrganizationConfigTemplateSwitchProfilePortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilePortOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrganizationConfigTemplateSwitchProfilePortParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrganizationConfigTemplateSwitchProfilePort",
		Method:             "GET",
		PathPattern:        "/organizations/{organizationId}/configTemplates/{configTemplateId}/switch/profiles/{profileId}/ports/{portId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetOrganizationConfigTemplateSwitchProfilePortReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetOrganizationConfigTemplateSwitchProfilePortOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrganizationConfigTemplateSwitchProfilePort: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetOrganizationConfigTemplateSwitchProfilePorts returns all the ports of a switch template

Return all the ports of a switch template
*/
func (a *Client) GetOrganizationConfigTemplateSwitchProfilePorts(params *GetOrganizationConfigTemplateSwitchProfilePortsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilePortsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrganizationConfigTemplateSwitchProfilePortsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrganizationConfigTemplateSwitchProfilePorts",
		Method:             "GET",
		PathPattern:        "/organizations/{organizationId}/configTemplates/{configTemplateId}/switch/profiles/{profileId}/ports",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetOrganizationConfigTemplateSwitchProfilePortsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetOrganizationConfigTemplateSwitchProfilePortsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrganizationConfigTemplateSwitchProfilePorts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetOrganizationConfigTemplateSwitchProfiles lists the switch templates for your switch template configuration

List the switch templates for your switch template configuration
*/
func (a *Client) GetOrganizationConfigTemplateSwitchProfiles(params *GetOrganizationConfigTemplateSwitchProfilesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationConfigTemplateSwitchProfilesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrganizationConfigTemplateSwitchProfilesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrganizationConfigTemplateSwitchProfiles",
		Method:             "GET",
		PathPattern:        "/organizations/{organizationId}/configTemplates/{configTemplateId}/switch/profiles",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetOrganizationConfigTemplateSwitchProfilesReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetOrganizationConfigTemplateSwitchProfilesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrganizationConfigTemplateSwitchProfiles: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
GetOrganizationSwitchPortsBySwitch lists the switchports in an organization by switch

List the switchports in an organization by switch
*/
func (a *Client) GetOrganizationSwitchPortsBySwitch(params *GetOrganizationSwitchPortsBySwitchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetOrganizationSwitchPortsBySwitchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOrganizationSwitchPortsBySwitchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getOrganizationSwitchPortsBySwitch",
		Method:             "GET",
		PathPattern:        "/organizations/{organizationId}/switch/ports/bySwitch",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetOrganizationSwitchPortsBySwitchReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*GetOrganizationSwitchPortsBySwitchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getOrganizationSwitchPortsBySwitch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
RemoveNetworkSwitchStack removes a switch from a stack

Remove a switch from a stack
*/
func (a *Client) RemoveNetworkSwitchStack(params *RemoveNetworkSwitchStackParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*RemoveNetworkSwitchStackOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewRemoveNetworkSwitchStackParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "removeNetworkSwitchStack",
		Method:             "POST",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/remove",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &RemoveNetworkSwitchStackReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*RemoveNetworkSwitchStackOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for removeNetworkSwitchStack: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateDeviceSwitchPort updates a switch port

Update a switch port
*/
func (a *Client) UpdateDeviceSwitchPort(params *UpdateDeviceSwitchPortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchPortOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceSwitchPortParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateDeviceSwitchPort",
		Method:             "PUT",
		PathPattern:        "/devices/{serial}/switch/ports/{portId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceSwitchPortReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateDeviceSwitchPortOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateDeviceSwitchPort: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateDeviceSwitchRoutingInterface updates a layer 3 interface for a switch

Update a layer 3 interface for a switch
*/
func (a *Client) UpdateDeviceSwitchRoutingInterface(params *UpdateDeviceSwitchRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceSwitchRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateDeviceSwitchRoutingInterface",
		Method:             "PUT",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceSwitchRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateDeviceSwitchRoutingInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateDeviceSwitchRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateDeviceSwitchRoutingInterfaceDhcp updates a layer 3 interface d h c p configuration for a switch

Update a layer 3 interface DHCP configuration for a switch
*/
func (a *Client) UpdateDeviceSwitchRoutingInterfaceDhcp(params *UpdateDeviceSwitchRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingInterfaceDhcpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceSwitchRoutingInterfaceDhcpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateDeviceSwitchRoutingInterfaceDhcp",
		Method:             "PUT",
		PathPattern:        "/devices/{serial}/switch/routing/interfaces/{interfaceId}/dhcp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceSwitchRoutingInterfaceDhcpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateDeviceSwitchRoutingInterfaceDhcpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateDeviceSwitchRoutingInterfaceDhcp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateDeviceSwitchRoutingStaticRoute updates a layer 3 static route for a switch

Update a layer 3 static route for a switch
*/
func (a *Client) UpdateDeviceSwitchRoutingStaticRoute(params *UpdateDeviceSwitchRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchRoutingStaticRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceSwitchRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateDeviceSwitchRoutingStaticRoute",
		Method:             "PUT",
		PathPattern:        "/devices/{serial}/switch/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceSwitchRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateDeviceSwitchRoutingStaticRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateDeviceSwitchRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateDeviceSwitchWarmSpare updates warm spare configuration for a switch

Update warm spare configuration for a switch. The spare will use the same L3 configuration as the primary. Note that this will irreversibly destroy any existing L3 configuration on the spare.
*/
func (a *Client) UpdateDeviceSwitchWarmSpare(params *UpdateDeviceSwitchWarmSpareParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateDeviceSwitchWarmSpareOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceSwitchWarmSpareParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateDeviceSwitchWarmSpare",
		Method:             "PUT",
		PathPattern:        "/devices/{serial}/switch/warmSpare",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceSwitchWarmSpareReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateDeviceSwitchWarmSpareOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateDeviceSwitchWarmSpare: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchAccessControlLists updates the access control lists for a m s network

Update the access control lists for a MS network
*/
func (a *Client) UpdateNetworkSwitchAccessControlLists(params *UpdateNetworkSwitchAccessControlListsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAccessControlListsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchAccessControlListsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchAccessControlLists",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/accessControlLists",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchAccessControlListsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchAccessControlListsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchAccessControlLists: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchAccessPolicy updates an access policy for a switch network

Update an access policy for a switch network. If you would like to enable Meraki Authentication, set radiusServers to empty array.
*/
func (a *Client) UpdateNetworkSwitchAccessPolicy(params *UpdateNetworkSwitchAccessPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAccessPolicyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchAccessPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchAccessPolicy",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/accessPolicies/{accessPolicyNumber}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchAccessPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchAccessPolicyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchAccessPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchAlternateManagementInterface updates the switch alternate management interface for the network

Update the switch alternate management interface for the network
*/
func (a *Client) UpdateNetworkSwitchAlternateManagementInterface(params *UpdateNetworkSwitchAlternateManagementInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchAlternateManagementInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchAlternateManagementInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchAlternateManagementInterface",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/alternateManagementInterface",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchAlternateManagementInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchAlternateManagementInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchAlternateManagementInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchDhcpServerPolicy updates the d h c p server settings

Update the DHCP server settings. Blocked/allowed servers are only applied when default policy is allow/block, respectively
*/
func (a *Client) UpdateNetworkSwitchDhcpServerPolicy(params *UpdateNetworkSwitchDhcpServerPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDhcpServerPolicyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchDhcpServerPolicyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchDhcpServerPolicy",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchDhcpServerPolicyReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchDhcpServerPolicyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchDhcpServerPolicy: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer updates a server that is trusted by dynamic a r p inspection on this network

Update a server that is trusted by Dynamic ARP Inspection on this network
*/
func (a *Client) UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer(params *UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/dhcpServerPolicy/arpInspection/trustedServers/{trustedServerId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServerOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchDhcpServerPolicyArpInspectionTrustedServer: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchDscpToCosMappings updates the d s c p to co s mappings

Update the DSCP to CoS mappings
*/
func (a *Client) UpdateNetworkSwitchDscpToCosMappings(params *UpdateNetworkSwitchDscpToCosMappingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchDscpToCosMappingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchDscpToCosMappingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchDscpToCosMappings",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/dscpToCosMappings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchDscpToCosMappingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchDscpToCosMappingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchDscpToCosMappings: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchLinkAggregation updates a link aggregation group

Update a link aggregation group
*/
func (a *Client) UpdateNetworkSwitchLinkAggregation(params *UpdateNetworkSwitchLinkAggregationParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchLinkAggregationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchLinkAggregationParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchLinkAggregation",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/linkAggregations/{linkAggregationId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchLinkAggregationReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchLinkAggregationOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchLinkAggregation: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchMtu updates the m t u configuration

Update the MTU configuration
*/
func (a *Client) UpdateNetworkSwitchMtu(params *UpdateNetworkSwitchMtuParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchMtuOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchMtuParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchMtu",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/mtu",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchMtuReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchMtuOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchMtu: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchPortSchedule updates a switch port schedule

Update a switch port schedule
*/
func (a *Client) UpdateNetworkSwitchPortSchedule(params *UpdateNetworkSwitchPortScheduleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchPortScheduleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchPortScheduleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchPortSchedule",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/portSchedules/{portScheduleId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchPortScheduleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchPortScheduleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchPortSchedule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchQosRule updates a quality of service rule

Update a quality of service rule
*/
func (a *Client) UpdateNetworkSwitchQosRule(params *UpdateNetworkSwitchQosRuleParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchQosRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchQosRuleParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchQosRule",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/qosRules/{qosRuleId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchQosRuleReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchQosRuleOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchQosRule: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchQosRulesOrder updates the order in which the rules should be processed by the switch

Update the order in which the rules should be processed by the switch
*/
func (a *Client) UpdateNetworkSwitchQosRulesOrder(params *UpdateNetworkSwitchQosRulesOrderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchQosRulesOrderOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchQosRulesOrderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchQosRulesOrder",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/qosRules/order",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchQosRulesOrderReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchQosRulesOrderOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchQosRulesOrder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchRoutingMulticast updates multicast settings for a network

Update multicast settings for a network
*/
func (a *Client) UpdateNetworkSwitchRoutingMulticast(params *UpdateNetworkSwitchRoutingMulticastParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingMulticastOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchRoutingMulticastParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchRoutingMulticast",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchRoutingMulticastReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchRoutingMulticastOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchRoutingMulticast: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchRoutingMulticastRendezvousPoint updates a multicast rendezvous point

Update a multicast rendezvous point
*/
func (a *Client) UpdateNetworkSwitchRoutingMulticastRendezvousPoint(params *UpdateNetworkSwitchRoutingMulticastRendezvousPointParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingMulticastRendezvousPointOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchRoutingMulticastRendezvousPointParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchRoutingMulticastRendezvousPoint",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/routing/multicast/rendezvousPoints/{rendezvousPointId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchRoutingMulticastRendezvousPointReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchRoutingMulticastRendezvousPointOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchRoutingMulticastRendezvousPoint: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchRoutingOspf updates layer 3 o s p f routing configuration

Update layer 3 OSPF routing configuration
*/
func (a *Client) UpdateNetworkSwitchRoutingOspf(params *UpdateNetworkSwitchRoutingOspfParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchRoutingOspfOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchRoutingOspfParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchRoutingOspf",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/routing/ospf",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchRoutingOspfReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchRoutingOspfOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchRoutingOspf: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchSettings updates switch network settings

Update switch network settings
*/
func (a *Client) UpdateNetworkSwitchSettings(params *UpdateNetworkSwitchSettingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchSettingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchSettingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchSettings",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/settings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchSettingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchSettingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchSettings: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchStackRoutingInterface updates a layer 3 interface for a switch stack

Update a layer 3 interface for a switch stack
*/
func (a *Client) UpdateNetworkSwitchStackRoutingInterface(params *UpdateNetworkSwitchStackRoutingInterfaceParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingInterfaceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchStackRoutingInterfaceParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchStackRoutingInterface",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces/{interfaceId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchStackRoutingInterfaceReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchStackRoutingInterfaceOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchStackRoutingInterface: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchStackRoutingInterfaceDhcp updates a layer 3 interface d h c p configuration for a switch stack

Update a layer 3 interface DHCP configuration for a switch stack
*/
func (a *Client) UpdateNetworkSwitchStackRoutingInterfaceDhcp(params *UpdateNetworkSwitchStackRoutingInterfaceDhcpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingInterfaceDhcpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchStackRoutingInterfaceDhcpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchStackRoutingInterfaceDhcp",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/interfaces/{interfaceId}/dhcp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchStackRoutingInterfaceDhcpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchStackRoutingInterfaceDhcpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchStackRoutingInterfaceDhcp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchStackRoutingStaticRoute updates a layer 3 static route for a switch stack

Update a layer 3 static route for a switch stack
*/
func (a *Client) UpdateNetworkSwitchStackRoutingStaticRoute(params *UpdateNetworkSwitchStackRoutingStaticRouteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStackRoutingStaticRouteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchStackRoutingStaticRouteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchStackRoutingStaticRoute",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/stacks/{switchStackId}/routing/staticRoutes/{staticRouteId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchStackRoutingStaticRouteReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchStackRoutingStaticRouteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchStackRoutingStaticRoute: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchStormControl updates the storm control configuration for a switch network

Update the storm control configuration for a switch network
*/
func (a *Client) UpdateNetworkSwitchStormControl(params *UpdateNetworkSwitchStormControlParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStormControlOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchStormControlParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchStormControl",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/stormControl",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchStormControlReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchStormControlOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchStormControl: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateNetworkSwitchStp updates s t p settings

Updates STP settings
*/
func (a *Client) UpdateNetworkSwitchStp(params *UpdateNetworkSwitchStpParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateNetworkSwitchStpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetworkSwitchStpParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateNetworkSwitchStp",
		Method:             "PUT",
		PathPattern:        "/networks/{networkId}/switch/stp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateNetworkSwitchStpReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateNetworkSwitchStpOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateNetworkSwitchStp: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
UpdateOrganizationConfigTemplateSwitchProfilePort updates a switch template port

Update a switch template port
*/
func (a *Client) UpdateOrganizationConfigTemplateSwitchProfilePort(params *UpdateOrganizationConfigTemplateSwitchProfilePortParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateOrganizationConfigTemplateSwitchProfilePortOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateOrganizationConfigTemplateSwitchProfilePortParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateOrganizationConfigTemplateSwitchProfilePort",
		Method:             "PUT",
		PathPattern:        "/organizations/{organizationId}/configTemplates/{configTemplateId}/switch/profiles/{profileId}/ports/{portId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateOrganizationConfigTemplateSwitchProfilePortReader{formats: a.formats},
		AuthInfo:           authInfo,
		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.(*UpdateOrganizationConfigTemplateSwitchProfilePortOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateOrganizationConfigTemplateSwitchProfilePort: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}