v1

package

Go to main page

Versions in this module

v0

v0.1.6

Sep 14, 2021

Changes in this version

+ const DeviceType

v0.1.5

Sep 6, 2021

Changes in this version

type Registration

+ func (o *Registration) SetSubscriptions(sub []string)

v0.1.4

Sep 6, 2021

Changes in this version

+ const BfdFinalizer

+ const DeviceMatch

+ const DeviceTypeSRL

+ const Group

+ const InterfaceFinalizer

+ const InterfaceSubinterfaceFinalizer

+ const NetworkinstanceAggregateroutesFinalizer

+ const NetworkinstanceFinalizer

+ const NetworkinstanceNexthopgroupsFinalizer

+ const NetworkinstanceProtocolsBgpFinalizer

+ const NetworkinstanceProtocolsBgpevpnFinalizer

+ const NetworkinstanceProtocolsBgpvpnFinalizer

+ const NetworkinstanceProtocolsIsisFinalizer

+ const NetworkinstanceProtocolsLinuxFinalizer

+ const NetworkinstanceProtocolsOspfFinalizer

+ const NetworkinstanceStaticroutesFinalizer

+ const RoutingpolicyAspathsetFinalizer

+ const RoutingpolicyCommunitysetFinalizer

+ const RoutingpolicyPolicyFinalizer

+ const RoutingpolicyPrefixsetFinalizer

+ const SystemMtuFinalizer

+ const SystemNameFinalizer

+ const SystemNetworkinstanceProtocolsBgpvpnFinalizer

+ const SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiFinalizer

+ const SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceFinalizer

+ const SystemNetworkinstanceProtocolsEvpnFinalizer

+ const SystemNtpFinalizer

+ const TunnelinterfaceFinalizer

+ const TunnelinterfaceVxlaninterfaceFinalizer

+ const Version

+ var AddToScheme = SchemeBuilder.AddToScheme

+ var BfdGroupKind = schema.GroupKind{Group: Group, Kind: BfdKind}.String()

+ var BfdGroupVersionKind = GroupVersion.WithKind(BfdKind)

+ var BfdKind = reflect.TypeOf(SrlBfd{}).Name()

+ var BfdKindAPIVersion = BfdKind + "." + GroupVersion.String()

+ var GroupVersion = schema.GroupVersion

+ var InterfaceGroupKind = schema.GroupKind{Group: Group, Kind: InterfaceKind}.String()

+ var InterfaceGroupVersionKind = GroupVersion.WithKind(InterfaceKind)

+ var InterfaceKind = reflect.TypeOf(SrlInterface{}).Name()

+ var InterfaceKindAPIVersion = InterfaceKind + "." + GroupVersion.String()

+ var InterfaceSubinterfaceGroupKind = schema.GroupKind{Group: Group, Kind: InterfaceSubinterfaceKind}.String()

+ var InterfaceSubinterfaceGroupVersionKind = GroupVersion.WithKind(InterfaceSubinterfaceKind)

+ var InterfaceSubinterfaceKind = reflect.TypeOf(SrlInterfaceSubinterface{}).Name()

+ var InterfaceSubinterfaceKindAPIVersion = InterfaceSubinterfaceKind + "." + GroupVersion.String()

+ var NetworkinstanceAggregateroutesGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceAggregateroutesKind}.String()

+ var NetworkinstanceAggregateroutesGroupVersionKind = GroupVersion.WithKind(NetworkinstanceAggregateroutesKind)

+ var NetworkinstanceAggregateroutesKind = reflect.TypeOf(SrlNetworkinstanceAggregateroutes{}).Name()

+ var NetworkinstanceAggregateroutesKindAPIVersion = NetworkinstanceAggregateroutesKind + "." + GroupVersion.String()

+ var NetworkinstanceGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceKind}.String()

+ var NetworkinstanceGroupVersionKind = GroupVersion.WithKind(NetworkinstanceKind)

+ var NetworkinstanceKind = reflect.TypeOf(SrlNetworkinstance{}).Name()

+ var NetworkinstanceKindAPIVersion = NetworkinstanceKind + "." + GroupVersion.String()

+ var NetworkinstanceNexthopgroupsGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceNexthopgroupsKind}.String()

+ var NetworkinstanceNexthopgroupsGroupVersionKind = GroupVersion.WithKind(NetworkinstanceNexthopgroupsKind)

+ var NetworkinstanceNexthopgroupsKind = reflect.TypeOf(SrlNetworkinstanceNexthopgroups{}).Name()

+ var NetworkinstanceNexthopgroupsKindAPIVersion = NetworkinstanceNexthopgroupsKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsBgpGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsBgpKind}.String()

+ var NetworkinstanceProtocolsBgpGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsBgpKind)

+ var NetworkinstanceProtocolsBgpKind = reflect.TypeOf(SrlNetworkinstanceProtocolsBgp{}).Name()

+ var NetworkinstanceProtocolsBgpKindAPIVersion = NetworkinstanceProtocolsBgpKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsBgpevpnGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsBgpevpnKind}.String()

+ var NetworkinstanceProtocolsBgpevpnGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsBgpevpnKind)

+ var NetworkinstanceProtocolsBgpevpnKind = reflect.TypeOf(SrlNetworkinstanceProtocolsBgpevpn{}).Name()

+ var NetworkinstanceProtocolsBgpevpnKindAPIVersion = NetworkinstanceProtocolsBgpevpnKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsBgpvpnGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsBgpvpnKind}.String()

+ var NetworkinstanceProtocolsBgpvpnGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsBgpvpnKind)

+ var NetworkinstanceProtocolsBgpvpnKind = reflect.TypeOf(SrlNetworkinstanceProtocolsBgpvpn{}).Name()

+ var NetworkinstanceProtocolsBgpvpnKindAPIVersion = NetworkinstanceProtocolsBgpvpnKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsIsisGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsIsisKind}.String()

+ var NetworkinstanceProtocolsIsisGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsIsisKind)

+ var NetworkinstanceProtocolsIsisKind = reflect.TypeOf(SrlNetworkinstanceProtocolsIsis{}).Name()

+ var NetworkinstanceProtocolsIsisKindAPIVersion = NetworkinstanceProtocolsIsisKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsLinuxGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsLinuxKind}.String()

+ var NetworkinstanceProtocolsLinuxGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsLinuxKind)

+ var NetworkinstanceProtocolsLinuxKind = reflect.TypeOf(SrlNetworkinstanceProtocolsLinux{}).Name()

+ var NetworkinstanceProtocolsLinuxKindAPIVersion = NetworkinstanceProtocolsLinuxKind + "." + GroupVersion.String()

+ var NetworkinstanceProtocolsOspfGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceProtocolsOspfKind}.String()

+ var NetworkinstanceProtocolsOspfGroupVersionKind = GroupVersion.WithKind(NetworkinstanceProtocolsOspfKind)

+ var NetworkinstanceProtocolsOspfKind = reflect.TypeOf(SrlNetworkinstanceProtocolsOspf{}).Name()

+ var NetworkinstanceProtocolsOspfKindAPIVersion = NetworkinstanceProtocolsOspfKind + "." + GroupVersion.String()

+ var NetworkinstanceStaticroutesGroupKind = schema.GroupKind{Group: Group, Kind: NetworkinstanceStaticroutesKind}.String()

+ var NetworkinstanceStaticroutesGroupVersionKind = GroupVersion.WithKind(NetworkinstanceStaticroutesKind)

+ var NetworkinstanceStaticroutesKind = reflect.TypeOf(SrlNetworkinstanceStaticroutes{}).Name()

+ var NetworkinstanceStaticroutesKindAPIVersion = NetworkinstanceStaticroutesKind + "." + GroupVersion.String()

+ var RegistrationGroupKind = schema.GroupKind{Group: Group, Kind: RegistrationKind}.String()

+ var RegistrationGroupVersionKind = GroupVersion.WithKind(RegistrationKind)

+ var RegistrationKind = reflect.TypeOf(Registration{}).Name()

+ var RegistrationKindAPIVersion = RegistrationKind + "." + GroupVersion.String()

+ var RoutingpolicyAspathsetGroupKind = schema.GroupKind{Group: Group, Kind: RoutingpolicyAspathsetKind}.String()

+ var RoutingpolicyAspathsetGroupVersionKind = GroupVersion.WithKind(RoutingpolicyAspathsetKind)

+ var RoutingpolicyAspathsetKind = reflect.TypeOf(SrlRoutingpolicyAspathset{}).Name()

+ var RoutingpolicyAspathsetKindAPIVersion = RoutingpolicyAspathsetKind + "." + GroupVersion.String()

+ var RoutingpolicyCommunitysetGroupKind = schema.GroupKind{Group: Group, Kind: RoutingpolicyCommunitysetKind}.String()

+ var RoutingpolicyCommunitysetGroupVersionKind = GroupVersion.WithKind(RoutingpolicyCommunitysetKind)

+ var RoutingpolicyCommunitysetKind = reflect.TypeOf(SrlRoutingpolicyCommunityset{}).Name()

+ var RoutingpolicyCommunitysetKindAPIVersion = RoutingpolicyCommunitysetKind + "." + GroupVersion.String()

+ var RoutingpolicyPolicyGroupKind = schema.GroupKind{Group: Group, Kind: RoutingpolicyPolicyKind}.String()

+ var RoutingpolicyPolicyGroupVersionKind = GroupVersion.WithKind(RoutingpolicyPolicyKind)

+ var RoutingpolicyPolicyKind = reflect.TypeOf(SrlRoutingpolicyPolicy{}).Name()

+ var RoutingpolicyPolicyKindAPIVersion = RoutingpolicyPolicyKind + "." + GroupVersion.String()

+ var RoutingpolicyPrefixsetGroupKind = schema.GroupKind{Group: Group, Kind: RoutingpolicyPrefixsetKind}.String()

+ var RoutingpolicyPrefixsetGroupVersionKind = GroupVersion.WithKind(RoutingpolicyPrefixsetKind)

+ var RoutingpolicyPrefixsetKind = reflect.TypeOf(SrlRoutingpolicyPrefixset{}).Name()

+ var RoutingpolicyPrefixsetKindAPIVersion = RoutingpolicyPrefixsetKind + "." + GroupVersion.String()

+ var SchemeBuilder = &scheme.Builder

+ var SystemMtuGroupKind = schema.GroupKind{Group: Group, Kind: SystemMtuKind}.String()

+ var SystemMtuGroupVersionKind = GroupVersion.WithKind(SystemMtuKind)

+ var SystemMtuKind = reflect.TypeOf(SrlSystemMtu{}).Name()

+ var SystemMtuKindAPIVersion = SystemMtuKind + "." + GroupVersion.String()

+ var SystemNameGroupKind = schema.GroupKind{Group: Group, Kind: SystemNameKind}.String()

+ var SystemNameGroupVersionKind = GroupVersion.WithKind(SystemNameKind)

+ var SystemNameKind = reflect.TypeOf(SrlSystemName{}).Name()

+ var SystemNameKindAPIVersion = SystemNameKind + "." + GroupVersion.String()

+ var SystemNetworkinstanceProtocolsBgpvpnGroupKind = schema.GroupKind{Group: Group, Kind: SystemNetworkinstanceProtocolsBgpvpnKind}.String()

+ var SystemNetworkinstanceProtocolsBgpvpnGroupVersionKind = GroupVersion.WithKind(SystemNetworkinstanceProtocolsBgpvpnKind)

+ var SystemNetworkinstanceProtocolsBgpvpnKind = reflect.TypeOf(SrlSystemNetworkinstanceProtocolsBgpvpn{}).Name()

+ var SystemNetworkinstanceProtocolsBgpvpnKindAPIVersion = SystemNetworkinstanceProtocolsBgpvpnKind + "." + GroupVersion.String()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiGroupKind = schema.GroupKind{Group: Group, Kind: SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiKind}.String()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiGroupVersionKind = GroupVersion.WithKind(SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiKind)

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiKind = reflect.TypeOf(SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi{}).Name()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiKindAPIVersion = SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiKind + "." + GroupVersion.String()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceGroupKind = schema.GroupKind{Group: Group, Kind: SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceKind}.String()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceGroupVersionKind = GroupVersion.WithKind(SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceKind)

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceKind = reflect.TypeOf(SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance{}).Name()

+ var SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceKindAPIVersion = SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceKind + "." + GroupVersion.String()

+ var SystemNetworkinstanceProtocolsEvpnGroupKind = schema.GroupKind{Group: Group, Kind: SystemNetworkinstanceProtocolsEvpnKind}.String()

+ var SystemNetworkinstanceProtocolsEvpnGroupVersionKind = GroupVersion.WithKind(SystemNetworkinstanceProtocolsEvpnKind)

+ var SystemNetworkinstanceProtocolsEvpnKind = reflect.TypeOf(SrlSystemNetworkinstanceProtocolsEvpn{}).Name()

+ var SystemNetworkinstanceProtocolsEvpnKindAPIVersion = SystemNetworkinstanceProtocolsEvpnKind + "." + GroupVersion.String()

+ var SystemNtpGroupKind = schema.GroupKind{Group: Group, Kind: SystemNtpKind}.String()

+ var SystemNtpGroupVersionKind = GroupVersion.WithKind(SystemNtpKind)

+ var SystemNtpKind = reflect.TypeOf(SrlSystemNtp{}).Name()

+ var SystemNtpKindAPIVersion = SystemNtpKind + "." + GroupVersion.String()

+ var TunnelinterfaceGroupKind = schema.GroupKind{Group: Group, Kind: TunnelinterfaceKind}.String()

+ var TunnelinterfaceGroupVersionKind = GroupVersion.WithKind(TunnelinterfaceKind)

+ var TunnelinterfaceKind = reflect.TypeOf(SrlTunnelinterface{}).Name()

+ var TunnelinterfaceKindAPIVersion = TunnelinterfaceKind + "." + GroupVersion.String()

+ var TunnelinterfaceVxlaninterfaceGroupKind = schema.GroupKind{Group: Group, Kind: TunnelinterfaceVxlaninterfaceKind}.String()

+ var TunnelinterfaceVxlaninterfaceGroupVersionKind = GroupVersion.WithKind(TunnelinterfaceVxlaninterfaceKind)

+ var TunnelinterfaceVxlaninterfaceKind = reflect.TypeOf(SrlTunnelinterfaceVxlaninterface{}).Name()

+ var TunnelinterfaceVxlaninterfaceKindAPIVersion = TunnelinterfaceVxlaninterfaceKind + "." + GroupVersion.String()

+ type Bfd struct

+ MicroBfdSessions *BfdMicroBfdSessions

+ Subinterface []*BfdSubinterface

+ func (in *Bfd) DeepCopy() *Bfd

+ func (in *Bfd) DeepCopyInto(out *Bfd)

+ type BfdMicroBfdSessions struct

+ LagInterface []*BfdMicroBfdSessionsLagInterface

+ func (in *BfdMicroBfdSessions) DeepCopy() *BfdMicroBfdSessions

+ func (in *BfdMicroBfdSessions) DeepCopyInto(out *BfdMicroBfdSessions)

+ type BfdMicroBfdSessionsLagInterface struct

+ AdminState *string

+ DesiredMinimumTransmitInterval *uint32

+ DetectionMultiplier *uint8

+ LocalAddress *string

+ Name *string

+ RemoteAddress *string

+ RequiredMinimumReceive *uint32

+ func (in *BfdMicroBfdSessionsLagInterface) DeepCopy() *BfdMicroBfdSessionsLagInterface

+ func (in *BfdMicroBfdSessionsLagInterface) DeepCopyInto(out *BfdMicroBfdSessionsLagInterface)

+ type BfdObservation struct

+ func (in *BfdObservation) DeepCopy() *BfdObservation

+ func (in *BfdObservation) DeepCopyInto(out *BfdObservation)

+ type BfdParameters struct

+ SrlBfd *Bfd

+ func (in *BfdParameters) DeepCopy() *BfdParameters

+ func (in *BfdParameters) DeepCopyInto(out *BfdParameters)

+ type BfdSpec struct

+ ForNetworkNode BfdParameters

+ func (in *BfdSpec) DeepCopy() *BfdSpec

+ func (in *BfdSpec) DeepCopyInto(out *BfdSpec)

+ type BfdStatus struct

+ AtNetworkNode BfdObservation

+ func (in *BfdStatus) DeepCopy() *BfdStatus

+ func (in *BfdStatus) DeepCopyInto(out *BfdStatus)

+ type BfdSubinterface struct

+ func (in *BfdSubinterface) DeepCopy() *BfdSubinterface

+ func (in *BfdSubinterface) DeepCopyInto(out *BfdSubinterface)

+ AdminState *string

+ DesiredMinimumTransmitInterval *uint32

+ DetectionMultiplier *uint8

+ Id *string

+ MinimumEchoReceiveInterval *uint32

+ RequiredMinimumReceive *uint32

+ type Interface struct

+ AdminState *string

+ Description *string

+ Ethernet *InterfaceEthernet

+ Lag *InterfaceLag

+ LoopbackMode *bool

+ Mtu *uint16

+ Name *string

+ Qos *InterfaceQos

+ Sflow *InterfaceSflow

+ Transceiver *InterfaceTransceiver

+ VlanTagging *bool

+ func (in *Interface) DeepCopy() *Interface

+ func (in *Interface) DeepCopyInto(out *Interface)

+ type InterfaceEthernet struct

+ AggregateId *string

+ AutoNegotiate *bool

+ DuplexMode *string

+ FlowControl *InterfaceEthernetFlowControl

+ LacpPortPriority *uint16

+ PortSpeed *string

+ func (in *InterfaceEthernet) DeepCopy() *InterfaceEthernet

+ func (in *InterfaceEthernet) DeepCopyInto(out *InterfaceEthernet)

+ type InterfaceEthernetFlowControl struct

+ Receive *bool

+ Transmit *bool

+ func (in *InterfaceEthernetFlowControl) DeepCopy() *InterfaceEthernetFlowControl

+ func (in *InterfaceEthernetFlowControl) DeepCopyInto(out *InterfaceEthernetFlowControl)

+ type InterfaceLag struct

+ Lacp *InterfaceLagLacp

+ LacpFallbackMode *string

+ LacpFallbackTimeout *uint16

+ LagType *string

+ MemberSpeed *string

+ MinLinks *uint16

+ func (in *InterfaceLag) DeepCopy() *InterfaceLag

+ func (in *InterfaceLag) DeepCopyInto(out *InterfaceLag)

+ type InterfaceLagLacp struct

+ AdminKey *uint16

+ Interval *string

+ LacpMode *string

+ SystemIdMac *string

+ SystemPriority *uint16

+ func (in *InterfaceLagLacp) DeepCopy() *InterfaceLagLacp

+ func (in *InterfaceLagLacp) DeepCopyInto(out *InterfaceLagLacp)

+ type InterfaceObservation struct

+ func (in *InterfaceObservation) DeepCopy() *InterfaceObservation

+ func (in *InterfaceObservation) DeepCopyInto(out *InterfaceObservation)

+ type InterfaceParameters struct

+ SrlInterface *Interface

+ func (in *InterfaceParameters) DeepCopy() *InterfaceParameters

+ func (in *InterfaceParameters) DeepCopyInto(out *InterfaceParameters)

+ type InterfaceQos struct

+ Output *InterfaceQosOutput

+ func (in *InterfaceQos) DeepCopy() *InterfaceQos

+ func (in *InterfaceQos) DeepCopyInto(out *InterfaceQos)

+ type InterfaceQosOutput struct

+ MulticastQueue []*InterfaceQosOutputMulticastQueue

+ Scheduler *InterfaceQosOutputScheduler

+ UnicastQueue []*InterfaceQosOutputUnicastQueue

+ func (in *InterfaceQosOutput) DeepCopy() *InterfaceQosOutput

+ func (in *InterfaceQosOutput) DeepCopyInto(out *InterfaceQosOutput)

+ type InterfaceQosOutputMulticastQueue struct

+ QueueId *uint8

+ Scheduling *InterfaceQosOutputMulticastQueueScheduling

+ Template *string

+ func (in *InterfaceQosOutputMulticastQueue) DeepCopy() *InterfaceQosOutputMulticastQueue

+ func (in *InterfaceQosOutputMulticastQueue) DeepCopyInto(out *InterfaceQosOutputMulticastQueue)

+ type InterfaceQosOutputMulticastQueueScheduling struct

+ PeakRatePercent *uint8

+ func (in *InterfaceQosOutputMulticastQueueScheduling) DeepCopy() *InterfaceQosOutputMulticastQueueScheduling

+ func (in *InterfaceQosOutputMulticastQueueScheduling) DeepCopyInto(out *InterfaceQosOutputMulticastQueueScheduling)

+ type InterfaceQosOutputScheduler struct

+ Tier []*InterfaceQosOutputSchedulerTier

+ func (in *InterfaceQosOutputScheduler) DeepCopy() *InterfaceQosOutputScheduler

+ func (in *InterfaceQosOutputScheduler) DeepCopyInto(out *InterfaceQosOutputScheduler)

+ type InterfaceQosOutputSchedulerTier struct

+ Level *uint8

+ Node []*InterfaceQosOutputSchedulerTierNode

+ func (in *InterfaceQosOutputSchedulerTier) DeepCopy() *InterfaceQosOutputSchedulerTier

+ func (in *InterfaceQosOutputSchedulerTier) DeepCopyInto(out *InterfaceQosOutputSchedulerTier)

+ type InterfaceQosOutputSchedulerTierNode struct

+ NodeNumber *uint8

+ StrictPriority *bool

+ Weight *uint8

+ func (in *InterfaceQosOutputSchedulerTierNode) DeepCopy() *InterfaceQosOutputSchedulerTierNode

+ func (in *InterfaceQosOutputSchedulerTierNode) DeepCopyInto(out *InterfaceQosOutputSchedulerTierNode)

+ type InterfaceQosOutputUnicastQueue struct

+ QueueId *uint8

+ Scheduling *InterfaceQosOutputUnicastQueueScheduling

+ Template *string

+ VoqTemplate *string

+ func (in *InterfaceQosOutputUnicastQueue) DeepCopy() *InterfaceQosOutputUnicastQueue

+ func (in *InterfaceQosOutputUnicastQueue) DeepCopyInto(out *InterfaceQosOutputUnicastQueue)

+ type InterfaceQosOutputUnicastQueueScheduling struct

+ PeakRatePercent *uint8

+ StrictPriority *bool

+ Weight *uint8

+ func (in *InterfaceQosOutputUnicastQueueScheduling) DeepCopy() *InterfaceQosOutputUnicastQueueScheduling

+ func (in *InterfaceQosOutputUnicastQueueScheduling) DeepCopyInto(out *InterfaceQosOutputUnicastQueueScheduling)

+ type InterfaceSflow struct

+ AdminState *string

+ func (in *InterfaceSflow) DeepCopy() *InterfaceSflow

+ func (in *InterfaceSflow) DeepCopyInto(out *InterfaceSflow)

+ type InterfaceSpec struct

+ ForNetworkNode InterfaceParameters

+ func (in *InterfaceSpec) DeepCopy() *InterfaceSpec

+ func (in *InterfaceSpec) DeepCopyInto(out *InterfaceSpec)

+ type InterfaceStatus struct

+ AtNetworkNode InterfaceObservation

+ func (in *InterfaceStatus) DeepCopy() *InterfaceStatus

+ func (in *InterfaceStatus) DeepCopyInto(out *InterfaceStatus)

+ type InterfaceSubinterface struct

+ func (in *InterfaceSubinterface) DeepCopy() *InterfaceSubinterface

+ func (in *InterfaceSubinterface) DeepCopyInto(out *InterfaceSubinterface)

+ Acl *InterfaceSubinterfaceAcl

+ AdminState *string

+ AnycastGw *InterfaceSubinterfaceAnycastGw

+ BridgeTable *InterfaceSubinterfaceBridgeTable

+ Description *string

+ Index *uint32

+ IpMtu *uint16

+ Ipv4 *InterfaceSubinterfaceIpv4

+ Ipv6 *InterfaceSubinterfaceIpv6

+ L2Mtu *uint16

+ LocalMirrorDestination *InterfaceSubinterfaceLocalMirrorDestination

+ Qos *InterfaceSubinterfaceQos

+ Type *string

+ Vlan *InterfaceSubinterfaceVlan

+ type InterfaceSubinterfaceAcl struct

+ func (in *InterfaceSubinterfaceAcl) DeepCopy() *InterfaceSubinterfaceAcl

+ func (in *InterfaceSubinterfaceAcl) DeepCopyInto(out *InterfaceSubinterfaceAcl)

+ Input *InterfaceSubinterfaceAclInput

+ Output *InterfaceSubinterfaceAclOutput

+ type InterfaceSubinterfaceAclInput struct

+ func (in *InterfaceSubinterfaceAclInput) DeepCopy() *InterfaceSubinterfaceAclInput

+ func (in *InterfaceSubinterfaceAclInput) DeepCopyInto(out *InterfaceSubinterfaceAclInput)

+ Ipv4Filter *string

+ Ipv6Filter *string

+ type InterfaceSubinterfaceAclOutput struct

+ func (in *InterfaceSubinterfaceAclOutput) DeepCopy() *InterfaceSubinterfaceAclOutput

+ func (in *InterfaceSubinterfaceAclOutput) DeepCopyInto(out *InterfaceSubinterfaceAclOutput)

+ Ipv4Filter *string

+ Ipv6Filter *string

+ type InterfaceSubinterfaceAnycastGw struct

+ func (in *InterfaceSubinterfaceAnycastGw) DeepCopy() *InterfaceSubinterfaceAnycastGw

+ func (in *InterfaceSubinterfaceAnycastGw) DeepCopyInto(out *InterfaceSubinterfaceAnycastGw)

+ AnycastGwMac *string

+ VirtualRouterId *uint8

+ type InterfaceSubinterfaceBridgeTable struct

+ func (in *InterfaceSubinterfaceBridgeTable) DeepCopy() *InterfaceSubinterfaceBridgeTable

+ func (in *InterfaceSubinterfaceBridgeTable) DeepCopyInto(out *InterfaceSubinterfaceBridgeTable)

+ DiscardUnknownSrcMac *bool

+ MacDuplication *InterfaceSubinterfaceBridgeTableMacDuplication

+ MacLearning *InterfaceSubinterfaceBridgeTableMacLearning

+ MacLimit *InterfaceSubinterfaceBridgeTableMacLimit

+ type InterfaceSubinterfaceBridgeTableMacDuplication struct

+ func (in *InterfaceSubinterfaceBridgeTableMacDuplication) DeepCopy() *InterfaceSubinterfaceBridgeTableMacDuplication

+ func (in *InterfaceSubinterfaceBridgeTableMacDuplication) DeepCopyInto(out *InterfaceSubinterfaceBridgeTableMacDuplication)

+ Action *string

+ type InterfaceSubinterfaceBridgeTableMacLearning struct

+ func (in *InterfaceSubinterfaceBridgeTableMacLearning) DeepCopy() *InterfaceSubinterfaceBridgeTableMacLearning

+ func (in *InterfaceSubinterfaceBridgeTableMacLearning) DeepCopyInto(out *InterfaceSubinterfaceBridgeTableMacLearning)

+ AdminState *string

+ Aging *InterfaceSubinterfaceBridgeTableMacLearningAging

+ type InterfaceSubinterfaceBridgeTableMacLearningAging struct

+ func (in *InterfaceSubinterfaceBridgeTableMacLearningAging) DeepCopy() *InterfaceSubinterfaceBridgeTableMacLearningAging

+ func (in *InterfaceSubinterfaceBridgeTableMacLearningAging) DeepCopyInto(out *InterfaceSubinterfaceBridgeTableMacLearningAging)

+ AdminState *string

+ type InterfaceSubinterfaceBridgeTableMacLimit struct

+ func (in *InterfaceSubinterfaceBridgeTableMacLimit) DeepCopy() *InterfaceSubinterfaceBridgeTableMacLimit

+ func (in *InterfaceSubinterfaceBridgeTableMacLimit) DeepCopyInto(out *InterfaceSubinterfaceBridgeTableMacLimit)

+ MaximumEntries *int32

+ WarningThresholdPct *int32

+ type InterfaceSubinterfaceIpv4 struct

+ func (in *InterfaceSubinterfaceIpv4) DeepCopy() *InterfaceSubinterfaceIpv4

+ func (in *InterfaceSubinterfaceIpv4) DeepCopyInto(out *InterfaceSubinterfaceIpv4)

+ Address []*InterfaceSubinterfaceIpv4Address

+ AllowDirectedBroadcast *bool

+ Arp *InterfaceSubinterfaceIpv4Arp

+ DhcpClient *InterfaceSubinterfaceIpv4DhcpClient

+ DhcpRelay *InterfaceSubinterfaceIpv4DhcpRelay

+ Vrrp *InterfaceSubinterfaceIpv4Vrrp

+ type InterfaceSubinterfaceIpv4Address struct

+ func (in *InterfaceSubinterfaceIpv4Address) DeepCopy() *InterfaceSubinterfaceIpv4Address

+ func (in *InterfaceSubinterfaceIpv4Address) DeepCopyInto(out *InterfaceSubinterfaceIpv4Address)

+ AnycastGw *bool

+ IpPrefix *string

+ Primary *string

+ type InterfaceSubinterfaceIpv4Arp struct

+ func (in *InterfaceSubinterfaceIpv4Arp) DeepCopy() *InterfaceSubinterfaceIpv4Arp

+ func (in *InterfaceSubinterfaceIpv4Arp) DeepCopyInto(out *InterfaceSubinterfaceIpv4Arp)

+ Debug *string

+ DuplicateAddressDetection *bool

+ Evpn *InterfaceSubinterfaceIpv4ArpEvpn

+ HostRoute *InterfaceSubinterfaceIpv4ArpHostRoute

+ LearnUnsolicited *bool

+ Neighbor []*InterfaceSubinterfaceIpv4ArpNeighbor

+ Timeout *uint16

+ type InterfaceSubinterfaceIpv4ArpEvpn struct

+ func (in *InterfaceSubinterfaceIpv4ArpEvpn) DeepCopy() *InterfaceSubinterfaceIpv4ArpEvpn

+ func (in *InterfaceSubinterfaceIpv4ArpEvpn) DeepCopyInto(out *InterfaceSubinterfaceIpv4ArpEvpn)

+ Advertise []*InterfaceSubinterfaceIpv4ArpEvpnAdvertise

+ type InterfaceSubinterfaceIpv4ArpEvpnAdvertise struct

+ func (in *InterfaceSubinterfaceIpv4ArpEvpnAdvertise) DeepCopy() *InterfaceSubinterfaceIpv4ArpEvpnAdvertise

+ func (in *InterfaceSubinterfaceIpv4ArpEvpnAdvertise) DeepCopyInto(out *InterfaceSubinterfaceIpv4ArpEvpnAdvertise)

+ AdminTag *uint32

+ RouteType *string

+ type InterfaceSubinterfaceIpv4ArpHostRoute struct

+ func (in *InterfaceSubinterfaceIpv4ArpHostRoute) DeepCopy() *InterfaceSubinterfaceIpv4ArpHostRoute

+ func (in *InterfaceSubinterfaceIpv4ArpHostRoute) DeepCopyInto(out *InterfaceSubinterfaceIpv4ArpHostRoute)

+ Populate []*InterfaceSubinterfaceIpv4ArpHostRoutePopulate

+ type InterfaceSubinterfaceIpv4ArpHostRoutePopulate struct

+ func (in *InterfaceSubinterfaceIpv4ArpHostRoutePopulate) DeepCopy() *InterfaceSubinterfaceIpv4ArpHostRoutePopulate

+ func (in *InterfaceSubinterfaceIpv4ArpHostRoutePopulate) DeepCopyInto(out *InterfaceSubinterfaceIpv4ArpHostRoutePopulate)

+ AdminTag *uint32

+ RouteType *string

+ type InterfaceSubinterfaceIpv4ArpNeighbor struct

+ func (in *InterfaceSubinterfaceIpv4ArpNeighbor) DeepCopy() *InterfaceSubinterfaceIpv4ArpNeighbor

+ func (in *InterfaceSubinterfaceIpv4ArpNeighbor) DeepCopyInto(out *InterfaceSubinterfaceIpv4ArpNeighbor)

+ Ipv4Address *string

+ LinkLayerAddress *string

+ type InterfaceSubinterfaceIpv4DhcpClient struct

+ func (in *InterfaceSubinterfaceIpv4DhcpClient) DeepCopy() *InterfaceSubinterfaceIpv4DhcpClient

+ func (in *InterfaceSubinterfaceIpv4DhcpClient) DeepCopyInto(out *InterfaceSubinterfaceIpv4DhcpClient)

+ TraceOptions *InterfaceSubinterfaceIpv4DhcpClientTraceOptions

+ type InterfaceSubinterfaceIpv4DhcpClientTraceOptions struct

+ func (in *InterfaceSubinterfaceIpv4DhcpClientTraceOptions) DeepCopy() *InterfaceSubinterfaceIpv4DhcpClientTraceOptions

+ func (in *InterfaceSubinterfaceIpv4DhcpClientTraceOptions) DeepCopyInto(out *InterfaceSubinterfaceIpv4DhcpClientTraceOptions)

+ Trace *string

+ type InterfaceSubinterfaceIpv4DhcpRelay struct

+ func (in *InterfaceSubinterfaceIpv4DhcpRelay) DeepCopy() *InterfaceSubinterfaceIpv4DhcpRelay

+ func (in *InterfaceSubinterfaceIpv4DhcpRelay) DeepCopyInto(out *InterfaceSubinterfaceIpv4DhcpRelay)

+ AdminState *string

+ GiAddress *string

+ Option *string

+ Server *string

+ TraceOptions *InterfaceSubinterfaceIpv4DhcpRelayTraceOptions

+ UseGiAddrAsSrcIpAddr *bool

+ type InterfaceSubinterfaceIpv4DhcpRelayTraceOptions struct

+ func (in *InterfaceSubinterfaceIpv4DhcpRelayTraceOptions) DeepCopy() *InterfaceSubinterfaceIpv4DhcpRelayTraceOptions

+ func (in *InterfaceSubinterfaceIpv4DhcpRelayTraceOptions) DeepCopyInto(out *InterfaceSubinterfaceIpv4DhcpRelayTraceOptions)

+ Trace *string

+ type InterfaceSubinterfaceIpv4Vrrp struct

+ func (in *InterfaceSubinterfaceIpv4Vrrp) DeepCopy() *InterfaceSubinterfaceIpv4Vrrp

+ func (in *InterfaceSubinterfaceIpv4Vrrp) DeepCopyInto(out *InterfaceSubinterfaceIpv4Vrrp)

+ VrrpGroup []*InterfaceSubinterfaceIpv4VrrpVrrpGroup

+ type InterfaceSubinterfaceIpv4VrrpVrrpGroup struct

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroup) DeepCopy() *InterfaceSubinterfaceIpv4VrrpVrrpGroup

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroup) DeepCopyInto(out *InterfaceSubinterfaceIpv4VrrpVrrpGroup)

+ AcceptMode *bool

+ AdminState *string

+ AdvertiseInterval *uint16

+ Authentication *InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication

+ InitDelay *uint16

+ InterfaceTracking *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking

+ MasterInheritInterval *bool

+ OperInterval *uint16

+ Preempt *bool

+ PreemptDelay *uint16

+ Priority *uint8

+ Statistics *InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics

+ Version *uint8

+ VirtualAddress *string

+ VirtualRouterId *uint8

+ type InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication struct

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication) DeepCopy() *InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication) DeepCopyInto(out *InterfaceSubinterfaceIpv4VrrpVrrpGroupAuthentication)

+ Keychain *string

+ type InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking struct

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking) DeepCopy() *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking) DeepCopyInto(out *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTracking)

+ TrackInterface []*InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface

+ type InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface struct

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface) DeepCopy() *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface) DeepCopyInto(out *InterfaceSubinterfaceIpv4VrrpVrrpGroupInterfaceTrackingTrackInterface)

+ Interface *string

+ PriorityDecrement *uint8

+ type InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics struct

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics) DeepCopy() *InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics

+ func (in *InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics) DeepCopyInto(out *InterfaceSubinterfaceIpv4VrrpVrrpGroupStatistics)

+ type InterfaceSubinterfaceIpv6 struct

+ func (in *InterfaceSubinterfaceIpv6) DeepCopy() *InterfaceSubinterfaceIpv6

+ func (in *InterfaceSubinterfaceIpv6) DeepCopyInto(out *InterfaceSubinterfaceIpv6)

+ Address []*InterfaceSubinterfaceIpv6Address

+ DhcpClient *InterfaceSubinterfaceIpv6DhcpClient

+ DhcpRelay *InterfaceSubinterfaceIpv6DhcpRelay

+ NeighborDiscovery *InterfaceSubinterfaceIpv6NeighborDiscovery

+ RouterAdvertisement *InterfaceSubinterfaceIpv6RouterAdvertisement

+ Vrrp *InterfaceSubinterfaceIpv6Vrrp

+ type InterfaceSubinterfaceIpv6Address struct

+ func (in *InterfaceSubinterfaceIpv6Address) DeepCopy() *InterfaceSubinterfaceIpv6Address

+ func (in *InterfaceSubinterfaceIpv6Address) DeepCopyInto(out *InterfaceSubinterfaceIpv6Address)

+ AnycastGw *bool

+ IpPrefix *string

+ Primary *string

+ type InterfaceSubinterfaceIpv6DhcpClient struct

+ func (in *InterfaceSubinterfaceIpv6DhcpClient) DeepCopy() *InterfaceSubinterfaceIpv6DhcpClient

+ func (in *InterfaceSubinterfaceIpv6DhcpClient) DeepCopyInto(out *InterfaceSubinterfaceIpv6DhcpClient)

+ TraceOptions *InterfaceSubinterfaceIpv6DhcpClientTraceOptions

+ type InterfaceSubinterfaceIpv6DhcpClientTraceOptions struct

+ func (in *InterfaceSubinterfaceIpv6DhcpClientTraceOptions) DeepCopy() *InterfaceSubinterfaceIpv6DhcpClientTraceOptions

+ func (in *InterfaceSubinterfaceIpv6DhcpClientTraceOptions) DeepCopyInto(out *InterfaceSubinterfaceIpv6DhcpClientTraceOptions)

+ Trace *string

+ type InterfaceSubinterfaceIpv6DhcpRelay struct

+ func (in *InterfaceSubinterfaceIpv6DhcpRelay) DeepCopy() *InterfaceSubinterfaceIpv6DhcpRelay

+ func (in *InterfaceSubinterfaceIpv6DhcpRelay) DeepCopyInto(out *InterfaceSubinterfaceIpv6DhcpRelay)

+ AdminState *string

+ Option *string

+ Server *string

+ SourceAddress *string

+ TraceOptions *InterfaceSubinterfaceIpv6DhcpRelayTraceOptions

+ type InterfaceSubinterfaceIpv6DhcpRelayTraceOptions struct

+ func (in *InterfaceSubinterfaceIpv6DhcpRelayTraceOptions) DeepCopy() *InterfaceSubinterfaceIpv6DhcpRelayTraceOptions

+ func (in *InterfaceSubinterfaceIpv6DhcpRelayTraceOptions) DeepCopyInto(out *InterfaceSubinterfaceIpv6DhcpRelayTraceOptions)

+ Trace *string

+ type InterfaceSubinterfaceIpv6NeighborDiscovery struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscovery) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscovery

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscovery) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscovery)

+ Debug *string

+ DuplicateAddressDetection *bool

+ Evpn *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn

+ HostRoute *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute

+ LearnUnsolicited *string

+ Neighbor []*InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor

+ ReachableTime *uint32

+ StaleTime *uint32

+ type InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpn)

+ Advertise []*InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise

+ type InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscoveryEvpnAdvertise)

+ AdminTag *uint32

+ RouteType *string

+ type InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoute)

+ Populate []*InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate

+ type InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscoveryHostRoutePopulate)

+ AdminTag *uint32

+ RouteType *string

+ type InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor struct

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor) DeepCopy() *InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor

+ func (in *InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor) DeepCopyInto(out *InterfaceSubinterfaceIpv6NeighborDiscoveryNeighbor)

+ Ipv6Address *string

+ LinkLayerAddress *string

+ type InterfaceSubinterfaceIpv6RouterAdvertisement struct

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisement) DeepCopy() *InterfaceSubinterfaceIpv6RouterAdvertisement

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisement) DeepCopyInto(out *InterfaceSubinterfaceIpv6RouterAdvertisement)

+ Debug *string

+ RouterRole *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole

+ type InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole struct

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole) DeepCopy() *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole) DeepCopyInto(out *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRole)

+ AdminState *string

+ CurrentHopLimit *uint8

+ IpMtu *uint16

+ ManagedConfigurationFlag *bool

+ MaxAdvertisementInterval *uint16

+ MinAdvertisementInterval *uint16

+ OtherConfigurationFlag *bool

+ Prefix []*InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix

+ ReachableTime *uint32

+ RetransmitTime *uint32

+ RouterLifetime *uint16

+ type InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix struct

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix) DeepCopy() *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix

+ func (in *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix) DeepCopyInto(out *InterfaceSubinterfaceIpv6RouterAdvertisementRouterRolePrefix)

+ AutonomousFlag *bool

+ Ipv6Prefix *string

+ OnLinkFlag *bool

+ PreferredLifetime *uint32

+ ValidLifetime *uint32

+ type InterfaceSubinterfaceIpv6Vrrp struct

+ func (in *InterfaceSubinterfaceIpv6Vrrp) DeepCopy() *InterfaceSubinterfaceIpv6Vrrp

+ func (in *InterfaceSubinterfaceIpv6Vrrp) DeepCopyInto(out *InterfaceSubinterfaceIpv6Vrrp)

+ VrrpGroup []*InterfaceSubinterfaceIpv6VrrpVrrpGroup

+ type InterfaceSubinterfaceIpv6VrrpVrrpGroup struct

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroup) DeepCopy() *InterfaceSubinterfaceIpv6VrrpVrrpGroup

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroup) DeepCopyInto(out *InterfaceSubinterfaceIpv6VrrpVrrpGroup)

+ AcceptMode *bool

+ AdminState *string

+ AdvertiseInterval *uint16

+ Authentication *InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication

+ InitDelay *uint16

+ InterfaceTracking *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking

+ MasterInheritInterval *bool

+ OperInterval *uint16

+ Preempt *bool

+ PreemptDelay *uint16

+ Priority *uint8

+ Statistics *InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics

+ Version *uint8

+ VirtualAddress *string

+ VirtualRouterId *uint8

+ type InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication struct

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication) DeepCopy() *InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication) DeepCopyInto(out *InterfaceSubinterfaceIpv6VrrpVrrpGroupAuthentication)

+ Keychain *string

+ type InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking struct

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking) DeepCopy() *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking) DeepCopyInto(out *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTracking)

+ TrackInterface []*InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface

+ type InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface struct

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface) DeepCopy() *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface) DeepCopyInto(out *InterfaceSubinterfaceIpv6VrrpVrrpGroupInterfaceTrackingTrackInterface)

+ Interface *string

+ PriorityDecrement *uint8

+ type InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics struct

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics) DeepCopy() *InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics

+ func (in *InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics) DeepCopyInto(out *InterfaceSubinterfaceIpv6VrrpVrrpGroupStatistics)

+ type InterfaceSubinterfaceLocalMirrorDestination struct

+ func (in *InterfaceSubinterfaceLocalMirrorDestination) DeepCopy() *InterfaceSubinterfaceLocalMirrorDestination

+ func (in *InterfaceSubinterfaceLocalMirrorDestination) DeepCopyInto(out *InterfaceSubinterfaceLocalMirrorDestination)

+ AdminState *string

+ type InterfaceSubinterfaceObservation struct

+ func (in *InterfaceSubinterfaceObservation) DeepCopy() *InterfaceSubinterfaceObservation

+ func (in *InterfaceSubinterfaceObservation) DeepCopyInto(out *InterfaceSubinterfaceObservation)

+ type InterfaceSubinterfaceParameters struct

+ func (in *InterfaceSubinterfaceParameters) DeepCopy() *InterfaceSubinterfaceParameters

+ func (in *InterfaceSubinterfaceParameters) DeepCopyInto(out *InterfaceSubinterfaceParameters)

+ InterfaceName *string

+ SrlInterfaceSubinterface *InterfaceSubinterface

+ type InterfaceSubinterfaceQos struct

+ func (in *InterfaceSubinterfaceQos) DeepCopy() *InterfaceSubinterfaceQos

+ func (in *InterfaceSubinterfaceQos) DeepCopyInto(out *InterfaceSubinterfaceQos)

+ Input *InterfaceSubinterfaceQosInput

+ Output *InterfaceSubinterfaceQosOutput

+ type InterfaceSubinterfaceQosInput struct

+ func (in *InterfaceSubinterfaceQosInput) DeepCopy() *InterfaceSubinterfaceQosInput

+ func (in *InterfaceSubinterfaceQosInput) DeepCopyInto(out *InterfaceSubinterfaceQosInput)

+ Classifiers *InterfaceSubinterfaceQosInputClassifiers

+ type InterfaceSubinterfaceQosInputClassifiers struct

+ func (in *InterfaceSubinterfaceQosInputClassifiers) DeepCopy() *InterfaceSubinterfaceQosInputClassifiers

+ func (in *InterfaceSubinterfaceQosInputClassifiers) DeepCopyInto(out *InterfaceSubinterfaceQosInputClassifiers)

+ Dscp *string

+ Ipv4Dscp *string

+ Ipv6Dscp *string

+ MplsTrafficClass *string

+ type InterfaceSubinterfaceQosOutput struct

+ func (in *InterfaceSubinterfaceQosOutput) DeepCopy() *InterfaceSubinterfaceQosOutput

+ func (in *InterfaceSubinterfaceQosOutput) DeepCopyInto(out *InterfaceSubinterfaceQosOutput)

+ RewriteRules *InterfaceSubinterfaceQosOutputRewriteRules

+ type InterfaceSubinterfaceQosOutputRewriteRules struct

+ func (in *InterfaceSubinterfaceQosOutputRewriteRules) DeepCopy() *InterfaceSubinterfaceQosOutputRewriteRules

+ func (in *InterfaceSubinterfaceQosOutputRewriteRules) DeepCopyInto(out *InterfaceSubinterfaceQosOutputRewriteRules)

+ Dscp *string

+ Ipv4Dscp *string

+ Ipv6Dscp *string

+ MplsTrafficClass *string

+ type InterfaceSubinterfaceSpec struct

+ func (in *InterfaceSubinterfaceSpec) DeepCopy() *InterfaceSubinterfaceSpec

+ func (in *InterfaceSubinterfaceSpec) DeepCopyInto(out *InterfaceSubinterfaceSpec)

+ ForNetworkNode InterfaceSubinterfaceParameters

+ type InterfaceSubinterfaceStatus struct

+ func (in *InterfaceSubinterfaceStatus) DeepCopy() *InterfaceSubinterfaceStatus

+ func (in *InterfaceSubinterfaceStatus) DeepCopyInto(out *InterfaceSubinterfaceStatus)

+ AtNetworkNode InterfaceSubinterfaceObservation

+ type InterfaceSubinterfaceVlan struct

+ func (in *InterfaceSubinterfaceVlan) DeepCopy() *InterfaceSubinterfaceVlan

+ func (in *InterfaceSubinterfaceVlan) DeepCopyInto(out *InterfaceSubinterfaceVlan)

+ Encap *InterfaceSubinterfaceVlanEncap

+ type InterfaceSubinterfaceVlanEncap struct

+ func (in *InterfaceSubinterfaceVlanEncap) DeepCopy() *InterfaceSubinterfaceVlanEncap

+ func (in *InterfaceSubinterfaceVlanEncap) DeepCopyInto(out *InterfaceSubinterfaceVlanEncap)

+ SingleTagged *InterfaceSubinterfaceVlanEncapSingleTagged

+ Untagged *InterfaceSubinterfaceVlanEncapUntagged

+ type InterfaceSubinterfaceVlanEncapSingleTagged struct

+ func (in *InterfaceSubinterfaceVlanEncapSingleTagged) DeepCopy() *InterfaceSubinterfaceVlanEncapSingleTagged

+ func (in *InterfaceSubinterfaceVlanEncapSingleTagged) DeepCopyInto(out *InterfaceSubinterfaceVlanEncapSingleTagged)

+ VlanId *string

+ type InterfaceSubinterfaceVlanEncapUntagged struct

+ func (in *InterfaceSubinterfaceVlanEncapUntagged) DeepCopy() *InterfaceSubinterfaceVlanEncapUntagged

+ func (in *InterfaceSubinterfaceVlanEncapUntagged) DeepCopyInto(out *InterfaceSubinterfaceVlanEncapUntagged)

+ type InterfaceTransceiver struct

+ DdmEvents *bool

+ ForwardErrorCorrection *string

+ TxLaser *bool

+ func (in *InterfaceTransceiver) DeepCopy() *InterfaceTransceiver

+ func (in *InterfaceTransceiver) DeepCopyInto(out *InterfaceTransceiver)

+ type Networkinstance struct

+ AdminState *string

+ BridgeTable *NetworkinstanceBridgeTable

+ Description *string

+ Interface []*NetworkinstanceInterface

+ IpForwarding *NetworkinstanceIpForwarding

+ IpLoadBalancing *NetworkinstanceIpLoadBalancing

+ Mpls *NetworkinstanceMpls

+ Mtu *NetworkinstanceMtu

+ Name *string

+ Protocols *NetworkinstanceProtocols

+ RouterId *string

+ TrafficEngineering *NetworkinstanceTrafficEngineering

+ Type *string

+ VxlanInterface []*NetworkinstanceVxlanInterface

+ func (in *Networkinstance) DeepCopy() *Networkinstance

+ func (in *Networkinstance) DeepCopyInto(out *Networkinstance)

+ type NetworkinstanceAggregateroutes struct

+ Route []*NetworkinstanceAggregateroutesRoute

+ func (in *NetworkinstanceAggregateroutes) DeepCopy() *NetworkinstanceAggregateroutes

+ func (in *NetworkinstanceAggregateroutes) DeepCopyInto(out *NetworkinstanceAggregateroutes)

+ type NetworkinstanceAggregateroutesObservation struct

+ func (in *NetworkinstanceAggregateroutesObservation) DeepCopy() *NetworkinstanceAggregateroutesObservation

+ func (in *NetworkinstanceAggregateroutesObservation) DeepCopyInto(out *NetworkinstanceAggregateroutesObservation)

+ type NetworkinstanceAggregateroutesParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceAggregateroutes *NetworkinstanceAggregateroutes

+ func (in *NetworkinstanceAggregateroutesParameters) DeepCopy() *NetworkinstanceAggregateroutesParameters

+ func (in *NetworkinstanceAggregateroutesParameters) DeepCopyInto(out *NetworkinstanceAggregateroutesParameters)

+ type NetworkinstanceAggregateroutesRoute struct

+ AdminState *string

+ Aggregator *NetworkinstanceAggregateroutesRouteAggregator

+ Communities *NetworkinstanceAggregateroutesRouteCommunities

+ GenerateIcmp *bool

+ Prefix *string

+ SummaryOnly *bool

+ func (in *NetworkinstanceAggregateroutesRoute) DeepCopy() *NetworkinstanceAggregateroutesRoute

+ func (in *NetworkinstanceAggregateroutesRoute) DeepCopyInto(out *NetworkinstanceAggregateroutesRoute)

+ type NetworkinstanceAggregateroutesRouteAggregator struct

+ Address *string

+ AsNumber *uint32

+ func (in *NetworkinstanceAggregateroutesRouteAggregator) DeepCopy() *NetworkinstanceAggregateroutesRouteAggregator

+ func (in *NetworkinstanceAggregateroutesRouteAggregator) DeepCopyInto(out *NetworkinstanceAggregateroutesRouteAggregator)

+ type NetworkinstanceAggregateroutesRouteCommunities struct

+ Add *string

+ func (in *NetworkinstanceAggregateroutesRouteCommunities) DeepCopy() *NetworkinstanceAggregateroutesRouteCommunities

+ func (in *NetworkinstanceAggregateroutesRouteCommunities) DeepCopyInto(out *NetworkinstanceAggregateroutesRouteCommunities)

+ type NetworkinstanceAggregateroutesSpec struct

+ ForNetworkNode NetworkinstanceAggregateroutesParameters

+ func (in *NetworkinstanceAggregateroutesSpec) DeepCopy() *NetworkinstanceAggregateroutesSpec

+ func (in *NetworkinstanceAggregateroutesSpec) DeepCopyInto(out *NetworkinstanceAggregateroutesSpec)

+ type NetworkinstanceAggregateroutesStatus struct

+ AtNetworkNode NetworkinstanceAggregateroutesObservation

+ func (in *NetworkinstanceAggregateroutesStatus) DeepCopy() *NetworkinstanceAggregateroutesStatus

+ func (in *NetworkinstanceAggregateroutesStatus) DeepCopyInto(out *NetworkinstanceAggregateroutesStatus)

+ type NetworkinstanceBridgeTable struct

+ DiscardUnknownDestMac *bool

+ MacDuplication *NetworkinstanceBridgeTableMacDuplication

+ MacLearning *NetworkinstanceBridgeTableMacLearning

+ MacLimit *NetworkinstanceBridgeTableMacLimit

+ ProtectAnycastGwMac *bool

+ StaticMac *NetworkinstanceBridgeTableStaticMac

+ func (in *NetworkinstanceBridgeTable) DeepCopy() *NetworkinstanceBridgeTable

+ func (in *NetworkinstanceBridgeTable) DeepCopyInto(out *NetworkinstanceBridgeTable)

+ type NetworkinstanceBridgeTableMacDuplication struct

+ Action *string

+ AdminState *string

+ HoldDownTime *uint32

+ MonitoringWindow *uint32

+ NumMoves *uint32

+ func (in *NetworkinstanceBridgeTableMacDuplication) DeepCopy() *NetworkinstanceBridgeTableMacDuplication

+ func (in *NetworkinstanceBridgeTableMacDuplication) DeepCopyInto(out *NetworkinstanceBridgeTableMacDuplication)

+ type NetworkinstanceBridgeTableMacLearning struct

+ AdminState *string

+ Aging *NetworkinstanceBridgeTableMacLearningAging

+ func (in *NetworkinstanceBridgeTableMacLearning) DeepCopy() *NetworkinstanceBridgeTableMacLearning

+ func (in *NetworkinstanceBridgeTableMacLearning) DeepCopyInto(out *NetworkinstanceBridgeTableMacLearning)

+ type NetworkinstanceBridgeTableMacLearningAging struct

+ AdminState *string

+ AgeTime *int32

+ func (in *NetworkinstanceBridgeTableMacLearningAging) DeepCopy() *NetworkinstanceBridgeTableMacLearningAging

+ func (in *NetworkinstanceBridgeTableMacLearningAging) DeepCopyInto(out *NetworkinstanceBridgeTableMacLearningAging)

+ type NetworkinstanceBridgeTableMacLimit struct

+ MaximumEntries *int32

+ WarningThresholdPct *int32

+ func (in *NetworkinstanceBridgeTableMacLimit) DeepCopy() *NetworkinstanceBridgeTableMacLimit

+ func (in *NetworkinstanceBridgeTableMacLimit) DeepCopyInto(out *NetworkinstanceBridgeTableMacLimit)

+ type NetworkinstanceBridgeTableStaticMac struct

+ Mac []*NetworkinstanceBridgeTableStaticMacMac

+ func (in *NetworkinstanceBridgeTableStaticMac) DeepCopy() *NetworkinstanceBridgeTableStaticMac

+ func (in *NetworkinstanceBridgeTableStaticMac) DeepCopyInto(out *NetworkinstanceBridgeTableStaticMac)

+ type NetworkinstanceBridgeTableStaticMacMac struct

+ Address *string

+ Destination *string

+ func (in *NetworkinstanceBridgeTableStaticMacMac) DeepCopy() *NetworkinstanceBridgeTableStaticMacMac

+ func (in *NetworkinstanceBridgeTableStaticMacMac) DeepCopyInto(out *NetworkinstanceBridgeTableStaticMacMac)

+ type NetworkinstanceInterface struct

+ Name *string

+ func (in *NetworkinstanceInterface) DeepCopy() *NetworkinstanceInterface

+ func (in *NetworkinstanceInterface) DeepCopyInto(out *NetworkinstanceInterface)

+ type NetworkinstanceIpForwarding struct

+ ReceiveIpv4Check *bool

+ ReceiveIpv6Check *bool

+ func (in *NetworkinstanceIpForwarding) DeepCopy() *NetworkinstanceIpForwarding

+ func (in *NetworkinstanceIpForwarding) DeepCopyInto(out *NetworkinstanceIpForwarding)

+ type NetworkinstanceIpLoadBalancing struct

+ ResilientHashPrefix []*NetworkinstanceIpLoadBalancingResilientHashPrefix

+ func (in *NetworkinstanceIpLoadBalancing) DeepCopy() *NetworkinstanceIpLoadBalancing

+ func (in *NetworkinstanceIpLoadBalancing) DeepCopyInto(out *NetworkinstanceIpLoadBalancing)

+ type NetworkinstanceIpLoadBalancingResilientHashPrefix struct

+ HashBucketsPerPath *uint8

+ IpPrefix *string

+ MaxPaths *uint8

+ func (in *NetworkinstanceIpLoadBalancingResilientHashPrefix) DeepCopy() *NetworkinstanceIpLoadBalancingResilientHashPrefix

+ func (in *NetworkinstanceIpLoadBalancingResilientHashPrefix) DeepCopyInto(out *NetworkinstanceIpLoadBalancingResilientHashPrefix)

+ type NetworkinstanceMpls struct

+ AdminState *string

+ StaticMplsEntry []*NetworkinstanceMplsStaticMplsEntry

+ TtlPropagation *bool

+ func (in *NetworkinstanceMpls) DeepCopy() *NetworkinstanceMpls

+ func (in *NetworkinstanceMpls) DeepCopyInto(out *NetworkinstanceMpls)

+ type NetworkinstanceMplsStaticMplsEntry struct

+ CollectStats *bool

+ NextHopGroup *string

+ Operation *string

+ Preference *uint8

+ TopLabel *string

+ func (in *NetworkinstanceMplsStaticMplsEntry) DeepCopy() *NetworkinstanceMplsStaticMplsEntry

+ func (in *NetworkinstanceMplsStaticMplsEntry) DeepCopyInto(out *NetworkinstanceMplsStaticMplsEntry)

+ type NetworkinstanceMtu struct

+ PathMtuDiscovery *bool

+ func (in *NetworkinstanceMtu) DeepCopy() *NetworkinstanceMtu

+ func (in *NetworkinstanceMtu) DeepCopyInto(out *NetworkinstanceMtu)

+ type NetworkinstanceNexthopgroups struct

+ Group []*NetworkinstanceNexthopgroupsGroup

+ func (in *NetworkinstanceNexthopgroups) DeepCopy() *NetworkinstanceNexthopgroups

+ func (in *NetworkinstanceNexthopgroups) DeepCopyInto(out *NetworkinstanceNexthopgroups)

+ type NetworkinstanceNexthopgroupsGroup struct

+ AdminState *string

+ Blackhole *NetworkinstanceNexthopgroupsGroupBlackhole

+ Name *string

+ Nexthop []*NetworkinstanceNexthopgroupsGroupNexthop

+ func (in *NetworkinstanceNexthopgroupsGroup) DeepCopy() *NetworkinstanceNexthopgroupsGroup

+ func (in *NetworkinstanceNexthopgroupsGroup) DeepCopyInto(out *NetworkinstanceNexthopgroupsGroup)

+ type NetworkinstanceNexthopgroupsGroupBlackhole struct

+ GenerateIcmp *bool

+ func (in *NetworkinstanceNexthopgroupsGroupBlackhole) DeepCopy() *NetworkinstanceNexthopgroupsGroupBlackhole

+ func (in *NetworkinstanceNexthopgroupsGroupBlackhole) DeepCopyInto(out *NetworkinstanceNexthopgroupsGroupBlackhole)

+ type NetworkinstanceNexthopgroupsGroupNexthop struct

+ AdminState *string

+ FailureDetection *NetworkinstanceNexthopgroupsGroupNexthopFailureDetection

+ Index *uint16

+ IpAddress *string

+ PushedMplsLabelStack *string

+ Resolve *bool

+ func (in *NetworkinstanceNexthopgroupsGroupNexthop) DeepCopy() *NetworkinstanceNexthopgroupsGroupNexthop

+ func (in *NetworkinstanceNexthopgroupsGroupNexthop) DeepCopyInto(out *NetworkinstanceNexthopgroupsGroupNexthop)

+ type NetworkinstanceNexthopgroupsGroupNexthopFailureDetection struct

+ EnableBfd *NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd

+ func (in *NetworkinstanceNexthopgroupsGroupNexthopFailureDetection) DeepCopy() *NetworkinstanceNexthopgroupsGroupNexthopFailureDetection

+ func (in *NetworkinstanceNexthopgroupsGroupNexthopFailureDetection) DeepCopyInto(out *NetworkinstanceNexthopgroupsGroupNexthopFailureDetection)

+ type NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd struct

+ LocalAddress *string

+ LocalDiscriminator *uint32

+ RemoteDiscriminator *uint32

+ func (in *NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd) DeepCopy() *NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd

+ func (in *NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd) DeepCopyInto(out *NetworkinstanceNexthopgroupsGroupNexthopFailureDetectionEnableBfd)

+ type NetworkinstanceNexthopgroupsObservation struct

+ func (in *NetworkinstanceNexthopgroupsObservation) DeepCopy() *NetworkinstanceNexthopgroupsObservation

+ func (in *NetworkinstanceNexthopgroupsObservation) DeepCopyInto(out *NetworkinstanceNexthopgroupsObservation)

+ type NetworkinstanceNexthopgroupsParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceNexthopgroups *NetworkinstanceNexthopgroups

+ func (in *NetworkinstanceNexthopgroupsParameters) DeepCopy() *NetworkinstanceNexthopgroupsParameters

+ func (in *NetworkinstanceNexthopgroupsParameters) DeepCopyInto(out *NetworkinstanceNexthopgroupsParameters)

+ type NetworkinstanceNexthopgroupsSpec struct

+ ForNetworkNode NetworkinstanceNexthopgroupsParameters

+ func (in *NetworkinstanceNexthopgroupsSpec) DeepCopy() *NetworkinstanceNexthopgroupsSpec

+ func (in *NetworkinstanceNexthopgroupsSpec) DeepCopyInto(out *NetworkinstanceNexthopgroupsSpec)

+ type NetworkinstanceNexthopgroupsStatus struct

+ AtNetworkNode NetworkinstanceNexthopgroupsObservation

+ func (in *NetworkinstanceNexthopgroupsStatus) DeepCopy() *NetworkinstanceNexthopgroupsStatus

+ func (in *NetworkinstanceNexthopgroupsStatus) DeepCopyInto(out *NetworkinstanceNexthopgroupsStatus)

+ type NetworkinstanceObservation struct

+ func (in *NetworkinstanceObservation) DeepCopy() *NetworkinstanceObservation

+ func (in *NetworkinstanceObservation) DeepCopyInto(out *NetworkinstanceObservation)

+ type NetworkinstanceParameters struct

+ SrlNetworkinstance *Networkinstance

+ func (in *NetworkinstanceParameters) DeepCopy() *NetworkinstanceParameters

+ func (in *NetworkinstanceParameters) DeepCopyInto(out *NetworkinstanceParameters)

+ type NetworkinstanceProtocols struct

+ DirectlyConnected *NetworkinstanceProtocolsDirectlyConnected

+ Ldp *NetworkinstanceProtocolsLdp

+ func (in *NetworkinstanceProtocols) DeepCopy() *NetworkinstanceProtocols

+ func (in *NetworkinstanceProtocols) DeepCopyInto(out *NetworkinstanceProtocols)

+ type NetworkinstanceProtocolsBgp struct

+ AdminState *string

+ AsPathOptions *NetworkinstanceProtocolsBgpAsPathOptions

+ Authentication *NetworkinstanceProtocolsBgpAuthentication

+ AutonomousSystem *uint32

+ Convergence *NetworkinstanceProtocolsBgpConvergence

+ DynamicNeighbors *NetworkinstanceProtocolsBgpDynamicNeighbors

+ EbgpDefaultPolicy *NetworkinstanceProtocolsBgpEbgpDefaultPolicy

+ Evpn *NetworkinstanceProtocolsBgpEvpn

+ ExportPolicy *string

+ FailureDetection *NetworkinstanceProtocolsBgpFailureDetection

+ GracefulRestart *NetworkinstanceProtocolsBgpGracefulRestart

+ Group []*NetworkinstanceProtocolsBgpGroup

+ ImportPolicy *string

+ Ipv4Unicast *NetworkinstanceProtocolsBgpIpv4Unicast

+ Ipv6Unicast *NetworkinstanceProtocolsBgpIpv6Unicast

+ LocalPreference *uint32

+ Neighbor []*NetworkinstanceProtocolsBgpNeighbor

+ Preference *NetworkinstanceProtocolsBgpPreference

+ RouteAdvertisement *NetworkinstanceProtocolsBgpRouteAdvertisement

+ RouteReflector *NetworkinstanceProtocolsBgpRouteReflector

+ RouterId *string

+ SendCommunity *NetworkinstanceProtocolsBgpSendCommunity

+ TraceOptions *NetworkinstanceProtocolsBgpTraceOptions

+ Transport *NetworkinstanceProtocolsBgpTransport

+ func (in *NetworkinstanceProtocolsBgp) DeepCopy() *NetworkinstanceProtocolsBgp

+ func (in *NetworkinstanceProtocolsBgp) DeepCopyInto(out *NetworkinstanceProtocolsBgp)

+ type NetworkinstanceProtocolsBgpAsPathOptions struct

+ AllowOwnAs *uint8

+ RemovePrivateAs *NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs

+ func (in *NetworkinstanceProtocolsBgpAsPathOptions) DeepCopy() *NetworkinstanceProtocolsBgpAsPathOptions

+ func (in *NetworkinstanceProtocolsBgpAsPathOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpAsPathOptions)

+ type NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs struct

+ IgnorePeerAs *bool

+ LeadingOnly *bool

+ Mode *string

+ func (in *NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs) DeepCopy() *NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs

+ func (in *NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs) DeepCopyInto(out *NetworkinstanceProtocolsBgpAsPathOptionsRemovePrivateAs)

+ type NetworkinstanceProtocolsBgpAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsBgpAuthentication) DeepCopy() *NetworkinstanceProtocolsBgpAuthentication

+ func (in *NetworkinstanceProtocolsBgpAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsBgpAuthentication)

+ type NetworkinstanceProtocolsBgpConvergence struct

+ MinWaitToAdvertise *uint16

+ func (in *NetworkinstanceProtocolsBgpConvergence) DeepCopy() *NetworkinstanceProtocolsBgpConvergence

+ func (in *NetworkinstanceProtocolsBgpConvergence) DeepCopyInto(out *NetworkinstanceProtocolsBgpConvergence)

+ type NetworkinstanceProtocolsBgpDynamicNeighbors struct

+ Accept *NetworkinstanceProtocolsBgpDynamicNeighborsAccept

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighbors) DeepCopy() *NetworkinstanceProtocolsBgpDynamicNeighbors

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighbors) DeepCopyInto(out *NetworkinstanceProtocolsBgpDynamicNeighbors)

+ type NetworkinstanceProtocolsBgpDynamicNeighborsAccept struct

+ Match []*NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch

+ MaxSessions *uint16

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighborsAccept) DeepCopy() *NetworkinstanceProtocolsBgpDynamicNeighborsAccept

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighborsAccept) DeepCopyInto(out *NetworkinstanceProtocolsBgpDynamicNeighborsAccept)

+ type NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch struct

+ AllowedPeerAs *string

+ PeerGroup *string

+ Prefix *string

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch) DeepCopy() *NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch

+ func (in *NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch) DeepCopyInto(out *NetworkinstanceProtocolsBgpDynamicNeighborsAcceptMatch)

+ type NetworkinstanceProtocolsBgpEbgpDefaultPolicy struct

+ ExportRejectAll *bool

+ ImportRejectAll *bool

+ func (in *NetworkinstanceProtocolsBgpEbgpDefaultPolicy) DeepCopy() *NetworkinstanceProtocolsBgpEbgpDefaultPolicy

+ func (in *NetworkinstanceProtocolsBgpEbgpDefaultPolicy) DeepCopyInto(out *NetworkinstanceProtocolsBgpEbgpDefaultPolicy)

+ type NetworkinstanceProtocolsBgpEvpn struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ KeepAllRoutes *bool

+ Multipath *NetworkinstanceProtocolsBgpEvpnMultipath

+ RapidUpdate *bool

+ func (in *NetworkinstanceProtocolsBgpEvpn) DeepCopy() *NetworkinstanceProtocolsBgpEvpn

+ func (in *NetworkinstanceProtocolsBgpEvpn) DeepCopyInto(out *NetworkinstanceProtocolsBgpEvpn)

+ type NetworkinstanceProtocolsBgpEvpnMultipath struct

+ AllowMultipleAs *bool

+ MaxPathsLevel1 *uint32

+ MaxPathsLevel2 *uint32

+ func (in *NetworkinstanceProtocolsBgpEvpnMultipath) DeepCopy() *NetworkinstanceProtocolsBgpEvpnMultipath

+ func (in *NetworkinstanceProtocolsBgpEvpnMultipath) DeepCopyInto(out *NetworkinstanceProtocolsBgpEvpnMultipath)

+ type NetworkinstanceProtocolsBgpFailureDetection struct

+ EnableBfd *bool

+ FastFailover *bool

+ func (in *NetworkinstanceProtocolsBgpFailureDetection) DeepCopy() *NetworkinstanceProtocolsBgpFailureDetection

+ func (in *NetworkinstanceProtocolsBgpFailureDetection) DeepCopyInto(out *NetworkinstanceProtocolsBgpFailureDetection)

+ type NetworkinstanceProtocolsBgpGracefulRestart struct

+ AdminState *string

+ StaleRoutesTime *uint16

+ func (in *NetworkinstanceProtocolsBgpGracefulRestart) DeepCopy() *NetworkinstanceProtocolsBgpGracefulRestart

+ func (in *NetworkinstanceProtocolsBgpGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsBgpGracefulRestart)

+ type NetworkinstanceProtocolsBgpGroup struct

+ AdminState *string

+ AsPathOptions *NetworkinstanceProtocolsBgpGroupAsPathOptions

+ Authentication *NetworkinstanceProtocolsBgpGroupAuthentication

+ Description *string

+ Evpn *NetworkinstanceProtocolsBgpGroupEvpn

+ ExportPolicy *string

+ FailureDetection *NetworkinstanceProtocolsBgpGroupFailureDetection

+ GracefulRestart *NetworkinstanceProtocolsBgpGroupGracefulRestart

+ GroupName *string

+ ImportPolicy *string

+ Ipv4Unicast *NetworkinstanceProtocolsBgpGroupIpv4Unicast

+ Ipv6Unicast *NetworkinstanceProtocolsBgpGroupIpv6Unicast

+ LocalAs []*NetworkinstanceProtocolsBgpGroupLocalAs

+ LocalPreference *uint32

+ NextHopSelf *bool

+ PeerAs *uint32

+ RouteReflector *NetworkinstanceProtocolsBgpGroupRouteReflector

+ SendCommunity *NetworkinstanceProtocolsBgpGroupSendCommunity

+ SendDefaultRoute *NetworkinstanceProtocolsBgpGroupSendDefaultRoute

+ Timers *NetworkinstanceProtocolsBgpGroupTimers

+ TraceOptions *NetworkinstanceProtocolsBgpGroupTraceOptions

+ Transport *NetworkinstanceProtocolsBgpGroupTransport

+ func (in *NetworkinstanceProtocolsBgpGroup) DeepCopy() *NetworkinstanceProtocolsBgpGroup

+ func (in *NetworkinstanceProtocolsBgpGroup) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroup)

+ type NetworkinstanceProtocolsBgpGroupAsPathOptions struct

+ AllowOwnAs *uint8

+ RemovePrivateAs *NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs

+ ReplacePeerAs *bool

+ func (in *NetworkinstanceProtocolsBgpGroupAsPathOptions) DeepCopy() *NetworkinstanceProtocolsBgpGroupAsPathOptions

+ func (in *NetworkinstanceProtocolsBgpGroupAsPathOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupAsPathOptions)

+ type NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs struct

+ IgnorePeerAs *bool

+ LeadingOnly *bool

+ Mode *string

+ func (in *NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs) DeepCopy() *NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs

+ func (in *NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupAsPathOptionsRemovePrivateAs)

+ type NetworkinstanceProtocolsBgpGroupAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsBgpGroupAuthentication) DeepCopy() *NetworkinstanceProtocolsBgpGroupAuthentication

+ func (in *NetworkinstanceProtocolsBgpGroupAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupAuthentication)

+ type NetworkinstanceProtocolsBgpGroupEvpn struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ PrefixLimit *NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpGroupEvpn) DeepCopy() *NetworkinstanceProtocolsBgpGroupEvpn

+ func (in *NetworkinstanceProtocolsBgpGroupEvpn) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupEvpn)

+ type NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupEvpnPrefixLimit)

+ type NetworkinstanceProtocolsBgpGroupFailureDetection struct

+ EnableBfd *bool

+ FastFailover *bool

+ func (in *NetworkinstanceProtocolsBgpGroupFailureDetection) DeepCopy() *NetworkinstanceProtocolsBgpGroupFailureDetection

+ func (in *NetworkinstanceProtocolsBgpGroupFailureDetection) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupFailureDetection)

+ type NetworkinstanceProtocolsBgpGroupGracefulRestart struct

+ AdminState *string

+ StaleRoutesTime *uint16

+ func (in *NetworkinstanceProtocolsBgpGroupGracefulRestart) DeepCopy() *NetworkinstanceProtocolsBgpGroupGracefulRestart

+ func (in *NetworkinstanceProtocolsBgpGroupGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupGracefulRestart)

+ type NetworkinstanceProtocolsBgpGroupIpv4Unicast struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ PrefixLimit *NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit

+ ReceiveIpv6NextHops *bool

+ func (in *NetworkinstanceProtocolsBgpGroupIpv4Unicast) DeepCopy() *NetworkinstanceProtocolsBgpGroupIpv4Unicast

+ func (in *NetworkinstanceProtocolsBgpGroupIpv4Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupIpv4Unicast)

+ type NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupIpv4UnicastPrefixLimit)

+ type NetworkinstanceProtocolsBgpGroupIpv6Unicast struct

+ AdminState *string

+ PrefixLimit *NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpGroupIpv6Unicast) DeepCopy() *NetworkinstanceProtocolsBgpGroupIpv6Unicast

+ func (in *NetworkinstanceProtocolsBgpGroupIpv6Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupIpv6Unicast)

+ type NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupIpv6UnicastPrefixLimit)

+ type NetworkinstanceProtocolsBgpGroupLocalAs struct

+ AsNumber *uint32

+ PrependGlobalAs *bool

+ PrependLocalAs *bool

+ func (in *NetworkinstanceProtocolsBgpGroupLocalAs) DeepCopy() *NetworkinstanceProtocolsBgpGroupLocalAs

+ func (in *NetworkinstanceProtocolsBgpGroupLocalAs) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupLocalAs)

+ type NetworkinstanceProtocolsBgpGroupRouteReflector struct

+ Client *bool

+ ClusterId *string

+ func (in *NetworkinstanceProtocolsBgpGroupRouteReflector) DeepCopy() *NetworkinstanceProtocolsBgpGroupRouteReflector

+ func (in *NetworkinstanceProtocolsBgpGroupRouteReflector) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupRouteReflector)

+ type NetworkinstanceProtocolsBgpGroupSendCommunity struct

+ Large *bool

+ Standard *bool

+ func (in *NetworkinstanceProtocolsBgpGroupSendCommunity) DeepCopy() *NetworkinstanceProtocolsBgpGroupSendCommunity

+ func (in *NetworkinstanceProtocolsBgpGroupSendCommunity) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupSendCommunity)

+ type NetworkinstanceProtocolsBgpGroupSendDefaultRoute struct

+ ExportPolicy *string

+ Ipv4Unicast *bool

+ Ipv6Unicast *bool

+ func (in *NetworkinstanceProtocolsBgpGroupSendDefaultRoute) DeepCopy() *NetworkinstanceProtocolsBgpGroupSendDefaultRoute

+ func (in *NetworkinstanceProtocolsBgpGroupSendDefaultRoute) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupSendDefaultRoute)

+ type NetworkinstanceProtocolsBgpGroupTimers struct

+ ConnectRetry *uint16

+ HoldTime *uint16

+ KeepaliveInterval *uint16

+ MinimumAdvertisementInterval *uint16

+ func (in *NetworkinstanceProtocolsBgpGroupTimers) DeepCopy() *NetworkinstanceProtocolsBgpGroupTimers

+ func (in *NetworkinstanceProtocolsBgpGroupTimers) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupTimers)

+ type NetworkinstanceProtocolsBgpGroupTraceOptions struct

+ Flag []*NetworkinstanceProtocolsBgpGroupTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpGroupTraceOptions) DeepCopy() *NetworkinstanceProtocolsBgpGroupTraceOptions

+ func (in *NetworkinstanceProtocolsBgpGroupTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupTraceOptions)

+ type NetworkinstanceProtocolsBgpGroupTraceOptionsFlag struct

+ Modifier *string

+ Name *string

+ func (in *NetworkinstanceProtocolsBgpGroupTraceOptionsFlag) DeepCopy() *NetworkinstanceProtocolsBgpGroupTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpGroupTraceOptionsFlag) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupTraceOptionsFlag)

+ type NetworkinstanceProtocolsBgpGroupTransport struct

+ LocalAddress *string

+ PassiveMode *bool

+ TcpMss *uint16

+ func (in *NetworkinstanceProtocolsBgpGroupTransport) DeepCopy() *NetworkinstanceProtocolsBgpGroupTransport

+ func (in *NetworkinstanceProtocolsBgpGroupTransport) DeepCopyInto(out *NetworkinstanceProtocolsBgpGroupTransport)

+ type NetworkinstanceProtocolsBgpIpv4Unicast struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ Convergence *NetworkinstanceProtocolsBgpIpv4UnicastConvergence

+ Multipath *NetworkinstanceProtocolsBgpIpv4UnicastMultipath

+ ReceiveIpv6NextHops *bool

+ func (in *NetworkinstanceProtocolsBgpIpv4Unicast) DeepCopy() *NetworkinstanceProtocolsBgpIpv4Unicast

+ func (in *NetworkinstanceProtocolsBgpIpv4Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv4Unicast)

+ type NetworkinstanceProtocolsBgpIpv4UnicastConvergence struct

+ MaxWaitToAdvertise *uint16

+ func (in *NetworkinstanceProtocolsBgpIpv4UnicastConvergence) DeepCopy() *NetworkinstanceProtocolsBgpIpv4UnicastConvergence

+ func (in *NetworkinstanceProtocolsBgpIpv4UnicastConvergence) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv4UnicastConvergence)

+ type NetworkinstanceProtocolsBgpIpv4UnicastMultipath struct

+ AllowMultipleAs *bool

+ MaxPathsLevel1 *uint32

+ MaxPathsLevel2 *uint32

+ func (in *NetworkinstanceProtocolsBgpIpv4UnicastMultipath) DeepCopy() *NetworkinstanceProtocolsBgpIpv4UnicastMultipath

+ func (in *NetworkinstanceProtocolsBgpIpv4UnicastMultipath) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv4UnicastMultipath)

+ type NetworkinstanceProtocolsBgpIpv6Unicast struct

+ AdminState *string

+ Convergence *NetworkinstanceProtocolsBgpIpv6UnicastConvergence

+ Multipath *NetworkinstanceProtocolsBgpIpv6UnicastMultipath

+ func (in *NetworkinstanceProtocolsBgpIpv6Unicast) DeepCopy() *NetworkinstanceProtocolsBgpIpv6Unicast

+ func (in *NetworkinstanceProtocolsBgpIpv6Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv6Unicast)

+ type NetworkinstanceProtocolsBgpIpv6UnicastConvergence struct

+ MaxWaitToAdvertise *uint16

+ func (in *NetworkinstanceProtocolsBgpIpv6UnicastConvergence) DeepCopy() *NetworkinstanceProtocolsBgpIpv6UnicastConvergence

+ func (in *NetworkinstanceProtocolsBgpIpv6UnicastConvergence) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv6UnicastConvergence)

+ type NetworkinstanceProtocolsBgpIpv6UnicastMultipath struct

+ AllowMultipleAs *bool

+ MaxPathsLevel1 *uint32

+ MaxPathsLevel2 *uint32

+ func (in *NetworkinstanceProtocolsBgpIpv6UnicastMultipath) DeepCopy() *NetworkinstanceProtocolsBgpIpv6UnicastMultipath

+ func (in *NetworkinstanceProtocolsBgpIpv6UnicastMultipath) DeepCopyInto(out *NetworkinstanceProtocolsBgpIpv6UnicastMultipath)

+ type NetworkinstanceProtocolsBgpNeighbor struct

+ AdminState *string

+ AsPathOptions *NetworkinstanceProtocolsBgpNeighborAsPathOptions

+ Authentication *NetworkinstanceProtocolsBgpNeighborAuthentication

+ Description *string

+ Evpn *NetworkinstanceProtocolsBgpNeighborEvpn

+ ExportPolicy *string

+ FailureDetection *NetworkinstanceProtocolsBgpNeighborFailureDetection

+ GracefulRestart *NetworkinstanceProtocolsBgpNeighborGracefulRestart

+ ImportPolicy *string

+ Ipv4Unicast *NetworkinstanceProtocolsBgpNeighborIpv4Unicast

+ Ipv6Unicast *NetworkinstanceProtocolsBgpNeighborIpv6Unicast

+ LocalAs []*NetworkinstanceProtocolsBgpNeighborLocalAs

+ LocalPreference *uint32

+ NextHopSelf *bool

+ PeerAddress *string

+ PeerAs *uint32

+ PeerGroup *string

+ RouteReflector *NetworkinstanceProtocolsBgpNeighborRouteReflector

+ SendCommunity *NetworkinstanceProtocolsBgpNeighborSendCommunity

+ SendDefaultRoute *NetworkinstanceProtocolsBgpNeighborSendDefaultRoute

+ Timers *NetworkinstanceProtocolsBgpNeighborTimers

+ TraceOptions *NetworkinstanceProtocolsBgpNeighborTraceOptions

+ Transport *NetworkinstanceProtocolsBgpNeighborTransport

+ func (in *NetworkinstanceProtocolsBgpNeighbor) DeepCopy() *NetworkinstanceProtocolsBgpNeighbor

+ func (in *NetworkinstanceProtocolsBgpNeighbor) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighbor)

+ type NetworkinstanceProtocolsBgpNeighborAsPathOptions struct

+ AllowOwnAs *uint8

+ RemovePrivateAs *NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs

+ ReplacePeerAs *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborAsPathOptions) DeepCopy() *NetworkinstanceProtocolsBgpNeighborAsPathOptions

+ func (in *NetworkinstanceProtocolsBgpNeighborAsPathOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborAsPathOptions)

+ type NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs struct

+ IgnorePeerAs *bool

+ LeadingOnly *bool

+ Mode *string

+ func (in *NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs) DeepCopy() *NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs

+ func (in *NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborAsPathOptionsRemovePrivateAs)

+ type NetworkinstanceProtocolsBgpNeighborAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsBgpNeighborAuthentication) DeepCopy() *NetworkinstanceProtocolsBgpNeighborAuthentication

+ func (in *NetworkinstanceProtocolsBgpNeighborAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborAuthentication)

+ type NetworkinstanceProtocolsBgpNeighborEvpn struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ PrefixLimit *NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpNeighborEvpn) DeepCopy() *NetworkinstanceProtocolsBgpNeighborEvpn

+ func (in *NetworkinstanceProtocolsBgpNeighborEvpn) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborEvpn)

+ type NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborEvpnPrefixLimit)

+ type NetworkinstanceProtocolsBgpNeighborFailureDetection struct

+ EnableBfd *bool

+ FastFailover *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborFailureDetection) DeepCopy() *NetworkinstanceProtocolsBgpNeighborFailureDetection

+ func (in *NetworkinstanceProtocolsBgpNeighborFailureDetection) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborFailureDetection)

+ type NetworkinstanceProtocolsBgpNeighborGracefulRestart struct

+ AdminState *string

+ StaleRoutesTime *uint16

+ WarmRestart *NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart

+ func (in *NetworkinstanceProtocolsBgpNeighborGracefulRestart) DeepCopy() *NetworkinstanceProtocolsBgpNeighborGracefulRestart

+ func (in *NetworkinstanceProtocolsBgpNeighborGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborGracefulRestart)

+ type NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart struct

+ AdminState *string

+ func (in *NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart) DeepCopy() *NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart

+ func (in *NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborGracefulRestartWarmRestart)

+ type NetworkinstanceProtocolsBgpNeighborIpv4Unicast struct

+ AdminState *string

+ AdvertiseIpv6NextHops *bool

+ PrefixLimit *NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit

+ ReceiveIpv6NextHops *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv4Unicast) DeepCopy() *NetworkinstanceProtocolsBgpNeighborIpv4Unicast

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv4Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborIpv4Unicast)

+ type NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborIpv4UnicastPrefixLimit)

+ type NetworkinstanceProtocolsBgpNeighborIpv6Unicast struct

+ AdminState *string

+ PrefixLimit *NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv6Unicast) DeepCopy() *NetworkinstanceProtocolsBgpNeighborIpv6Unicast

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv6Unicast) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborIpv6Unicast)

+ type NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit struct

+ MaxReceivedRoutes *uint32

+ WarningThresholdPct *uint8

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit) DeepCopy() *NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit

+ func (in *NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborIpv6UnicastPrefixLimit)

+ type NetworkinstanceProtocolsBgpNeighborLocalAs struct

+ AsNumber *uint32

+ PrependGlobalAs *bool

+ PrependLocalAs *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborLocalAs) DeepCopy() *NetworkinstanceProtocolsBgpNeighborLocalAs

+ func (in *NetworkinstanceProtocolsBgpNeighborLocalAs) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborLocalAs)

+ type NetworkinstanceProtocolsBgpNeighborRouteReflector struct

+ Client *bool

+ ClusterId *string

+ func (in *NetworkinstanceProtocolsBgpNeighborRouteReflector) DeepCopy() *NetworkinstanceProtocolsBgpNeighborRouteReflector

+ func (in *NetworkinstanceProtocolsBgpNeighborRouteReflector) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborRouteReflector)

+ type NetworkinstanceProtocolsBgpNeighborSendCommunity struct

+ Large *bool

+ Standard *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborSendCommunity) DeepCopy() *NetworkinstanceProtocolsBgpNeighborSendCommunity

+ func (in *NetworkinstanceProtocolsBgpNeighborSendCommunity) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborSendCommunity)

+ type NetworkinstanceProtocolsBgpNeighborSendDefaultRoute struct

+ ExportPolicy *string

+ Ipv4Unicast *bool

+ Ipv6Unicast *bool

+ func (in *NetworkinstanceProtocolsBgpNeighborSendDefaultRoute) DeepCopy() *NetworkinstanceProtocolsBgpNeighborSendDefaultRoute

+ func (in *NetworkinstanceProtocolsBgpNeighborSendDefaultRoute) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborSendDefaultRoute)

+ type NetworkinstanceProtocolsBgpNeighborTimers struct

+ ConnectRetry *uint16

+ HoldTime *uint16

+ KeepaliveInterval *uint16

+ MinimumAdvertisementInterval *uint16

+ func (in *NetworkinstanceProtocolsBgpNeighborTimers) DeepCopy() *NetworkinstanceProtocolsBgpNeighborTimers

+ func (in *NetworkinstanceProtocolsBgpNeighborTimers) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborTimers)

+ type NetworkinstanceProtocolsBgpNeighborTraceOptions struct

+ Flag []*NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpNeighborTraceOptions) DeepCopy() *NetworkinstanceProtocolsBgpNeighborTraceOptions

+ func (in *NetworkinstanceProtocolsBgpNeighborTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborTraceOptions)

+ type NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag struct

+ Modifier *string

+ Name *string

+ func (in *NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag) DeepCopy() *NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborTraceOptionsFlag)

+ type NetworkinstanceProtocolsBgpNeighborTransport struct

+ LocalAddress *string

+ PassiveMode *bool

+ TcpMss *uint16

+ func (in *NetworkinstanceProtocolsBgpNeighborTransport) DeepCopy() *NetworkinstanceProtocolsBgpNeighborTransport

+ func (in *NetworkinstanceProtocolsBgpNeighborTransport) DeepCopyInto(out *NetworkinstanceProtocolsBgpNeighborTransport)

+ type NetworkinstanceProtocolsBgpObservation struct

+ func (in *NetworkinstanceProtocolsBgpObservation) DeepCopy() *NetworkinstanceProtocolsBgpObservation

+ func (in *NetworkinstanceProtocolsBgpObservation) DeepCopyInto(out *NetworkinstanceProtocolsBgpObservation)

+ type NetworkinstanceProtocolsBgpParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsBgp *NetworkinstanceProtocolsBgp

+ func (in *NetworkinstanceProtocolsBgpParameters) DeepCopy() *NetworkinstanceProtocolsBgpParameters

+ func (in *NetworkinstanceProtocolsBgpParameters) DeepCopyInto(out *NetworkinstanceProtocolsBgpParameters)

+ type NetworkinstanceProtocolsBgpPreference struct

+ Ebgp *uint8

+ Ibgp *uint8

+ func (in *NetworkinstanceProtocolsBgpPreference) DeepCopy() *NetworkinstanceProtocolsBgpPreference

+ func (in *NetworkinstanceProtocolsBgpPreference) DeepCopyInto(out *NetworkinstanceProtocolsBgpPreference)

+ type NetworkinstanceProtocolsBgpRouteAdvertisement struct

+ RapidWithdrawal *bool

+ WaitForFibInstall *bool

+ func (in *NetworkinstanceProtocolsBgpRouteAdvertisement) DeepCopy() *NetworkinstanceProtocolsBgpRouteAdvertisement

+ func (in *NetworkinstanceProtocolsBgpRouteAdvertisement) DeepCopyInto(out *NetworkinstanceProtocolsBgpRouteAdvertisement)

+ type NetworkinstanceProtocolsBgpRouteReflector struct

+ Client *bool

+ ClusterId *string

+ func (in *NetworkinstanceProtocolsBgpRouteReflector) DeepCopy() *NetworkinstanceProtocolsBgpRouteReflector

+ func (in *NetworkinstanceProtocolsBgpRouteReflector) DeepCopyInto(out *NetworkinstanceProtocolsBgpRouteReflector)

+ type NetworkinstanceProtocolsBgpSendCommunity struct

+ Large *bool

+ Standard *bool

+ func (in *NetworkinstanceProtocolsBgpSendCommunity) DeepCopy() *NetworkinstanceProtocolsBgpSendCommunity

+ func (in *NetworkinstanceProtocolsBgpSendCommunity) DeepCopyInto(out *NetworkinstanceProtocolsBgpSendCommunity)

+ type NetworkinstanceProtocolsBgpSpec struct

+ ForNetworkNode NetworkinstanceProtocolsBgpParameters

+ func (in *NetworkinstanceProtocolsBgpSpec) DeepCopy() *NetworkinstanceProtocolsBgpSpec

+ func (in *NetworkinstanceProtocolsBgpSpec) DeepCopyInto(out *NetworkinstanceProtocolsBgpSpec)

+ type NetworkinstanceProtocolsBgpStatus struct

+ AtNetworkNode NetworkinstanceProtocolsBgpObservation

+ func (in *NetworkinstanceProtocolsBgpStatus) DeepCopy() *NetworkinstanceProtocolsBgpStatus

+ func (in *NetworkinstanceProtocolsBgpStatus) DeepCopyInto(out *NetworkinstanceProtocolsBgpStatus)

+ type NetworkinstanceProtocolsBgpTraceOptions struct

+ Flag []*NetworkinstanceProtocolsBgpTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpTraceOptions) DeepCopy() *NetworkinstanceProtocolsBgpTraceOptions

+ func (in *NetworkinstanceProtocolsBgpTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsBgpTraceOptions)

+ type NetworkinstanceProtocolsBgpTraceOptionsFlag struct

+ Modifier *string

+ Name *string

+ func (in *NetworkinstanceProtocolsBgpTraceOptionsFlag) DeepCopy() *NetworkinstanceProtocolsBgpTraceOptionsFlag

+ func (in *NetworkinstanceProtocolsBgpTraceOptionsFlag) DeepCopyInto(out *NetworkinstanceProtocolsBgpTraceOptionsFlag)

+ type NetworkinstanceProtocolsBgpTransport struct

+ TcpMss *uint16

+ func (in *NetworkinstanceProtocolsBgpTransport) DeepCopy() *NetworkinstanceProtocolsBgpTransport

+ func (in *NetworkinstanceProtocolsBgpTransport) DeepCopyInto(out *NetworkinstanceProtocolsBgpTransport)

+ type NetworkinstanceProtocolsBgpevpn struct

+ BgpInstance []*NetworkinstanceProtocolsBgpevpnBgpInstance

+ func (in *NetworkinstanceProtocolsBgpevpn) DeepCopy() *NetworkinstanceProtocolsBgpevpn

+ func (in *NetworkinstanceProtocolsBgpevpn) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpn)

+ type NetworkinstanceProtocolsBgpevpnBgpInstance struct

+ AdminState *string

+ DefaultAdminTag *uint32

+ Ecmp *uint8

+ EncapsulationType *string

+ Evi *uint32

+ Id *string

+ Routes *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes

+ VxlanInterface *string

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstance) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstance

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstance) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstance)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes struct

+ BridgeTable *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable

+ RouteTable *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutes)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable struct

+ InclusiveMcast *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast

+ MacIp *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp

+ NextHop *string

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTable)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast struct

+ Advertise *bool

+ OriginatingIp *string

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableInclusiveMcast)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp struct

+ Advertise *bool

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesBridgeTableMacIp)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable struct

+ MacIp *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTable)

+ type NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp struct

+ AdvertiseGatewayMac *bool

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp) DeepCopy() *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp

+ func (in *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnBgpInstanceRoutesRouteTableMacIp)

+ type NetworkinstanceProtocolsBgpevpnObservation struct

+ func (in *NetworkinstanceProtocolsBgpevpnObservation) DeepCopy() *NetworkinstanceProtocolsBgpevpnObservation

+ func (in *NetworkinstanceProtocolsBgpevpnObservation) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnObservation)

+ type NetworkinstanceProtocolsBgpevpnParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsBgpevpn *NetworkinstanceProtocolsBgpevpn

+ func (in *NetworkinstanceProtocolsBgpevpnParameters) DeepCopy() *NetworkinstanceProtocolsBgpevpnParameters

+ func (in *NetworkinstanceProtocolsBgpevpnParameters) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnParameters)

+ type NetworkinstanceProtocolsBgpevpnSpec struct

+ ForNetworkNode NetworkinstanceProtocolsBgpevpnParameters

+ func (in *NetworkinstanceProtocolsBgpevpnSpec) DeepCopy() *NetworkinstanceProtocolsBgpevpnSpec

+ func (in *NetworkinstanceProtocolsBgpevpnSpec) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnSpec)

+ type NetworkinstanceProtocolsBgpevpnStatus struct

+ AtNetworkNode NetworkinstanceProtocolsBgpevpnObservation

+ func (in *NetworkinstanceProtocolsBgpevpnStatus) DeepCopy() *NetworkinstanceProtocolsBgpevpnStatus

+ func (in *NetworkinstanceProtocolsBgpevpnStatus) DeepCopyInto(out *NetworkinstanceProtocolsBgpevpnStatus)

+ type NetworkinstanceProtocolsBgpvpn struct

+ BgpInstance []*NetworkinstanceProtocolsBgpvpnBgpInstance

+ func (in *NetworkinstanceProtocolsBgpvpn) DeepCopy() *NetworkinstanceProtocolsBgpvpn

+ func (in *NetworkinstanceProtocolsBgpvpn) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpn)

+ type NetworkinstanceProtocolsBgpvpnBgpInstance struct

+ ExportPolicy *string

+ Id *uint8

+ ImportPolicy *string

+ RouteDistinguisher *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher

+ RouteTarget *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstance) DeepCopy() *NetworkinstanceProtocolsBgpvpnBgpInstance

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstance) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnBgpInstance)

+ type NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher struct

+ Rd *string

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher) DeepCopy() *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher)

+ type NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget struct

+ ExportRt *string

+ ImportRt *string

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget) DeepCopy() *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget

+ func (in *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget)

+ type NetworkinstanceProtocolsBgpvpnObservation struct

+ func (in *NetworkinstanceProtocolsBgpvpnObservation) DeepCopy() *NetworkinstanceProtocolsBgpvpnObservation

+ func (in *NetworkinstanceProtocolsBgpvpnObservation) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnObservation)

+ type NetworkinstanceProtocolsBgpvpnParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsBgpvpn *NetworkinstanceProtocolsBgpvpn

+ func (in *NetworkinstanceProtocolsBgpvpnParameters) DeepCopy() *NetworkinstanceProtocolsBgpvpnParameters

+ func (in *NetworkinstanceProtocolsBgpvpnParameters) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnParameters)

+ type NetworkinstanceProtocolsBgpvpnSpec struct

+ ForNetworkNode NetworkinstanceProtocolsBgpvpnParameters

+ func (in *NetworkinstanceProtocolsBgpvpnSpec) DeepCopy() *NetworkinstanceProtocolsBgpvpnSpec

+ func (in *NetworkinstanceProtocolsBgpvpnSpec) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnSpec)

+ type NetworkinstanceProtocolsBgpvpnStatus struct

+ AtNetworkNode NetworkinstanceProtocolsBgpvpnObservation

+ func (in *NetworkinstanceProtocolsBgpvpnStatus) DeepCopy() *NetworkinstanceProtocolsBgpvpnStatus

+ func (in *NetworkinstanceProtocolsBgpvpnStatus) DeepCopyInto(out *NetworkinstanceProtocolsBgpvpnStatus)

+ type NetworkinstanceProtocolsDirectlyConnected struct

+ TeDatabaseInstall *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall

+ func (in *NetworkinstanceProtocolsDirectlyConnected) DeepCopy() *NetworkinstanceProtocolsDirectlyConnected

+ func (in *NetworkinstanceProtocolsDirectlyConnected) DeepCopyInto(out *NetworkinstanceProtocolsDirectlyConnected)

+ type NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall struct

+ BgpLs *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall) DeepCopy() *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall

+ func (in *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall) DeepCopyInto(out *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstall)

+ type NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs struct

+ BgpLsIdentifier *uint32

+ IgpIdentifier *uint64

+ func (in *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs) DeepCopy() *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs) DeepCopyInto(out *NetworkinstanceProtocolsDirectlyConnectedTeDatabaseInstallBgpLs)

+ type NetworkinstanceProtocolsIsis struct

+ Instance []*NetworkinstanceProtocolsIsisInstance

+ func (in *NetworkinstanceProtocolsIsis) DeepCopy() *NetworkinstanceProtocolsIsis

+ func (in *NetworkinstanceProtocolsIsis) DeepCopyInto(out *NetworkinstanceProtocolsIsis)

+ type NetworkinstanceProtocolsIsisInstance struct

+ AdminState *string

+ AttachedBit *NetworkinstanceProtocolsIsisInstanceAttachedBit

+ Authentication *NetworkinstanceProtocolsIsisInstanceAuthentication

+ AutoCost *NetworkinstanceProtocolsIsisInstanceAutoCost

+ ExportPolicy *string

+ GracefulRestart *NetworkinstanceProtocolsIsisInstanceGracefulRestart

+ InterLevelPropagationPolicies *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies

+ Interface []*NetworkinstanceProtocolsIsisInstanceInterface

+ Ipv4Unicast *NetworkinstanceProtocolsIsisInstanceIpv4Unicast

+ Ipv6Unicast *NetworkinstanceProtocolsIsisInstanceIpv6Unicast

+ LdpSynchronization *NetworkinstanceProtocolsIsisInstanceLdpSynchronization

+ Level []*NetworkinstanceProtocolsIsisInstanceLevel

+ LevelCapability *string

+ MaxEcmpPaths *uint8

+ Name *string

+ Net *string

+ Overload *NetworkinstanceProtocolsIsisInstanceOverload

+ PoiTlv *bool

+ TeDatabaseInstall *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall

+ Timers *NetworkinstanceProtocolsIsisInstanceTimers

+ TraceOptions *NetworkinstanceProtocolsIsisInstanceTraceOptions

+ TrafficEngineering *NetworkinstanceProtocolsIsisInstanceTrafficEngineering

+ Transport *NetworkinstanceProtocolsIsisInstanceTransport

+ func (in *NetworkinstanceProtocolsIsisInstance) DeepCopy() *NetworkinstanceProtocolsIsisInstance

+ func (in *NetworkinstanceProtocolsIsisInstance) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstance)

+ type NetworkinstanceProtocolsIsisInstanceAttachedBit struct

+ Ignore *bool

+ Suppress *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceAttachedBit) DeepCopy() *NetworkinstanceProtocolsIsisInstanceAttachedBit

+ func (in *NetworkinstanceProtocolsIsisInstanceAttachedBit) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceAttachedBit)

+ type NetworkinstanceProtocolsIsisInstanceAuthentication struct

+ CsnpAuthentication *bool

+ HelloAuthentication *bool

+ Keychain *string

+ PsnpAuthentication *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceAuthentication) DeepCopy() *NetworkinstanceProtocolsIsisInstanceAuthentication

+ func (in *NetworkinstanceProtocolsIsisInstanceAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceAuthentication)

+ type NetworkinstanceProtocolsIsisInstanceAutoCost struct

+ ReferenceBandwidth *uint64

+ func (in *NetworkinstanceProtocolsIsisInstanceAutoCost) DeepCopy() *NetworkinstanceProtocolsIsisInstanceAutoCost

+ func (in *NetworkinstanceProtocolsIsisInstanceAutoCost) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceAutoCost)

+ type NetworkinstanceProtocolsIsisInstanceGracefulRestart struct

+ HelperMode *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceGracefulRestart) DeepCopy() *NetworkinstanceProtocolsIsisInstanceGracefulRestart

+ func (in *NetworkinstanceProtocolsIsisInstanceGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceGracefulRestart)

+ type NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies struct

+ Level1ToLevel2 *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPolicies)

+ type NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2 struct

+ SummaryAddress []*NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2SummaryAddress

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2) DeepCopy() ...

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2) DeepCopyInto(...)

+ type NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2SummaryAddress struct

+ IpPrefix *string

+ RouteTag *uint32

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2SummaryAddress) DeepCopy() ...

+ func (in *NetworkinstanceProtocolsIsisInstanceInterLevelPropagationPoliciesLevel1ToLevel2SummaryAddress) DeepCopyInto(...)

+ type NetworkinstanceProtocolsIsisInstanceInterface struct

+ AdminState *string

+ Authentication *NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication

+ CircuitType *string

+ HelloPadding *string

+ InterfaceName *string

+ Ipv4Unicast *NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast

+ Ipv6Unicast *NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast

+ LdpSynchronization *NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization

+ Level []*NetworkinstanceProtocolsIsisInstanceInterfaceLevel

+ Passive *bool

+ Timers *NetworkinstanceProtocolsIsisInstanceInterfaceTimers

+ TraceOptions *NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions

+ func (in *NetworkinstanceProtocolsIsisInstanceInterface) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterface

+ func (in *NetworkinstanceProtocolsIsisInstanceInterface) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterface)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication struct

+ HelloAuthentication *bool

+ Keychain *string

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceAuthentication)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast struct

+ AdminState *string

+ EnableBfd *bool

+ IncludeBfdTlv *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceIpv4Unicast)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast struct

+ AdminState *string

+ EnableBfd *bool

+ IncludeBfdTlv *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceIpv6Unicast)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization struct

+ Disable *string

+ EndOfLib *bool

+ HoldDownTimer *uint16

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceLdpSynchronization)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceLevel struct

+ Authentication *NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication

+ Disable *bool

+ Ipv6UnicastMetric *uint32

+ LevelNumber *uint8

+ Metric *uint32

+ Priority *uint8

+ Timers *NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevel) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceLevel

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevel) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceLevel)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceLevelAuthentication)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers struct

+ HelloInterval *uint32

+ HelloMultiplier *uint8

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceLevelTimers)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceTimers struct

+ CsnpInterval *uint16

+ LspPacingInterval *uint64

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceTimers) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceTimers

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceTimers) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceTimers)

+ type NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions struct

+ Trace *string

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions) DeepCopy() *NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions

+ func (in *NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceInterfaceTraceOptions)

+ type NetworkinstanceProtocolsIsisInstanceIpv4Unicast struct

+ AdminState *string

+ func (in *NetworkinstanceProtocolsIsisInstanceIpv4Unicast) DeepCopy() *NetworkinstanceProtocolsIsisInstanceIpv4Unicast

+ func (in *NetworkinstanceProtocolsIsisInstanceIpv4Unicast) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceIpv4Unicast)

+ type NetworkinstanceProtocolsIsisInstanceIpv6Unicast struct

+ AdminState *string

+ MultiTopology *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceIpv6Unicast) DeepCopy() *NetworkinstanceProtocolsIsisInstanceIpv6Unicast

+ func (in *NetworkinstanceProtocolsIsisInstanceIpv6Unicast) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceIpv6Unicast)

+ type NetworkinstanceProtocolsIsisInstanceLdpSynchronization struct

+ EndOfLib *bool

+ HoldDownTimer *uint16

+ func (in *NetworkinstanceProtocolsIsisInstanceLdpSynchronization) DeepCopy() *NetworkinstanceProtocolsIsisInstanceLdpSynchronization

+ func (in *NetworkinstanceProtocolsIsisInstanceLdpSynchronization) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceLdpSynchronization)

+ type NetworkinstanceProtocolsIsisInstanceLevel struct

+ Authentication *NetworkinstanceProtocolsIsisInstanceLevelAuthentication

+ BgpLsExclude *bool

+ LevelNumber *uint8

+ MetricStyle *string

+ RoutePreference *NetworkinstanceProtocolsIsisInstanceLevelRoutePreference

+ TraceOptions *NetworkinstanceProtocolsIsisInstanceLevelTraceOptions

+ func (in *NetworkinstanceProtocolsIsisInstanceLevel) DeepCopy() *NetworkinstanceProtocolsIsisInstanceLevel

+ func (in *NetworkinstanceProtocolsIsisInstanceLevel) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceLevel)

+ type NetworkinstanceProtocolsIsisInstanceLevelAuthentication struct

+ CsnpAuthentication *bool

+ HelloAuthentication *bool

+ Keychain *string

+ PsnpAuthentication *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelAuthentication) DeepCopy() *NetworkinstanceProtocolsIsisInstanceLevelAuthentication

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceLevelAuthentication)

+ type NetworkinstanceProtocolsIsisInstanceLevelRoutePreference struct

+ External *uint8

+ Internal *uint8

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelRoutePreference) DeepCopy() *NetworkinstanceProtocolsIsisInstanceLevelRoutePreference

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelRoutePreference) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceLevelRoutePreference)

+ type NetworkinstanceProtocolsIsisInstanceLevelTraceOptions struct

+ Trace *string

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelTraceOptions) DeepCopy() *NetworkinstanceProtocolsIsisInstanceLevelTraceOptions

+ func (in *NetworkinstanceProtocolsIsisInstanceLevelTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceLevelTraceOptions)

+ type NetworkinstanceProtocolsIsisInstanceOverload struct

+ AdvertiseExternal *bool

+ AdvertiseInterlevel *bool

+ Immediate *NetworkinstanceProtocolsIsisInstanceOverloadImmediate

+ OnBoot *NetworkinstanceProtocolsIsisInstanceOverloadOnBoot

+ func (in *NetworkinstanceProtocolsIsisInstanceOverload) DeepCopy() *NetworkinstanceProtocolsIsisInstanceOverload

+ func (in *NetworkinstanceProtocolsIsisInstanceOverload) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceOverload)

+ type NetworkinstanceProtocolsIsisInstanceOverloadImmediate struct

+ MaxMetric *bool

+ SetBit *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceOverloadImmediate) DeepCopy() *NetworkinstanceProtocolsIsisInstanceOverloadImmediate

+ func (in *NetworkinstanceProtocolsIsisInstanceOverloadImmediate) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceOverloadImmediate)

+ type NetworkinstanceProtocolsIsisInstanceOverloadOnBoot struct

+ MaxMetric *bool

+ SetBit *bool

+ Timeout *uint16

+ func (in *NetworkinstanceProtocolsIsisInstanceOverloadOnBoot) DeepCopy() *NetworkinstanceProtocolsIsisInstanceOverloadOnBoot

+ func (in *NetworkinstanceProtocolsIsisInstanceOverloadOnBoot) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceOverloadOnBoot)

+ type NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall struct

+ BgpLs *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall

+ func (in *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstall)

+ type NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs struct

+ BgpLsIdentifier *uint32

+ IgpIdentifier *uint64

+ func (in *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTeDatabaseInstallBgpLs)

+ type NetworkinstanceProtocolsIsisInstanceTimers struct

+ LspGeneration *NetworkinstanceProtocolsIsisInstanceTimersLspGeneration

+ LspLifetime *uint16

+ LspRefresh *NetworkinstanceProtocolsIsisInstanceTimersLspRefresh

+ Spf *NetworkinstanceProtocolsIsisInstanceTimersSpf

+ func (in *NetworkinstanceProtocolsIsisInstanceTimers) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTimers

+ func (in *NetworkinstanceProtocolsIsisInstanceTimers) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTimers)

+ type NetworkinstanceProtocolsIsisInstanceTimersLspGeneration struct

+ InitialWait *uint64

+ MaxWait *uint64

+ SecondWait *uint64

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersLspGeneration) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTimersLspGeneration

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersLspGeneration) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTimersLspGeneration)

+ type NetworkinstanceProtocolsIsisInstanceTimersLspRefresh struct

+ HalfLifetime *bool

+ Interval *uint16

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersLspRefresh) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTimersLspRefresh

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersLspRefresh) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTimersLspRefresh)

+ type NetworkinstanceProtocolsIsisInstanceTimersSpf struct

+ InitialWait *uint64

+ MaxWait *uint64

+ SecondWait *uint64

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersSpf) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTimersSpf

+ func (in *NetworkinstanceProtocolsIsisInstanceTimersSpf) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTimersSpf)

+ type NetworkinstanceProtocolsIsisInstanceTraceOptions struct

+ Trace *string

+ func (in *NetworkinstanceProtocolsIsisInstanceTraceOptions) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTraceOptions

+ func (in *NetworkinstanceProtocolsIsisInstanceTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTraceOptions)

+ type NetworkinstanceProtocolsIsisInstanceTrafficEngineering struct

+ Advertisement *bool

+ LegacyLinkAttributeAdvertisement *bool

+ func (in *NetworkinstanceProtocolsIsisInstanceTrafficEngineering) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTrafficEngineering

+ func (in *NetworkinstanceProtocolsIsisInstanceTrafficEngineering) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTrafficEngineering)

+ type NetworkinstanceProtocolsIsisInstanceTransport struct

+ LspMtuSize *uint16

+ func (in *NetworkinstanceProtocolsIsisInstanceTransport) DeepCopy() *NetworkinstanceProtocolsIsisInstanceTransport

+ func (in *NetworkinstanceProtocolsIsisInstanceTransport) DeepCopyInto(out *NetworkinstanceProtocolsIsisInstanceTransport)

+ type NetworkinstanceProtocolsIsisObservation struct

+ func (in *NetworkinstanceProtocolsIsisObservation) DeepCopy() *NetworkinstanceProtocolsIsisObservation

+ func (in *NetworkinstanceProtocolsIsisObservation) DeepCopyInto(out *NetworkinstanceProtocolsIsisObservation)

+ type NetworkinstanceProtocolsIsisParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsIsis *NetworkinstanceProtocolsIsis

+ func (in *NetworkinstanceProtocolsIsisParameters) DeepCopy() *NetworkinstanceProtocolsIsisParameters

+ func (in *NetworkinstanceProtocolsIsisParameters) DeepCopyInto(out *NetworkinstanceProtocolsIsisParameters)

+ type NetworkinstanceProtocolsIsisSpec struct

+ ForNetworkNode NetworkinstanceProtocolsIsisParameters

+ func (in *NetworkinstanceProtocolsIsisSpec) DeepCopy() *NetworkinstanceProtocolsIsisSpec

+ func (in *NetworkinstanceProtocolsIsisSpec) DeepCopyInto(out *NetworkinstanceProtocolsIsisSpec)

+ type NetworkinstanceProtocolsIsisStatus struct

+ AtNetworkNode NetworkinstanceProtocolsIsisObservation

+ func (in *NetworkinstanceProtocolsIsisStatus) DeepCopy() *NetworkinstanceProtocolsIsisStatus

+ func (in *NetworkinstanceProtocolsIsisStatus) DeepCopyInto(out *NetworkinstanceProtocolsIsisStatus)

+ type NetworkinstanceProtocolsLdp struct

+ AdminState *string

+ Discovery *NetworkinstanceProtocolsLdpDiscovery

+ DynamicLabelBlock *string

+ GracefulRestart *NetworkinstanceProtocolsLdpGracefulRestart

+ Ipv4 *NetworkinstanceProtocolsLdpIpv4

+ Multipath *NetworkinstanceProtocolsLdpMultipath

+ Peers *NetworkinstanceProtocolsLdpPeers

+ TraceOptions *NetworkinstanceProtocolsLdpTraceOptions

+ func (in *NetworkinstanceProtocolsLdp) DeepCopy() *NetworkinstanceProtocolsLdp

+ func (in *NetworkinstanceProtocolsLdp) DeepCopyInto(out *NetworkinstanceProtocolsLdp)

+ type NetworkinstanceProtocolsLdpDiscovery struct

+ Interfaces *NetworkinstanceProtocolsLdpDiscoveryInterfaces

+ func (in *NetworkinstanceProtocolsLdpDiscovery) DeepCopy() *NetworkinstanceProtocolsLdpDiscovery

+ func (in *NetworkinstanceProtocolsLdpDiscovery) DeepCopyInto(out *NetworkinstanceProtocolsLdpDiscovery)

+ type NetworkinstanceProtocolsLdpDiscoveryInterfaces struct

+ HelloHoldtime *uint16

+ HelloInterval *uint16

+ Interface []*NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfaces) DeepCopy() *NetworkinstanceProtocolsLdpDiscoveryInterfaces

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfaces) DeepCopyInto(out *NetworkinstanceProtocolsLdpDiscoveryInterfaces)

+ type NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface struct

+ AdminState *string

+ HelloHoldtime *uint16

+ HelloInterval *uint16

+ Ipv4 *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4

+ Name *string

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface) DeepCopy() *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface) DeepCopyInto(out *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterface)

+ type NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4 struct

+ AdminState *string

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4) DeepCopy() *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4

+ func (in *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4) DeepCopyInto(out *NetworkinstanceProtocolsLdpDiscoveryInterfacesInterfaceIpv4)

+ type NetworkinstanceProtocolsLdpGracefulRestart struct

+ HelperEnable *bool

+ MaxReconnectTime *uint16

+ MaxRecoveryTime *uint16

+ func (in *NetworkinstanceProtocolsLdpGracefulRestart) DeepCopy() *NetworkinstanceProtocolsLdpGracefulRestart

+ func (in *NetworkinstanceProtocolsLdpGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsLdpGracefulRestart)

+ type NetworkinstanceProtocolsLdpIpv4 struct

+ FecResolution *NetworkinstanceProtocolsLdpIpv4FecResolution

+ func (in *NetworkinstanceProtocolsLdpIpv4) DeepCopy() *NetworkinstanceProtocolsLdpIpv4

+ func (in *NetworkinstanceProtocolsLdpIpv4) DeepCopyInto(out *NetworkinstanceProtocolsLdpIpv4)

+ type NetworkinstanceProtocolsLdpIpv4FecResolution struct

+ LongestPrefix *bool

+ func (in *NetworkinstanceProtocolsLdpIpv4FecResolution) DeepCopy() *NetworkinstanceProtocolsLdpIpv4FecResolution

+ func (in *NetworkinstanceProtocolsLdpIpv4FecResolution) DeepCopyInto(out *NetworkinstanceProtocolsLdpIpv4FecResolution)

+ type NetworkinstanceProtocolsLdpMultipath struct

+ MaxPaths *uint8

+ func (in *NetworkinstanceProtocolsLdpMultipath) DeepCopy() *NetworkinstanceProtocolsLdpMultipath

+ func (in *NetworkinstanceProtocolsLdpMultipath) DeepCopyInto(out *NetworkinstanceProtocolsLdpMultipath)

+ type NetworkinstanceProtocolsLdpPeers struct

+ Peer []*NetworkinstanceProtocolsLdpPeersPeer

+ SessionKeepaliveHoldtime *uint16

+ SessionKeepaliveInterval *uint16

+ TcpTransport *NetworkinstanceProtocolsLdpPeersTcpTransport

+ func (in *NetworkinstanceProtocolsLdpPeers) DeepCopy() *NetworkinstanceProtocolsLdpPeers

+ func (in *NetworkinstanceProtocolsLdpPeers) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeers)

+ type NetworkinstanceProtocolsLdpPeersPeer struct

+ Ipv4 *NetworkinstanceProtocolsLdpPeersPeerIpv4

+ LabelSpaceId *uint16

+ LsrId *string

+ TcpTransport *NetworkinstanceProtocolsLdpPeersPeerTcpTransport

+ func (in *NetworkinstanceProtocolsLdpPeersPeer) DeepCopy() *NetworkinstanceProtocolsLdpPeersPeer

+ func (in *NetworkinstanceProtocolsLdpPeersPeer) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersPeer)

+ type NetworkinstanceProtocolsLdpPeersPeerIpv4 struct

+ FecLimit *uint32

+ func (in *NetworkinstanceProtocolsLdpPeersPeerIpv4) DeepCopy() *NetworkinstanceProtocolsLdpPeersPeerIpv4

+ func (in *NetworkinstanceProtocolsLdpPeersPeerIpv4) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersPeerIpv4)

+ type NetworkinstanceProtocolsLdpPeersPeerTcpTransport struct

+ Authentication *NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication

+ func (in *NetworkinstanceProtocolsLdpPeersPeerTcpTransport) DeepCopy() *NetworkinstanceProtocolsLdpPeersPeerTcpTransport

+ func (in *NetworkinstanceProtocolsLdpPeersPeerTcpTransport) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersPeerTcpTransport)

+ type NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication) DeepCopy() *NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication

+ func (in *NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersPeerTcpTransportAuthentication)

+ type NetworkinstanceProtocolsLdpPeersTcpTransport struct

+ Authentication *NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication

+ func (in *NetworkinstanceProtocolsLdpPeersTcpTransport) DeepCopy() *NetworkinstanceProtocolsLdpPeersTcpTransport

+ func (in *NetworkinstanceProtocolsLdpPeersTcpTransport) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersTcpTransport)

+ type NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication) DeepCopy() *NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication

+ func (in *NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsLdpPeersTcpTransportAuthentication)

+ type NetworkinstanceProtocolsLdpTraceOptions struct

+ Interface []*NetworkinstanceProtocolsLdpTraceOptionsInterface

+ Peer []*NetworkinstanceProtocolsLdpTraceOptionsPeer

+ func (in *NetworkinstanceProtocolsLdpTraceOptions) DeepCopy() *NetworkinstanceProtocolsLdpTraceOptions

+ func (in *NetworkinstanceProtocolsLdpTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsLdpTraceOptions)

+ type NetworkinstanceProtocolsLdpTraceOptionsInterface struct

+ Name *string

+ func (in *NetworkinstanceProtocolsLdpTraceOptionsInterface) DeepCopy() *NetworkinstanceProtocolsLdpTraceOptionsInterface

+ func (in *NetworkinstanceProtocolsLdpTraceOptionsInterface) DeepCopyInto(out *NetworkinstanceProtocolsLdpTraceOptionsInterface)

+ type NetworkinstanceProtocolsLdpTraceOptionsPeer struct

+ LabelSpaceId *uint16

+ LsrId *string

+ func (in *NetworkinstanceProtocolsLdpTraceOptionsPeer) DeepCopy() *NetworkinstanceProtocolsLdpTraceOptionsPeer

+ func (in *NetworkinstanceProtocolsLdpTraceOptionsPeer) DeepCopyInto(out *NetworkinstanceProtocolsLdpTraceOptionsPeer)

+ type NetworkinstanceProtocolsLinux struct

+ ExportNeighbors *bool

+ ExportRoutes *bool

+ ImportRoutes *bool

+ func (in *NetworkinstanceProtocolsLinux) DeepCopy() *NetworkinstanceProtocolsLinux

+ func (in *NetworkinstanceProtocolsLinux) DeepCopyInto(out *NetworkinstanceProtocolsLinux)

+ type NetworkinstanceProtocolsLinuxObservation struct

+ func (in *NetworkinstanceProtocolsLinuxObservation) DeepCopy() *NetworkinstanceProtocolsLinuxObservation

+ func (in *NetworkinstanceProtocolsLinuxObservation) DeepCopyInto(out *NetworkinstanceProtocolsLinuxObservation)

+ type NetworkinstanceProtocolsLinuxParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsLinux *NetworkinstanceProtocolsLinux

+ func (in *NetworkinstanceProtocolsLinuxParameters) DeepCopy() *NetworkinstanceProtocolsLinuxParameters

+ func (in *NetworkinstanceProtocolsLinuxParameters) DeepCopyInto(out *NetworkinstanceProtocolsLinuxParameters)

+ type NetworkinstanceProtocolsLinuxSpec struct

+ ForNetworkNode NetworkinstanceProtocolsLinuxParameters

+ func (in *NetworkinstanceProtocolsLinuxSpec) DeepCopy() *NetworkinstanceProtocolsLinuxSpec

+ func (in *NetworkinstanceProtocolsLinuxSpec) DeepCopyInto(out *NetworkinstanceProtocolsLinuxSpec)

+ type NetworkinstanceProtocolsLinuxStatus struct

+ AtNetworkNode NetworkinstanceProtocolsLinuxObservation

+ func (in *NetworkinstanceProtocolsLinuxStatus) DeepCopy() *NetworkinstanceProtocolsLinuxStatus

+ func (in *NetworkinstanceProtocolsLinuxStatus) DeepCopyInto(out *NetworkinstanceProtocolsLinuxStatus)

+ type NetworkinstanceProtocolsOspf struct

+ Instance []*NetworkinstanceProtocolsOspfInstance

+ func (in *NetworkinstanceProtocolsOspf) DeepCopy() *NetworkinstanceProtocolsOspf

+ func (in *NetworkinstanceProtocolsOspf) DeepCopyInto(out *NetworkinstanceProtocolsOspf)

+ type NetworkinstanceProtocolsOspfInstance struct

+ AddressFamily *string

+ AdminState *string

+ AdvertiseRouterCapability *string

+ Area []*NetworkinstanceProtocolsOspfInstanceArea

+ Asbr *NetworkinstanceProtocolsOspfInstanceAsbr

+ ExportLimit *NetworkinstanceProtocolsOspfInstanceExportLimit

+ ExportPolicy *string

+ ExternalDbOverflow *NetworkinstanceProtocolsOspfInstanceExternalDbOverflow

+ ExternalPreference *uint8

+ GracefulRestart *NetworkinstanceProtocolsOspfInstanceGracefulRestart

+ InstanceId *uint32

+ MaxEcmpPaths *uint8

+ Name *string

+ Overload *NetworkinstanceProtocolsOspfInstanceOverload

+ Preference *uint8

+ ReferenceBandwidth *uint64

+ RouterId *string

+ TeDatabaseInstall *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall

+ Timers *NetworkinstanceProtocolsOspfInstanceTimers

+ TraceOptions *NetworkinstanceProtocolsOspfInstanceTraceOptions

+ TrafficEngineering *NetworkinstanceProtocolsOspfInstanceTrafficEngineering

+ Version *string

+ func (in *NetworkinstanceProtocolsOspfInstance) DeepCopy() *NetworkinstanceProtocolsOspfInstance

+ func (in *NetworkinstanceProtocolsOspfInstance) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstance)

+ type NetworkinstanceProtocolsOspfInstanceArea struct

+ AdvertiseRouterCapability *bool

+ AreaId *string

+ AreaRange []*NetworkinstanceProtocolsOspfInstanceAreaAreaRange

+ BgpLsExclude *bool

+ BlackholeAggregate *bool

+ ExportPolicy *string

+ Interface []*NetworkinstanceProtocolsOspfInstanceAreaInterface

+ Nssa *NetworkinstanceProtocolsOspfInstanceAreaNssa

+ Stub *NetworkinstanceProtocolsOspfInstanceAreaStub

+ func (in *NetworkinstanceProtocolsOspfInstanceArea) DeepCopy() *NetworkinstanceProtocolsOspfInstanceArea

+ func (in *NetworkinstanceProtocolsOspfInstanceArea) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceArea)

+ type NetworkinstanceProtocolsOspfInstanceAreaAreaRange struct

+ Advertise *bool

+ IpPrefixMask *string

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaAreaRange) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaAreaRange

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaAreaRange) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaAreaRange)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterface struct

+ AdminState *string

+ AdvertiseRouterCapability *bool

+ AdvertiseSubnet *bool

+ Authentication *NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication

+ DeadInterval *uint32

+ FailureDetection *NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection

+ HelloInterval *uint32

+ InterfaceName *string

+ InterfaceType *string

+ LsaFilterOut *string

+ Metric *uint16

+ Mtu *uint32

+ Passive *bool

+ Priority *uint16

+ RetransmitInterval *uint32

+ TraceOptions *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions

+ TransitDelay *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterface) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterface

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterface) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterface)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication struct

+ Keychain *string

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterfaceAuthentication)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection struct

+ EnableBfd *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterfaceFailureDetection)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions struct

+ Trace *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptions)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace struct

+ Adjacencies *string

+ Interfaces *string

+ Packet *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTrace)

+ type NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket struct

+ Detail *string

+ Modifier *string

+ Type *string

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaInterfaceTraceOptionsTracePacket)

+ type NetworkinstanceProtocolsOspfInstanceAreaNssa struct

+ AreaRange []*NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange

+ OriginateDefaultRoute *NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute

+ RedistributeExternal *bool

+ Summaries *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssa) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaNssa

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssa) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaNssa)

+ type NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange struct

+ Advertise *bool

+ IpPrefixMask *string

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaNssaAreaRange)

+ type NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute struct

+ AdjacencyCheck *bool

+ TypeNssa *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaNssaOriginateDefaultRoute)

+ type NetworkinstanceProtocolsOspfInstanceAreaStub struct

+ DefaultMetric *uint16

+ Summaries *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaStub) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAreaStub

+ func (in *NetworkinstanceProtocolsOspfInstanceAreaStub) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAreaStub)

+ type NetworkinstanceProtocolsOspfInstanceAsbr struct

+ TracePath *string

+ func (in *NetworkinstanceProtocolsOspfInstanceAsbr) DeepCopy() *NetworkinstanceProtocolsOspfInstanceAsbr

+ func (in *NetworkinstanceProtocolsOspfInstanceAsbr) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceAsbr)

+ type NetworkinstanceProtocolsOspfInstanceExportLimit struct

+ LogPercent *uint32

+ Number *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceExportLimit) DeepCopy() *NetworkinstanceProtocolsOspfInstanceExportLimit

+ func (in *NetworkinstanceProtocolsOspfInstanceExportLimit) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceExportLimit)

+ type NetworkinstanceProtocolsOspfInstanceExternalDbOverflow struct

+ Interval *uint32

+ Limit *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceExternalDbOverflow) DeepCopy() *NetworkinstanceProtocolsOspfInstanceExternalDbOverflow

+ func (in *NetworkinstanceProtocolsOspfInstanceExternalDbOverflow) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceExternalDbOverflow)

+ type NetworkinstanceProtocolsOspfInstanceGracefulRestart struct

+ HelperMode *bool

+ StrictLsaChecking *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceGracefulRestart) DeepCopy() *NetworkinstanceProtocolsOspfInstanceGracefulRestart

+ func (in *NetworkinstanceProtocolsOspfInstanceGracefulRestart) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceGracefulRestart)

+ type NetworkinstanceProtocolsOspfInstanceOverload struct

+ Active *bool

+ OverloadIncludeExt1 *bool

+ OverloadIncludeExt2 *bool

+ OverloadIncludeExtStub *bool

+ OverloadOnBoot *NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot

+ RtrAdvLsaLimit *NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit

+ func (in *NetworkinstanceProtocolsOspfInstanceOverload) DeepCopy() *NetworkinstanceProtocolsOspfInstanceOverload

+ func (in *NetworkinstanceProtocolsOspfInstanceOverload) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceOverload)

+ type NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot struct

+ Timeout *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot) DeepCopy() *NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot

+ func (in *NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceOverloadOverloadOnBoot)

+ type NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit struct

+ LogOnly *bool

+ MaxLsaCount *uint32

+ OverloadTimeout *uint16

+ WarningThreshold *uint8

+ func (in *NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit) DeepCopy() *NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit

+ func (in *NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceOverloadRtrAdvLsaLimit)

+ type NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall struct

+ BgpLs *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall

+ func (in *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstall)

+ type NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs struct

+ BgpLsIdentifier *uint32

+ IgpIdentifier *uint64

+ func (in *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs

+ func (in *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTeDatabaseInstallBgpLs)

+ type NetworkinstanceProtocolsOspfInstanceTimers struct

+ IncrementalSpfWait *uint32

+ LsaAccumulate *uint32

+ LsaArrival *uint32

+ LsaGenerate *NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate

+ RedistributeDelay *uint32

+ SpfWait *NetworkinstanceProtocolsOspfInstanceTimersSpfWait

+ func (in *NetworkinstanceProtocolsOspfInstanceTimers) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTimers

+ func (in *NetworkinstanceProtocolsOspfInstanceTimers) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTimers)

+ type NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate struct

+ LsaInitialWait *uint32

+ LsaSecondWait *uint32

+ MaxLsaWait *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate

+ func (in *NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTimersLsaGenerate)

+ type NetworkinstanceProtocolsOspfInstanceTimersSpfWait struct

+ SpfInitialWait *uint32

+ SpfMaxWait *uint32

+ SpfSecondWait *uint32

+ func (in *NetworkinstanceProtocolsOspfInstanceTimersSpfWait) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTimersSpfWait

+ func (in *NetworkinstanceProtocolsOspfInstanceTimersSpfWait) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTimersSpfWait)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptions struct

+ Trace *NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptions) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptions

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptions) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptions)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace struct

+ Adjacencies *string

+ GracefulRestart *string

+ Interfaces *string

+ Lsdb *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb

+ Misc *string

+ Packet *NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket

+ Routes *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes

+ Spf *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptionsTrace)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb struct

+ LinkStateId *string

+ RouterId *string

+ Type *string

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceLsdb)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket struct

+ Detail *string

+ Modifier *string

+ Type *string

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptionsTracePacket)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes struct

+ DestAddress *string

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceRoutes)

+ type NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf struct

+ DestAddress *string

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf

+ func (in *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTraceOptionsTraceSpf)

+ type NetworkinstanceProtocolsOspfInstanceTrafficEngineering struct

+ Advertisement *bool

+ LegacyLinkAttributeAdvertisement *bool

+ func (in *NetworkinstanceProtocolsOspfInstanceTrafficEngineering) DeepCopy() *NetworkinstanceProtocolsOspfInstanceTrafficEngineering

+ func (in *NetworkinstanceProtocolsOspfInstanceTrafficEngineering) DeepCopyInto(out *NetworkinstanceProtocolsOspfInstanceTrafficEngineering)

+ type NetworkinstanceProtocolsOspfObservation struct

+ func (in *NetworkinstanceProtocolsOspfObservation) DeepCopy() *NetworkinstanceProtocolsOspfObservation

+ func (in *NetworkinstanceProtocolsOspfObservation) DeepCopyInto(out *NetworkinstanceProtocolsOspfObservation)

+ type NetworkinstanceProtocolsOspfParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceProtocolsOspf *NetworkinstanceProtocolsOspf

+ func (in *NetworkinstanceProtocolsOspfParameters) DeepCopy() *NetworkinstanceProtocolsOspfParameters

+ func (in *NetworkinstanceProtocolsOspfParameters) DeepCopyInto(out *NetworkinstanceProtocolsOspfParameters)

+ type NetworkinstanceProtocolsOspfSpec struct

+ ForNetworkNode NetworkinstanceProtocolsOspfParameters

+ func (in *NetworkinstanceProtocolsOspfSpec) DeepCopy() *NetworkinstanceProtocolsOspfSpec

+ func (in *NetworkinstanceProtocolsOspfSpec) DeepCopyInto(out *NetworkinstanceProtocolsOspfSpec)

+ type NetworkinstanceProtocolsOspfStatus struct

+ AtNetworkNode NetworkinstanceProtocolsOspfObservation

+ func (in *NetworkinstanceProtocolsOspfStatus) DeepCopy() *NetworkinstanceProtocolsOspfStatus

+ func (in *NetworkinstanceProtocolsOspfStatus) DeepCopyInto(out *NetworkinstanceProtocolsOspfStatus)

+ type NetworkinstanceSpec struct

+ ForNetworkNode NetworkinstanceParameters

+ func (in *NetworkinstanceSpec) DeepCopy() *NetworkinstanceSpec

+ func (in *NetworkinstanceSpec) DeepCopyInto(out *NetworkinstanceSpec)

+ type NetworkinstanceStaticroutes struct

+ Route []*NetworkinstanceStaticroutesRoute

+ func (in *NetworkinstanceStaticroutes) DeepCopy() *NetworkinstanceStaticroutes

+ func (in *NetworkinstanceStaticroutes) DeepCopyInto(out *NetworkinstanceStaticroutes)

+ type NetworkinstanceStaticroutesObservation struct

+ func (in *NetworkinstanceStaticroutesObservation) DeepCopy() *NetworkinstanceStaticroutesObservation

+ func (in *NetworkinstanceStaticroutesObservation) DeepCopyInto(out *NetworkinstanceStaticroutesObservation)

+ type NetworkinstanceStaticroutesParameters struct

+ NetworkInstanceName *string

+ SrlNetworkinstanceStaticroutes *NetworkinstanceStaticroutes

+ func (in *NetworkinstanceStaticroutesParameters) DeepCopy() *NetworkinstanceStaticroutesParameters

+ func (in *NetworkinstanceStaticroutesParameters) DeepCopyInto(out *NetworkinstanceStaticroutesParameters)

+ type NetworkinstanceStaticroutesRoute struct

+ AdminState *string

+ Metric *uint32

+ NextHopGroup *string

+ Preference *uint8

+ Prefix *string

+ func (in *NetworkinstanceStaticroutesRoute) DeepCopy() *NetworkinstanceStaticroutesRoute

+ func (in *NetworkinstanceStaticroutesRoute) DeepCopyInto(out *NetworkinstanceStaticroutesRoute)

+ type NetworkinstanceStaticroutesSpec struct

+ ForNetworkNode NetworkinstanceStaticroutesParameters

+ func (in *NetworkinstanceStaticroutesSpec) DeepCopy() *NetworkinstanceStaticroutesSpec

+ func (in *NetworkinstanceStaticroutesSpec) DeepCopyInto(out *NetworkinstanceStaticroutesSpec)

+ type NetworkinstanceStaticroutesStatus struct

+ AtNetworkNode NetworkinstanceStaticroutesObservation

+ func (in *NetworkinstanceStaticroutesStatus) DeepCopy() *NetworkinstanceStaticroutesStatus

+ func (in *NetworkinstanceStaticroutesStatus) DeepCopyInto(out *NetworkinstanceStaticroutesStatus)

+ type NetworkinstanceStatus struct

+ AtNetworkNode NetworkinstanceObservation

+ func (in *NetworkinstanceStatus) DeepCopy() *NetworkinstanceStatus

+ func (in *NetworkinstanceStatus) DeepCopyInto(out *NetworkinstanceStatus)

+ type NetworkinstanceTrafficEngineering struct

+ AdminGroups *NetworkinstanceTrafficEngineeringAdminGroups

+ AutonomousSystem *uint32

+ Interface []*NetworkinstanceTrafficEngineeringInterface

+ Ipv4TeRouterId *string

+ Ipv6TeRouterId *string

+ SharedRiskLinkGroups *NetworkinstanceTrafficEngineeringSharedRiskLinkGroups

+ func (in *NetworkinstanceTrafficEngineering) DeepCopy() *NetworkinstanceTrafficEngineering

+ func (in *NetworkinstanceTrafficEngineering) DeepCopyInto(out *NetworkinstanceTrafficEngineering)

+ type NetworkinstanceTrafficEngineeringAdminGroups struct

+ Group []*NetworkinstanceTrafficEngineeringAdminGroupsGroup

+ func (in *NetworkinstanceTrafficEngineeringAdminGroups) DeepCopy() *NetworkinstanceTrafficEngineeringAdminGroups

+ func (in *NetworkinstanceTrafficEngineeringAdminGroups) DeepCopyInto(out *NetworkinstanceTrafficEngineeringAdminGroups)

+ type NetworkinstanceTrafficEngineeringAdminGroupsGroup struct

+ BitPosition *uint32

+ Name *string

+ func (in *NetworkinstanceTrafficEngineeringAdminGroupsGroup) DeepCopy() *NetworkinstanceTrafficEngineeringAdminGroupsGroup

+ func (in *NetworkinstanceTrafficEngineeringAdminGroupsGroup) DeepCopyInto(out *NetworkinstanceTrafficEngineeringAdminGroupsGroup)

+ type NetworkinstanceTrafficEngineeringInterface struct

+ AdminGroup *string

+ Delay *NetworkinstanceTrafficEngineeringInterfaceDelay

+ InterfaceName *string

+ SrlgMembership *string

+ TeMetric *uint32

+ func (in *NetworkinstanceTrafficEngineeringInterface) DeepCopy() *NetworkinstanceTrafficEngineeringInterface

+ func (in *NetworkinstanceTrafficEngineeringInterface) DeepCopyInto(out *NetworkinstanceTrafficEngineeringInterface)

+ type NetworkinstanceTrafficEngineeringInterfaceDelay struct

+ Static *uint32

+ func (in *NetworkinstanceTrafficEngineeringInterfaceDelay) DeepCopy() *NetworkinstanceTrafficEngineeringInterfaceDelay

+ func (in *NetworkinstanceTrafficEngineeringInterfaceDelay) DeepCopyInto(out *NetworkinstanceTrafficEngineeringInterfaceDelay)

+ type NetworkinstanceTrafficEngineeringSharedRiskLinkGroups struct

+ Group []*NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroups) DeepCopy() *NetworkinstanceTrafficEngineeringSharedRiskLinkGroups

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroups) DeepCopyInto(out *NetworkinstanceTrafficEngineeringSharedRiskLinkGroups)

+ type NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup struct

+ Cost *uint32

+ Name *string

+ StaticMember []*NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember

+ Value *uint32

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup) DeepCopy() *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup) DeepCopyInto(out *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroup)

+ type NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember struct

+ FromAddress *string

+ ToAddress *string

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember) DeepCopy() *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember

+ func (in *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember) DeepCopyInto(out *NetworkinstanceTrafficEngineeringSharedRiskLinkGroupsGroupStaticMember)

+ type NetworkinstanceVxlanInterface struct

+ Name *string

+ func (in *NetworkinstanceVxlanInterface) DeepCopy() *NetworkinstanceVxlanInterface

+ func (in *NetworkinstanceVxlanInterface) DeepCopyInto(out *NetworkinstanceVxlanInterface)

+ type Registration struct

+ Spec RegistrationSpec

+ Status RegistrationStatus

+ func (in *Registration) DeepCopy() *Registration

+ func (in *Registration) DeepCopyInto(out *Registration)

+ func (in *Registration) DeepCopyObject() runtime.Object

+ func (mg *Registration) GetActive() bool

+ func (mg *Registration) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *Registration) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *Registration) GetExternalLeafRefs() []string

+ func (mg *Registration) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *Registration) GetResourceIndexes() map[string]string

+ func (mg *Registration) GetTarget() []string

+ func (mg *Registration) SetActive(b bool)

+ func (mg *Registration) SetConditions(c ...nddv1.Condition)

+ func (mg *Registration) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *Registration) SetExternalLeafRefs(n []string)

+ func (mg *Registration) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *Registration) SetResourceIndexes(n map[string]string)

+ func (mg *Registration) SetTarget(t []string)

+ func (o *Registration) GetSubscriptions() []string

+ func (o *Registration) SetSubscriotions(sub []string)

+ type RegistrationList struct

+ Items []Registration

+ func (in *RegistrationList) DeepCopy() *RegistrationList

+ func (in *RegistrationList) DeepCopyInto(out *RegistrationList)

+ func (in *RegistrationList) DeepCopyObject() runtime.Object

+ func (l *RegistrationList) GetItems() []resource.Managed

+ type RegistrationObservation struct

+ func (in *RegistrationObservation) DeepCopy() *RegistrationObservation

+ func (in *RegistrationObservation) DeepCopyInto(out *RegistrationObservation)

+ type RegistrationParameters struct

+ func (in *RegistrationParameters) DeepCopy() *RegistrationParameters

+ func (in *RegistrationParameters) DeepCopyInto(out *RegistrationParameters)

+ type RegistrationSpec struct

+ ForNetworkNode RegistrationParameters

+ func (in *RegistrationSpec) DeepCopy() *RegistrationSpec

+ func (in *RegistrationSpec) DeepCopyInto(out *RegistrationSpec)

+ type RegistrationStatus struct

+ AtNetworkNode RegistrationObservation

+ func (in *RegistrationStatus) DeepCopy() *RegistrationStatus

+ func (in *RegistrationStatus) DeepCopyInto(out *RegistrationStatus)

+ type RoutingpolicyAspathset struct

+ Expression *string

+ Name *string

+ func (in *RoutingpolicyAspathset) DeepCopy() *RoutingpolicyAspathset

+ func (in *RoutingpolicyAspathset) DeepCopyInto(out *RoutingpolicyAspathset)

+ type RoutingpolicyAspathsetObservation struct

+ func (in *RoutingpolicyAspathsetObservation) DeepCopy() *RoutingpolicyAspathsetObservation

+ func (in *RoutingpolicyAspathsetObservation) DeepCopyInto(out *RoutingpolicyAspathsetObservation)

+ type RoutingpolicyAspathsetParameters struct

+ SrlRoutingpolicyAspathset *RoutingpolicyAspathset

+ func (in *RoutingpolicyAspathsetParameters) DeepCopy() *RoutingpolicyAspathsetParameters

+ func (in *RoutingpolicyAspathsetParameters) DeepCopyInto(out *RoutingpolicyAspathsetParameters)

+ type RoutingpolicyAspathsetSpec struct

+ ForNetworkNode RoutingpolicyAspathsetParameters

+ func (in *RoutingpolicyAspathsetSpec) DeepCopy() *RoutingpolicyAspathsetSpec

+ func (in *RoutingpolicyAspathsetSpec) DeepCopyInto(out *RoutingpolicyAspathsetSpec)

+ type RoutingpolicyAspathsetStatus struct

+ AtNetworkNode RoutingpolicyAspathsetObservation

+ func (in *RoutingpolicyAspathsetStatus) DeepCopy() *RoutingpolicyAspathsetStatus

+ func (in *RoutingpolicyAspathsetStatus) DeepCopyInto(out *RoutingpolicyAspathsetStatus)

+ type RoutingpolicyCommunityset struct

+ Member *string

+ Name *string

+ func (in *RoutingpolicyCommunityset) DeepCopy() *RoutingpolicyCommunityset

+ func (in *RoutingpolicyCommunityset) DeepCopyInto(out *RoutingpolicyCommunityset)

+ type RoutingpolicyCommunitysetObservation struct

+ func (in *RoutingpolicyCommunitysetObservation) DeepCopy() *RoutingpolicyCommunitysetObservation

+ func (in *RoutingpolicyCommunitysetObservation) DeepCopyInto(out *RoutingpolicyCommunitysetObservation)

+ type RoutingpolicyCommunitysetParameters struct

+ SrlRoutingpolicyCommunityset *RoutingpolicyCommunityset

+ func (in *RoutingpolicyCommunitysetParameters) DeepCopy() *RoutingpolicyCommunitysetParameters

+ func (in *RoutingpolicyCommunitysetParameters) DeepCopyInto(out *RoutingpolicyCommunitysetParameters)

+ type RoutingpolicyCommunitysetSpec struct

+ ForNetworkNode RoutingpolicyCommunitysetParameters

+ func (in *RoutingpolicyCommunitysetSpec) DeepCopy() *RoutingpolicyCommunitysetSpec

+ func (in *RoutingpolicyCommunitysetSpec) DeepCopyInto(out *RoutingpolicyCommunitysetSpec)

+ type RoutingpolicyCommunitysetStatus struct

+ AtNetworkNode RoutingpolicyCommunitysetObservation

+ func (in *RoutingpolicyCommunitysetStatus) DeepCopy() *RoutingpolicyCommunitysetStatus

+ func (in *RoutingpolicyCommunitysetStatus) DeepCopyInto(out *RoutingpolicyCommunitysetStatus)

+ type RoutingpolicyPolicy struct

+ DefaultAction *RoutingpolicyPolicyDefaultAction

+ Name *string

+ Statement []*RoutingpolicyPolicyStatement

+ func (in *RoutingpolicyPolicy) DeepCopy() *RoutingpolicyPolicy

+ func (in *RoutingpolicyPolicy) DeepCopyInto(out *RoutingpolicyPolicy)

+ type RoutingpolicyPolicyDefaultAction struct

+ Accept *RoutingpolicyPolicyDefaultActionAccept

+ NextEntry *RoutingpolicyPolicyDefaultActionNextEntry

+ NextPolicy *RoutingpolicyPolicyDefaultActionNextPolicy

+ Reject *RoutingpolicyPolicyDefaultActionReject

+ func (in *RoutingpolicyPolicyDefaultAction) DeepCopy() *RoutingpolicyPolicyDefaultAction

+ func (in *RoutingpolicyPolicyDefaultAction) DeepCopyInto(out *RoutingpolicyPolicyDefaultAction)

+ type RoutingpolicyPolicyDefaultActionAccept struct

+ Bgp *RoutingpolicyPolicyDefaultActionAcceptBgp

+ func (in *RoutingpolicyPolicyDefaultActionAccept) DeepCopy() *RoutingpolicyPolicyDefaultActionAccept

+ func (in *RoutingpolicyPolicyDefaultActionAccept) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAccept)

+ type RoutingpolicyPolicyDefaultActionAcceptBgp struct

+ AsPath *RoutingpolicyPolicyDefaultActionAcceptBgpAsPath

+ Communities *RoutingpolicyPolicyDefaultActionAcceptBgpCommunities

+ LocalPreference *RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference

+ Origin *RoutingpolicyPolicyDefaultActionAcceptBgpOrigin

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgp) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgp

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgp) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgp)

+ type RoutingpolicyPolicyDefaultActionAcceptBgpAsPath struct

+ Prepend *RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend

+ Remove *bool

+ Replace *uint32

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpAsPath) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgpAsPath

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpAsPath) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgpAsPath)

+ type RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend struct

+ AsNumber *string

+ RepeatN *uint8

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgpAsPathPrepend)

+ type RoutingpolicyPolicyDefaultActionAcceptBgpCommunities struct

+ Add *string

+ Remove *string

+ Replace *string

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpCommunities) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgpCommunities

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpCommunities) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgpCommunities)

+ type RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference struct

+ Set *uint32

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgpLocalPreference)

+ type RoutingpolicyPolicyDefaultActionAcceptBgpOrigin struct

+ Set *string

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpOrigin) DeepCopy() *RoutingpolicyPolicyDefaultActionAcceptBgpOrigin

+ func (in *RoutingpolicyPolicyDefaultActionAcceptBgpOrigin) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionAcceptBgpOrigin)

+ type RoutingpolicyPolicyDefaultActionNextEntry struct

+ func (in *RoutingpolicyPolicyDefaultActionNextEntry) DeepCopy() *RoutingpolicyPolicyDefaultActionNextEntry

+ func (in *RoutingpolicyPolicyDefaultActionNextEntry) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionNextEntry)

+ type RoutingpolicyPolicyDefaultActionNextPolicy struct

+ func (in *RoutingpolicyPolicyDefaultActionNextPolicy) DeepCopy() *RoutingpolicyPolicyDefaultActionNextPolicy

+ func (in *RoutingpolicyPolicyDefaultActionNextPolicy) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionNextPolicy)

+ type RoutingpolicyPolicyDefaultActionReject struct

+ func (in *RoutingpolicyPolicyDefaultActionReject) DeepCopy() *RoutingpolicyPolicyDefaultActionReject

+ func (in *RoutingpolicyPolicyDefaultActionReject) DeepCopyInto(out *RoutingpolicyPolicyDefaultActionReject)

+ type RoutingpolicyPolicyObservation struct

+ func (in *RoutingpolicyPolicyObservation) DeepCopy() *RoutingpolicyPolicyObservation

+ func (in *RoutingpolicyPolicyObservation) DeepCopyInto(out *RoutingpolicyPolicyObservation)

+ type RoutingpolicyPolicyParameters struct

+ SrlRoutingpolicyPolicy *RoutingpolicyPolicy

+ func (in *RoutingpolicyPolicyParameters) DeepCopy() *RoutingpolicyPolicyParameters

+ func (in *RoutingpolicyPolicyParameters) DeepCopyInto(out *RoutingpolicyPolicyParameters)

+ type RoutingpolicyPolicySpec struct

+ ForNetworkNode RoutingpolicyPolicyParameters

+ func (in *RoutingpolicyPolicySpec) DeepCopy() *RoutingpolicyPolicySpec

+ func (in *RoutingpolicyPolicySpec) DeepCopyInto(out *RoutingpolicyPolicySpec)

+ type RoutingpolicyPolicyStatement struct

+ Action *RoutingpolicyPolicyStatementAction

+ Match *RoutingpolicyPolicyStatementMatch

+ SequenceId *uint32

+ func (in *RoutingpolicyPolicyStatement) DeepCopy() *RoutingpolicyPolicyStatement

+ func (in *RoutingpolicyPolicyStatement) DeepCopyInto(out *RoutingpolicyPolicyStatement)

+ type RoutingpolicyPolicyStatementAction struct

+ Accept *RoutingpolicyPolicyStatementActionAccept

+ NextEntry *RoutingpolicyPolicyStatementActionNextEntry

+ NextPolicy *RoutingpolicyPolicyStatementActionNextPolicy

+ Reject *RoutingpolicyPolicyStatementActionReject

+ func (in *RoutingpolicyPolicyStatementAction) DeepCopy() *RoutingpolicyPolicyStatementAction

+ func (in *RoutingpolicyPolicyStatementAction) DeepCopyInto(out *RoutingpolicyPolicyStatementAction)

+ type RoutingpolicyPolicyStatementActionAccept struct

+ Bgp *RoutingpolicyPolicyStatementActionAcceptBgp

+ func (in *RoutingpolicyPolicyStatementActionAccept) DeepCopy() *RoutingpolicyPolicyStatementActionAccept

+ func (in *RoutingpolicyPolicyStatementActionAccept) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAccept)

+ type RoutingpolicyPolicyStatementActionAcceptBgp struct

+ AsPath *RoutingpolicyPolicyStatementActionAcceptBgpAsPath

+ Communities *RoutingpolicyPolicyStatementActionAcceptBgpCommunities

+ LocalPreference *RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference

+ Origin *RoutingpolicyPolicyStatementActionAcceptBgpOrigin

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgp) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgp

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgp) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgp)

+ type RoutingpolicyPolicyStatementActionAcceptBgpAsPath struct

+ Prepend *RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend

+ Remove *bool

+ Replace *uint32

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpAsPath) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgpAsPath

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpAsPath) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgpAsPath)

+ type RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend struct

+ AsNumber *string

+ RepeatN *uint8

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgpAsPathPrepend)

+ type RoutingpolicyPolicyStatementActionAcceptBgpCommunities struct

+ Add *string

+ Remove *string

+ Replace *string

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpCommunities) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgpCommunities

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpCommunities) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgpCommunities)

+ type RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference struct

+ Set *uint32

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgpLocalPreference)

+ type RoutingpolicyPolicyStatementActionAcceptBgpOrigin struct

+ Set *string

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpOrigin) DeepCopy() *RoutingpolicyPolicyStatementActionAcceptBgpOrigin

+ func (in *RoutingpolicyPolicyStatementActionAcceptBgpOrigin) DeepCopyInto(out *RoutingpolicyPolicyStatementActionAcceptBgpOrigin)

+ type RoutingpolicyPolicyStatementActionNextEntry struct

+ func (in *RoutingpolicyPolicyStatementActionNextEntry) DeepCopy() *RoutingpolicyPolicyStatementActionNextEntry

+ func (in *RoutingpolicyPolicyStatementActionNextEntry) DeepCopyInto(out *RoutingpolicyPolicyStatementActionNextEntry)

+ type RoutingpolicyPolicyStatementActionNextPolicy struct

+ func (in *RoutingpolicyPolicyStatementActionNextPolicy) DeepCopy() *RoutingpolicyPolicyStatementActionNextPolicy

+ func (in *RoutingpolicyPolicyStatementActionNextPolicy) DeepCopyInto(out *RoutingpolicyPolicyStatementActionNextPolicy)

+ type RoutingpolicyPolicyStatementActionReject struct

+ func (in *RoutingpolicyPolicyStatementActionReject) DeepCopy() *RoutingpolicyPolicyStatementActionReject

+ func (in *RoutingpolicyPolicyStatementActionReject) DeepCopyInto(out *RoutingpolicyPolicyStatementActionReject)

+ type RoutingpolicyPolicyStatementMatch struct

+ Bgp *RoutingpolicyPolicyStatementMatchBgp

+ Family *string

+ Isis *RoutingpolicyPolicyStatementMatchIsis

+ Ospf *RoutingpolicyPolicyStatementMatchOspf

+ PrefixSet *string

+ Protocol *string

+ func (in *RoutingpolicyPolicyStatementMatch) DeepCopy() *RoutingpolicyPolicyStatementMatch

+ func (in *RoutingpolicyPolicyStatementMatch) DeepCopyInto(out *RoutingpolicyPolicyStatementMatch)

+ type RoutingpolicyPolicyStatementMatchBgp struct

+ AsPathLength *RoutingpolicyPolicyStatementMatchBgpAsPathLength

+ AsPathSet *string

+ CommunitySet *string

+ Evpn *RoutingpolicyPolicyStatementMatchBgpEvpn

+ func (in *RoutingpolicyPolicyStatementMatchBgp) DeepCopy() *RoutingpolicyPolicyStatementMatchBgp

+ func (in *RoutingpolicyPolicyStatementMatchBgp) DeepCopyInto(out *RoutingpolicyPolicyStatementMatchBgp)

+ type RoutingpolicyPolicyStatementMatchBgpAsPathLength struct

+ Operator *string

+ Unique *bool

+ Value *uint8

+ func (in *RoutingpolicyPolicyStatementMatchBgpAsPathLength) DeepCopy() *RoutingpolicyPolicyStatementMatchBgpAsPathLength

+ func (in *RoutingpolicyPolicyStatementMatchBgpAsPathLength) DeepCopyInto(out *RoutingpolicyPolicyStatementMatchBgpAsPathLength)

+ type RoutingpolicyPolicyStatementMatchBgpEvpn struct

+ RouteType *uint8

+ func (in *RoutingpolicyPolicyStatementMatchBgpEvpn) DeepCopy() *RoutingpolicyPolicyStatementMatchBgpEvpn

+ func (in *RoutingpolicyPolicyStatementMatchBgpEvpn) DeepCopyInto(out *RoutingpolicyPolicyStatementMatchBgpEvpn)

+ type RoutingpolicyPolicyStatementMatchIsis struct

+ Level *uint8

+ RouteType *string

+ func (in *RoutingpolicyPolicyStatementMatchIsis) DeepCopy() *RoutingpolicyPolicyStatementMatchIsis

+ func (in *RoutingpolicyPolicyStatementMatchIsis) DeepCopyInto(out *RoutingpolicyPolicyStatementMatchIsis)

+ type RoutingpolicyPolicyStatementMatchOspf struct

+ AreaId *string

+ InstanceId *uint32

+ RouteType *string

+ func (in *RoutingpolicyPolicyStatementMatchOspf) DeepCopy() *RoutingpolicyPolicyStatementMatchOspf

+ func (in *RoutingpolicyPolicyStatementMatchOspf) DeepCopyInto(out *RoutingpolicyPolicyStatementMatchOspf)

+ type RoutingpolicyPolicyStatus struct

+ AtNetworkNode RoutingpolicyPolicyObservation

+ func (in *RoutingpolicyPolicyStatus) DeepCopy() *RoutingpolicyPolicyStatus

+ func (in *RoutingpolicyPolicyStatus) DeepCopyInto(out *RoutingpolicyPolicyStatus)

+ type RoutingpolicyPrefixset struct

+ Name *string

+ Prefix []*RoutingpolicyPrefixsetPrefix

+ func (in *RoutingpolicyPrefixset) DeepCopy() *RoutingpolicyPrefixset

+ func (in *RoutingpolicyPrefixset) DeepCopyInto(out *RoutingpolicyPrefixset)

+ type RoutingpolicyPrefixsetObservation struct

+ func (in *RoutingpolicyPrefixsetObservation) DeepCopy() *RoutingpolicyPrefixsetObservation

+ func (in *RoutingpolicyPrefixsetObservation) DeepCopyInto(out *RoutingpolicyPrefixsetObservation)

+ type RoutingpolicyPrefixsetParameters struct

+ SrlRoutingpolicyPrefixset *RoutingpolicyPrefixset

+ func (in *RoutingpolicyPrefixsetParameters) DeepCopy() *RoutingpolicyPrefixsetParameters

+ func (in *RoutingpolicyPrefixsetParameters) DeepCopyInto(out *RoutingpolicyPrefixsetParameters)

+ type RoutingpolicyPrefixsetPrefix struct

+ IpPrefix *string

+ MaskLengthRange *string

+ func (in *RoutingpolicyPrefixsetPrefix) DeepCopy() *RoutingpolicyPrefixsetPrefix

+ func (in *RoutingpolicyPrefixsetPrefix) DeepCopyInto(out *RoutingpolicyPrefixsetPrefix)

+ type RoutingpolicyPrefixsetSpec struct

+ ForNetworkNode RoutingpolicyPrefixsetParameters

+ func (in *RoutingpolicyPrefixsetSpec) DeepCopy() *RoutingpolicyPrefixsetSpec

+ func (in *RoutingpolicyPrefixsetSpec) DeepCopyInto(out *RoutingpolicyPrefixsetSpec)

+ type RoutingpolicyPrefixsetStatus struct

+ AtNetworkNode RoutingpolicyPrefixsetObservation

+ func (in *RoutingpolicyPrefixsetStatus) DeepCopy() *RoutingpolicyPrefixsetStatus

+ func (in *RoutingpolicyPrefixsetStatus) DeepCopyInto(out *RoutingpolicyPrefixsetStatus)

+ type SrlBfd struct

+ Spec BfdSpec

+ Status BfdStatus

+ func (in *SrlBfd) DeepCopy() *SrlBfd

+ func (in *SrlBfd) DeepCopyInto(out *SrlBfd)

+ func (in *SrlBfd) DeepCopyObject() runtime.Object

+ func (mg *SrlBfd) GetActive() bool

+ func (mg *SrlBfd) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlBfd) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlBfd) GetExternalLeafRefs() []string

+ func (mg *SrlBfd) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlBfd) GetResourceIndexes() map[string]string

+ func (mg *SrlBfd) GetTarget() []string

+ func (mg *SrlBfd) SetActive(b bool)

+ func (mg *SrlBfd) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlBfd) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlBfd) SetExternalLeafRefs(n []string)

+ func (mg *SrlBfd) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlBfd) SetResourceIndexes(n map[string]string)

+ func (mg *SrlBfd) SetTarget(t []string)

+ type SrlBfdList struct

+ Items []SrlBfd

+ func (in *SrlBfdList) DeepCopy() *SrlBfdList

+ func (in *SrlBfdList) DeepCopyInto(out *SrlBfdList)

+ func (in *SrlBfdList) DeepCopyObject() runtime.Object

+ func (l *SrlBfdList) GetItems() []resource.Managed

+ type SrlInterface struct

+ Spec InterfaceSpec

+ Status InterfaceStatus

+ func (in *SrlInterface) DeepCopy() *SrlInterface

+ func (in *SrlInterface) DeepCopyInto(out *SrlInterface)

+ func (in *SrlInterface) DeepCopyObject() runtime.Object

+ func (mg *SrlInterface) GetActive() bool

+ func (mg *SrlInterface) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlInterface) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlInterface) GetExternalLeafRefs() []string

+ func (mg *SrlInterface) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlInterface) GetResourceIndexes() map[string]string

+ func (mg *SrlInterface) GetTarget() []string

+ func (mg *SrlInterface) SetActive(b bool)

+ func (mg *SrlInterface) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlInterface) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlInterface) SetExternalLeafRefs(n []string)

+ func (mg *SrlInterface) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlInterface) SetResourceIndexes(n map[string]string)

+ func (mg *SrlInterface) SetTarget(t []string)

+ type SrlInterfaceList struct

+ Items []SrlInterface

+ func (in *SrlInterfaceList) DeepCopy() *SrlInterfaceList

+ func (in *SrlInterfaceList) DeepCopyInto(out *SrlInterfaceList)

+ func (in *SrlInterfaceList) DeepCopyObject() runtime.Object

+ func (l *SrlInterfaceList) GetItems() []resource.Managed

+ type SrlInterfaceSubinterface struct

+ func (in *SrlInterfaceSubinterface) DeepCopy() *SrlInterfaceSubinterface

+ func (in *SrlInterfaceSubinterface) DeepCopyInto(out *SrlInterfaceSubinterface)

+ func (in *SrlInterfaceSubinterface) DeepCopyObject() runtime.Object

+ func (mg *SrlInterfaceSubinterface) GetActive() bool

+ func (mg *SrlInterfaceSubinterface) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlInterfaceSubinterface) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlInterfaceSubinterface) GetExternalLeafRefs() []string

+ func (mg *SrlInterfaceSubinterface) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlInterfaceSubinterface) GetResourceIndexes() map[string]string

+ func (mg *SrlInterfaceSubinterface) GetTarget() []string

+ func (mg *SrlInterfaceSubinterface) SetActive(b bool)

+ func (mg *SrlInterfaceSubinterface) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlInterfaceSubinterface) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlInterfaceSubinterface) SetExternalLeafRefs(n []string)

+ func (mg *SrlInterfaceSubinterface) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlInterfaceSubinterface) SetResourceIndexes(n map[string]string)

+ func (mg *SrlInterfaceSubinterface) SetTarget(t []string)

+ Spec InterfaceSubinterfaceSpec

+ Status InterfaceSubinterfaceStatus

+ type SrlInterfaceSubinterfaceList struct

+ func (in *SrlInterfaceSubinterfaceList) DeepCopy() *SrlInterfaceSubinterfaceList

+ func (in *SrlInterfaceSubinterfaceList) DeepCopyInto(out *SrlInterfaceSubinterfaceList)

+ func (in *SrlInterfaceSubinterfaceList) DeepCopyObject() runtime.Object

+ func (l *SrlInterfaceSubinterfaceList) GetItems() []resource.Managed

+ Items []SrlInterfaceSubinterface

+ type SrlNetworkinstance struct

+ Spec NetworkinstanceSpec

+ Status NetworkinstanceStatus

+ func (in *SrlNetworkinstance) DeepCopy() *SrlNetworkinstance

+ func (in *SrlNetworkinstance) DeepCopyInto(out *SrlNetworkinstance)

+ func (in *SrlNetworkinstance) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstance) GetActive() bool

+ func (mg *SrlNetworkinstance) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstance) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstance) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstance) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstance) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstance) GetTarget() []string

+ func (mg *SrlNetworkinstance) SetActive(b bool)

+ func (mg *SrlNetworkinstance) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstance) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstance) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstance) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstance) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstance) SetTarget(t []string)

+ type SrlNetworkinstanceAggregateroutes struct

+ Spec NetworkinstanceAggregateroutesSpec

+ Status NetworkinstanceAggregateroutesStatus

+ func (in *SrlNetworkinstanceAggregateroutes) DeepCopy() *SrlNetworkinstanceAggregateroutes

+ func (in *SrlNetworkinstanceAggregateroutes) DeepCopyInto(out *SrlNetworkinstanceAggregateroutes)

+ func (in *SrlNetworkinstanceAggregateroutes) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceAggregateroutes) GetActive() bool

+ func (mg *SrlNetworkinstanceAggregateroutes) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceAggregateroutes) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceAggregateroutes) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceAggregateroutes) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceAggregateroutes) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceAggregateroutes) GetTarget() []string

+ func (mg *SrlNetworkinstanceAggregateroutes) SetActive(b bool)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceAggregateroutes) SetTarget(t []string)

+ type SrlNetworkinstanceAggregateroutesList struct

+ Items []SrlNetworkinstanceAggregateroutes

+ func (in *SrlNetworkinstanceAggregateroutesList) DeepCopy() *SrlNetworkinstanceAggregateroutesList

+ func (in *SrlNetworkinstanceAggregateroutesList) DeepCopyInto(out *SrlNetworkinstanceAggregateroutesList)

+ func (in *SrlNetworkinstanceAggregateroutesList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceAggregateroutesList) GetItems() []resource.Managed

+ type SrlNetworkinstanceList struct

+ Items []SrlNetworkinstance

+ func (in *SrlNetworkinstanceList) DeepCopy() *SrlNetworkinstanceList

+ func (in *SrlNetworkinstanceList) DeepCopyInto(out *SrlNetworkinstanceList)

+ func (in *SrlNetworkinstanceList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceList) GetItems() []resource.Managed

+ type SrlNetworkinstanceNexthopgroups struct

+ Spec NetworkinstanceNexthopgroupsSpec

+ Status NetworkinstanceNexthopgroupsStatus

+ func (in *SrlNetworkinstanceNexthopgroups) DeepCopy() *SrlNetworkinstanceNexthopgroups

+ func (in *SrlNetworkinstanceNexthopgroups) DeepCopyInto(out *SrlNetworkinstanceNexthopgroups)

+ func (in *SrlNetworkinstanceNexthopgroups) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceNexthopgroups) GetActive() bool

+ func (mg *SrlNetworkinstanceNexthopgroups) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceNexthopgroups) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceNexthopgroups) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceNexthopgroups) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceNexthopgroups) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceNexthopgroups) GetTarget() []string

+ func (mg *SrlNetworkinstanceNexthopgroups) SetActive(b bool)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceNexthopgroups) SetTarget(t []string)

+ type SrlNetworkinstanceNexthopgroupsList struct

+ Items []SrlNetworkinstanceNexthopgroups

+ func (in *SrlNetworkinstanceNexthopgroupsList) DeepCopy() *SrlNetworkinstanceNexthopgroupsList

+ func (in *SrlNetworkinstanceNexthopgroupsList) DeepCopyInto(out *SrlNetworkinstanceNexthopgroupsList)

+ func (in *SrlNetworkinstanceNexthopgroupsList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceNexthopgroupsList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsBgp struct

+ Spec NetworkinstanceProtocolsBgpSpec

+ Status NetworkinstanceProtocolsBgpStatus

+ func (in *SrlNetworkinstanceProtocolsBgp) DeepCopy() *SrlNetworkinstanceProtocolsBgp

+ func (in *SrlNetworkinstanceProtocolsBgp) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgp)

+ func (in *SrlNetworkinstanceProtocolsBgp) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsBgp) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsBgp) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsBgpList struct

+ Items []SrlNetworkinstanceProtocolsBgp

+ func (in *SrlNetworkinstanceProtocolsBgpList) DeepCopy() *SrlNetworkinstanceProtocolsBgpList

+ func (in *SrlNetworkinstanceProtocolsBgpList) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgpList)

+ func (in *SrlNetworkinstanceProtocolsBgpList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsBgpList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsBgpevpn struct

+ Spec NetworkinstanceProtocolsBgpevpnSpec

+ Status NetworkinstanceProtocolsBgpevpnStatus

+ func (in *SrlNetworkinstanceProtocolsBgpevpn) DeepCopy() *SrlNetworkinstanceProtocolsBgpevpn

+ func (in *SrlNetworkinstanceProtocolsBgpevpn) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgpevpn)

+ func (in *SrlNetworkinstanceProtocolsBgpevpn) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsBgpevpn) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsBgpevpnList struct

+ Items []SrlNetworkinstanceProtocolsBgpevpn

+ func (in *SrlNetworkinstanceProtocolsBgpevpnList) DeepCopy() *SrlNetworkinstanceProtocolsBgpevpnList

+ func (in *SrlNetworkinstanceProtocolsBgpevpnList) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgpevpnList)

+ func (in *SrlNetworkinstanceProtocolsBgpevpnList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsBgpevpnList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsBgpvpn struct

+ Spec NetworkinstanceProtocolsBgpvpnSpec

+ Status NetworkinstanceProtocolsBgpvpnStatus

+ func (in *SrlNetworkinstanceProtocolsBgpvpn) DeepCopy() *SrlNetworkinstanceProtocolsBgpvpn

+ func (in *SrlNetworkinstanceProtocolsBgpvpn) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgpvpn)

+ func (in *SrlNetworkinstanceProtocolsBgpvpn) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsBgpvpn) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsBgpvpnList struct

+ Items []SrlNetworkinstanceProtocolsBgpvpn

+ func (in *SrlNetworkinstanceProtocolsBgpvpnList) DeepCopy() *SrlNetworkinstanceProtocolsBgpvpnList

+ func (in *SrlNetworkinstanceProtocolsBgpvpnList) DeepCopyInto(out *SrlNetworkinstanceProtocolsBgpvpnList)

+ func (in *SrlNetworkinstanceProtocolsBgpvpnList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsBgpvpnList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsIsis struct

+ Spec NetworkinstanceProtocolsIsisSpec

+ Status NetworkinstanceProtocolsIsisStatus

+ func (in *SrlNetworkinstanceProtocolsIsis) DeepCopy() *SrlNetworkinstanceProtocolsIsis

+ func (in *SrlNetworkinstanceProtocolsIsis) DeepCopyInto(out *SrlNetworkinstanceProtocolsIsis)

+ func (in *SrlNetworkinstanceProtocolsIsis) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsIsis) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsIsis) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsIsisList struct

+ Items []SrlNetworkinstanceProtocolsIsis

+ func (in *SrlNetworkinstanceProtocolsIsisList) DeepCopy() *SrlNetworkinstanceProtocolsIsisList

+ func (in *SrlNetworkinstanceProtocolsIsisList) DeepCopyInto(out *SrlNetworkinstanceProtocolsIsisList)

+ func (in *SrlNetworkinstanceProtocolsIsisList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsIsisList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsLinux struct

+ Spec NetworkinstanceProtocolsLinuxSpec

+ Status NetworkinstanceProtocolsLinuxStatus

+ func (in *SrlNetworkinstanceProtocolsLinux) DeepCopy() *SrlNetworkinstanceProtocolsLinux

+ func (in *SrlNetworkinstanceProtocolsLinux) DeepCopyInto(out *SrlNetworkinstanceProtocolsLinux)

+ func (in *SrlNetworkinstanceProtocolsLinux) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsLinux) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsLinux) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsLinuxList struct

+ Items []SrlNetworkinstanceProtocolsLinux

+ func (in *SrlNetworkinstanceProtocolsLinuxList) DeepCopy() *SrlNetworkinstanceProtocolsLinuxList

+ func (in *SrlNetworkinstanceProtocolsLinuxList) DeepCopyInto(out *SrlNetworkinstanceProtocolsLinuxList)

+ func (in *SrlNetworkinstanceProtocolsLinuxList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsLinuxList) GetItems() []resource.Managed

+ type SrlNetworkinstanceProtocolsOspf struct

+ Spec NetworkinstanceProtocolsOspfSpec

+ Status NetworkinstanceProtocolsOspfStatus

+ func (in *SrlNetworkinstanceProtocolsOspf) DeepCopy() *SrlNetworkinstanceProtocolsOspf

+ func (in *SrlNetworkinstanceProtocolsOspf) DeepCopyInto(out *SrlNetworkinstanceProtocolsOspf)

+ func (in *SrlNetworkinstanceProtocolsOspf) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetActive() bool

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceProtocolsOspf) GetTarget() []string

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetActive(b bool)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceProtocolsOspf) SetTarget(t []string)

+ type SrlNetworkinstanceProtocolsOspfList struct

+ Items []SrlNetworkinstanceProtocolsOspf

+ func (in *SrlNetworkinstanceProtocolsOspfList) DeepCopy() *SrlNetworkinstanceProtocolsOspfList

+ func (in *SrlNetworkinstanceProtocolsOspfList) DeepCopyInto(out *SrlNetworkinstanceProtocolsOspfList)

+ func (in *SrlNetworkinstanceProtocolsOspfList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceProtocolsOspfList) GetItems() []resource.Managed

+ type SrlNetworkinstanceStaticroutes struct

+ Spec NetworkinstanceStaticroutesSpec

+ Status NetworkinstanceStaticroutesStatus

+ func (in *SrlNetworkinstanceStaticroutes) DeepCopy() *SrlNetworkinstanceStaticroutes

+ func (in *SrlNetworkinstanceStaticroutes) DeepCopyInto(out *SrlNetworkinstanceStaticroutes)

+ func (in *SrlNetworkinstanceStaticroutes) DeepCopyObject() runtime.Object

+ func (mg *SrlNetworkinstanceStaticroutes) GetActive() bool

+ func (mg *SrlNetworkinstanceStaticroutes) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlNetworkinstanceStaticroutes) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlNetworkinstanceStaticroutes) GetExternalLeafRefs() []string

+ func (mg *SrlNetworkinstanceStaticroutes) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlNetworkinstanceStaticroutes) GetResourceIndexes() map[string]string

+ func (mg *SrlNetworkinstanceStaticroutes) GetTarget() []string

+ func (mg *SrlNetworkinstanceStaticroutes) SetActive(b bool)

+ func (mg *SrlNetworkinstanceStaticroutes) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlNetworkinstanceStaticroutes) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlNetworkinstanceStaticroutes) SetExternalLeafRefs(n []string)

+ func (mg *SrlNetworkinstanceStaticroutes) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlNetworkinstanceStaticroutes) SetResourceIndexes(n map[string]string)

+ func (mg *SrlNetworkinstanceStaticroutes) SetTarget(t []string)

+ type SrlNetworkinstanceStaticroutesList struct

+ Items []SrlNetworkinstanceStaticroutes

+ func (in *SrlNetworkinstanceStaticroutesList) DeepCopy() *SrlNetworkinstanceStaticroutesList

+ func (in *SrlNetworkinstanceStaticroutesList) DeepCopyInto(out *SrlNetworkinstanceStaticroutesList)

+ func (in *SrlNetworkinstanceStaticroutesList) DeepCopyObject() runtime.Object

+ func (l *SrlNetworkinstanceStaticroutesList) GetItems() []resource.Managed

+ type SrlRoutingpolicyAspathset struct

+ Spec RoutingpolicyAspathsetSpec

+ Status RoutingpolicyAspathsetStatus

+ func (in *SrlRoutingpolicyAspathset) DeepCopy() *SrlRoutingpolicyAspathset

+ func (in *SrlRoutingpolicyAspathset) DeepCopyInto(out *SrlRoutingpolicyAspathset)

+ func (in *SrlRoutingpolicyAspathset) DeepCopyObject() runtime.Object

+ func (mg *SrlRoutingpolicyAspathset) GetActive() bool

+ func (mg *SrlRoutingpolicyAspathset) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlRoutingpolicyAspathset) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlRoutingpolicyAspathset) GetExternalLeafRefs() []string

+ func (mg *SrlRoutingpolicyAspathset) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlRoutingpolicyAspathset) GetResourceIndexes() map[string]string

+ func (mg *SrlRoutingpolicyAspathset) GetTarget() []string

+ func (mg *SrlRoutingpolicyAspathset) SetActive(b bool)

+ func (mg *SrlRoutingpolicyAspathset) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlRoutingpolicyAspathset) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlRoutingpolicyAspathset) SetExternalLeafRefs(n []string)

+ func (mg *SrlRoutingpolicyAspathset) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlRoutingpolicyAspathset) SetResourceIndexes(n map[string]string)

+ func (mg *SrlRoutingpolicyAspathset) SetTarget(t []string)

+ type SrlRoutingpolicyAspathsetList struct

+ Items []SrlRoutingpolicyAspathset

+ func (in *SrlRoutingpolicyAspathsetList) DeepCopy() *SrlRoutingpolicyAspathsetList

+ func (in *SrlRoutingpolicyAspathsetList) DeepCopyInto(out *SrlRoutingpolicyAspathsetList)

+ func (in *SrlRoutingpolicyAspathsetList) DeepCopyObject() runtime.Object

+ func (l *SrlRoutingpolicyAspathsetList) GetItems() []resource.Managed

+ type SrlRoutingpolicyCommunityset struct

+ Spec RoutingpolicyCommunitysetSpec

+ Status RoutingpolicyCommunitysetStatus

+ func (in *SrlRoutingpolicyCommunityset) DeepCopy() *SrlRoutingpolicyCommunityset

+ func (in *SrlRoutingpolicyCommunityset) DeepCopyInto(out *SrlRoutingpolicyCommunityset)

+ func (in *SrlRoutingpolicyCommunityset) DeepCopyObject() runtime.Object

+ func (mg *SrlRoutingpolicyCommunityset) GetActive() bool

+ func (mg *SrlRoutingpolicyCommunityset) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlRoutingpolicyCommunityset) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlRoutingpolicyCommunityset) GetExternalLeafRefs() []string

+ func (mg *SrlRoutingpolicyCommunityset) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlRoutingpolicyCommunityset) GetResourceIndexes() map[string]string

+ func (mg *SrlRoutingpolicyCommunityset) GetTarget() []string

+ func (mg *SrlRoutingpolicyCommunityset) SetActive(b bool)

+ func (mg *SrlRoutingpolicyCommunityset) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlRoutingpolicyCommunityset) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlRoutingpolicyCommunityset) SetExternalLeafRefs(n []string)

+ func (mg *SrlRoutingpolicyCommunityset) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlRoutingpolicyCommunityset) SetResourceIndexes(n map[string]string)

+ func (mg *SrlRoutingpolicyCommunityset) SetTarget(t []string)

+ type SrlRoutingpolicyCommunitysetList struct

+ Items []SrlRoutingpolicyCommunityset

+ func (in *SrlRoutingpolicyCommunitysetList) DeepCopy() *SrlRoutingpolicyCommunitysetList

+ func (in *SrlRoutingpolicyCommunitysetList) DeepCopyInto(out *SrlRoutingpolicyCommunitysetList)

+ func (in *SrlRoutingpolicyCommunitysetList) DeepCopyObject() runtime.Object

+ func (l *SrlRoutingpolicyCommunitysetList) GetItems() []resource.Managed

+ type SrlRoutingpolicyPolicy struct

+ Spec RoutingpolicyPolicySpec

+ Status RoutingpolicyPolicyStatus

+ func (in *SrlRoutingpolicyPolicy) DeepCopy() *SrlRoutingpolicyPolicy

+ func (in *SrlRoutingpolicyPolicy) DeepCopyInto(out *SrlRoutingpolicyPolicy)

+ func (in *SrlRoutingpolicyPolicy) DeepCopyObject() runtime.Object

+ func (mg *SrlRoutingpolicyPolicy) GetActive() bool

+ func (mg *SrlRoutingpolicyPolicy) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlRoutingpolicyPolicy) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlRoutingpolicyPolicy) GetExternalLeafRefs() []string

+ func (mg *SrlRoutingpolicyPolicy) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlRoutingpolicyPolicy) GetResourceIndexes() map[string]string

+ func (mg *SrlRoutingpolicyPolicy) GetTarget() []string

+ func (mg *SrlRoutingpolicyPolicy) SetActive(b bool)

+ func (mg *SrlRoutingpolicyPolicy) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlRoutingpolicyPolicy) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlRoutingpolicyPolicy) SetExternalLeafRefs(n []string)

+ func (mg *SrlRoutingpolicyPolicy) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlRoutingpolicyPolicy) SetResourceIndexes(n map[string]string)

+ func (mg *SrlRoutingpolicyPolicy) SetTarget(t []string)

+ type SrlRoutingpolicyPolicyList struct

+ Items []SrlRoutingpolicyPolicy

+ func (in *SrlRoutingpolicyPolicyList) DeepCopy() *SrlRoutingpolicyPolicyList

+ func (in *SrlRoutingpolicyPolicyList) DeepCopyInto(out *SrlRoutingpolicyPolicyList)

+ func (in *SrlRoutingpolicyPolicyList) DeepCopyObject() runtime.Object

+ func (l *SrlRoutingpolicyPolicyList) GetItems() []resource.Managed

+ type SrlRoutingpolicyPrefixset struct

+ Spec RoutingpolicyPrefixsetSpec

+ Status RoutingpolicyPrefixsetStatus

+ func (in *SrlRoutingpolicyPrefixset) DeepCopy() *SrlRoutingpolicyPrefixset

+ func (in *SrlRoutingpolicyPrefixset) DeepCopyInto(out *SrlRoutingpolicyPrefixset)

+ func (in *SrlRoutingpolicyPrefixset) DeepCopyObject() runtime.Object

+ func (mg *SrlRoutingpolicyPrefixset) GetActive() bool

+ func (mg *SrlRoutingpolicyPrefixset) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlRoutingpolicyPrefixset) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlRoutingpolicyPrefixset) GetExternalLeafRefs() []string

+ func (mg *SrlRoutingpolicyPrefixset) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlRoutingpolicyPrefixset) GetResourceIndexes() map[string]string

+ func (mg *SrlRoutingpolicyPrefixset) GetTarget() []string

+ func (mg *SrlRoutingpolicyPrefixset) SetActive(b bool)

+ func (mg *SrlRoutingpolicyPrefixset) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlRoutingpolicyPrefixset) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlRoutingpolicyPrefixset) SetExternalLeafRefs(n []string)

+ func (mg *SrlRoutingpolicyPrefixset) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlRoutingpolicyPrefixset) SetResourceIndexes(n map[string]string)

+ func (mg *SrlRoutingpolicyPrefixset) SetTarget(t []string)

+ type SrlRoutingpolicyPrefixsetList struct

+ Items []SrlRoutingpolicyPrefixset

+ func (in *SrlRoutingpolicyPrefixsetList) DeepCopy() *SrlRoutingpolicyPrefixsetList

+ func (in *SrlRoutingpolicyPrefixsetList) DeepCopyInto(out *SrlRoutingpolicyPrefixsetList)

+ func (in *SrlRoutingpolicyPrefixsetList) DeepCopyObject() runtime.Object

+ func (l *SrlRoutingpolicyPrefixsetList) GetItems() []resource.Managed

+ type SrlSystemMtu struct

+ Spec SystemMtuSpec

+ Status SystemMtuStatus

+ func (in *SrlSystemMtu) DeepCopy() *SrlSystemMtu

+ func (in *SrlSystemMtu) DeepCopyInto(out *SrlSystemMtu)

+ func (in *SrlSystemMtu) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemMtu) GetActive() bool

+ func (mg *SrlSystemMtu) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemMtu) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemMtu) GetExternalLeafRefs() []string

+ func (mg *SrlSystemMtu) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemMtu) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemMtu) GetTarget() []string

+ func (mg *SrlSystemMtu) SetActive(b bool)

+ func (mg *SrlSystemMtu) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemMtu) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemMtu) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemMtu) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemMtu) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemMtu) SetTarget(t []string)

+ type SrlSystemMtuList struct

+ Items []SrlSystemMtu

+ func (in *SrlSystemMtuList) DeepCopy() *SrlSystemMtuList

+ func (in *SrlSystemMtuList) DeepCopyInto(out *SrlSystemMtuList)

+ func (in *SrlSystemMtuList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemMtuList) GetItems() []resource.Managed

+ type SrlSystemName struct

+ Spec SystemNameSpec

+ Status SystemNameStatus

+ func (in *SrlSystemName) DeepCopy() *SrlSystemName

+ func (in *SrlSystemName) DeepCopyInto(out *SrlSystemName)

+ func (in *SrlSystemName) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemName) GetActive() bool

+ func (mg *SrlSystemName) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemName) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemName) GetExternalLeafRefs() []string

+ func (mg *SrlSystemName) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemName) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemName) GetTarget() []string

+ func (mg *SrlSystemName) SetActive(b bool)

+ func (mg *SrlSystemName) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemName) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemName) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemName) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemName) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemName) SetTarget(t []string)

+ type SrlSystemNameList struct

+ Items []SrlSystemName

+ func (in *SrlSystemNameList) DeepCopy() *SrlSystemNameList

+ func (in *SrlSystemNameList) DeepCopyInto(out *SrlSystemNameList)

+ func (in *SrlSystemNameList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNameList) GetItems() []resource.Managed

+ type SrlSystemNetworkinstanceProtocolsBgpvpn struct

+ Spec SystemNetworkinstanceProtocolsBgpvpnSpec

+ Status SystemNetworkinstanceProtocolsBgpvpnStatus

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpn) DeepCopy() *SrlSystemNetworkinstanceProtocolsBgpvpn

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpn) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsBgpvpn)

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpn) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetActive() bool

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetExternalLeafRefs() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) GetTarget() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetActive(b bool)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemNetworkinstanceProtocolsBgpvpn) SetTarget(t []string)

+ type SrlSystemNetworkinstanceProtocolsBgpvpnList struct

+ Items []SrlSystemNetworkinstanceProtocolsBgpvpn

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpnList) DeepCopy() *SrlSystemNetworkinstanceProtocolsBgpvpnList

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpnList) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsBgpvpnList)

+ func (in *SrlSystemNetworkinstanceProtocolsBgpvpnList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNetworkinstanceProtocolsBgpvpnList) GetItems() []resource.Managed

+ type SrlSystemNetworkinstanceProtocolsEvpn struct

+ Spec SystemNetworkinstanceProtocolsEvpnSpec

+ Status SystemNetworkinstanceProtocolsEvpnStatus

+ func (in *SrlSystemNetworkinstanceProtocolsEvpn) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpn

+ func (in *SrlSystemNetworkinstanceProtocolsEvpn) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpn)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpn) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetActive() bool

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetExternalLeafRefs() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) GetTarget() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetActive(b bool)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpn) SetTarget(t []string)

+ type SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance struct

+ Spec SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec

+ Status SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetActive() bool

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetExternalLeafRefs() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) GetTarget() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetActive(b bool)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance) SetTarget(t []string)

+ type SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi struct

+ Spec SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec

+ Status SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetActive() bool

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetExternalLeafRefs() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) GetTarget() []string

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetActive(b bool)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) SetTarget(t []string)

+ type SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList struct

+ Items []SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiList) GetItems() []resource.Managed

+ type SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList struct

+ Items []SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceList) GetItems() []resource.Managed

+ type SrlSystemNetworkinstanceProtocolsEvpnList struct

+ Items []SrlSystemNetworkinstanceProtocolsEvpn

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnList) DeepCopy() *SrlSystemNetworkinstanceProtocolsEvpnList

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnList) DeepCopyInto(out *SrlSystemNetworkinstanceProtocolsEvpnList)

+ func (in *SrlSystemNetworkinstanceProtocolsEvpnList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNetworkinstanceProtocolsEvpnList) GetItems() []resource.Managed

+ type SrlSystemNtp struct

+ Spec SystemNtpSpec

+ Status SystemNtpStatus

+ func (in *SrlSystemNtp) DeepCopy() *SrlSystemNtp

+ func (in *SrlSystemNtp) DeepCopyInto(out *SrlSystemNtp)

+ func (in *SrlSystemNtp) DeepCopyObject() runtime.Object

+ func (mg *SrlSystemNtp) GetActive() bool

+ func (mg *SrlSystemNtp) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlSystemNtp) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlSystemNtp) GetExternalLeafRefs() []string

+ func (mg *SrlSystemNtp) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlSystemNtp) GetResourceIndexes() map[string]string

+ func (mg *SrlSystemNtp) GetTarget() []string

+ func (mg *SrlSystemNtp) SetActive(b bool)

+ func (mg *SrlSystemNtp) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlSystemNtp) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlSystemNtp) SetExternalLeafRefs(n []string)

+ func (mg *SrlSystemNtp) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlSystemNtp) SetResourceIndexes(n map[string]string)

+ func (mg *SrlSystemNtp) SetTarget(t []string)

+ type SrlSystemNtpList struct

+ Items []SrlSystemNtp

+ func (in *SrlSystemNtpList) DeepCopy() *SrlSystemNtpList

+ func (in *SrlSystemNtpList) DeepCopyInto(out *SrlSystemNtpList)

+ func (in *SrlSystemNtpList) DeepCopyObject() runtime.Object

+ func (l *SrlSystemNtpList) GetItems() []resource.Managed

+ type SrlTunnelinterface struct

+ func (in *SrlTunnelinterface) DeepCopy() *SrlTunnelinterface

+ func (in *SrlTunnelinterface) DeepCopyInto(out *SrlTunnelinterface)

+ func (in *SrlTunnelinterface) DeepCopyObject() runtime.Object

+ func (mg *SrlTunnelinterface) GetActive() bool

+ func (mg *SrlTunnelinterface) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlTunnelinterface) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlTunnelinterface) GetExternalLeafRefs() []string

+ func (mg *SrlTunnelinterface) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlTunnelinterface) GetResourceIndexes() map[string]string

+ func (mg *SrlTunnelinterface) GetTarget() []string

+ func (mg *SrlTunnelinterface) SetActive(b bool)

+ func (mg *SrlTunnelinterface) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlTunnelinterface) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlTunnelinterface) SetExternalLeafRefs(n []string)

+ func (mg *SrlTunnelinterface) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlTunnelinterface) SetResourceIndexes(n map[string]string)

+ func (mg *SrlTunnelinterface) SetTarget(t []string)

+ Spec TunnelinterfaceSpec

+ Status TunnelinterfaceStatus

+ type SrlTunnelinterfaceList struct

+ func (in *SrlTunnelinterfaceList) DeepCopy() *SrlTunnelinterfaceList

+ func (in *SrlTunnelinterfaceList) DeepCopyInto(out *SrlTunnelinterfaceList)

+ func (in *SrlTunnelinterfaceList) DeepCopyObject() runtime.Object

+ func (l *SrlTunnelinterfaceList) GetItems() []resource.Managed

+ Items []SrlTunnelinterface

+ type SrlTunnelinterfaceVxlaninterface struct

+ func (in *SrlTunnelinterfaceVxlaninterface) DeepCopy() *SrlTunnelinterfaceVxlaninterface

+ func (in *SrlTunnelinterfaceVxlaninterface) DeepCopyInto(out *SrlTunnelinterfaceVxlaninterface)

+ func (in *SrlTunnelinterfaceVxlaninterface) DeepCopyObject() runtime.Object

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetActive() bool

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetCondition(ck nddv1.ConditionKind) nddv1.Condition

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetDeletionPolicy() nddv1.DeletionPolicy

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetExternalLeafRefs() []string

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetNetworkNodeReference() *nddv1.Reference

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetResourceIndexes() map[string]string

+ func (mg *SrlTunnelinterfaceVxlaninterface) GetTarget() []string

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetActive(b bool)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetConditions(c ...nddv1.Condition)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetDeletionPolicy(r nddv1.DeletionPolicy)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetExternalLeafRefs(n []string)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetNetworkNodeReference(r *nddv1.Reference)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetResourceIndexes(n map[string]string)

+ func (mg *SrlTunnelinterfaceVxlaninterface) SetTarget(t []string)

+ Spec TunnelinterfaceVxlaninterfaceSpec

+ Status TunnelinterfaceVxlaninterfaceStatus

+ type SrlTunnelinterfaceVxlaninterfaceList struct

+ func (in *SrlTunnelinterfaceVxlaninterfaceList) DeepCopy() *SrlTunnelinterfaceVxlaninterfaceList

+ func (in *SrlTunnelinterfaceVxlaninterfaceList) DeepCopyInto(out *SrlTunnelinterfaceVxlaninterfaceList)

+ func (in *SrlTunnelinterfaceVxlaninterfaceList) DeepCopyObject() runtime.Object

+ func (l *SrlTunnelinterfaceVxlaninterfaceList) GetItems() []resource.Managed

+ Items []SrlTunnelinterfaceVxlaninterface

+ type SystemMtu struct

+ DefaultIpMtu *uint16

+ DefaultL2Mtu *uint16

+ DefaultPortMtu *uint16

+ MinPathMtu *uint16

+ func (in *SystemMtu) DeepCopy() *SystemMtu

+ func (in *SystemMtu) DeepCopyInto(out *SystemMtu)

+ type SystemMtuObservation struct

+ func (in *SystemMtuObservation) DeepCopy() *SystemMtuObservation

+ func (in *SystemMtuObservation) DeepCopyInto(out *SystemMtuObservation)

+ type SystemMtuParameters struct

+ SrlSystemMtu *SystemMtu

+ func (in *SystemMtuParameters) DeepCopy() *SystemMtuParameters

+ func (in *SystemMtuParameters) DeepCopyInto(out *SystemMtuParameters)

+ type SystemMtuSpec struct

+ ForNetworkNode SystemMtuParameters

+ func (in *SystemMtuSpec) DeepCopy() *SystemMtuSpec

+ func (in *SystemMtuSpec) DeepCopyInto(out *SystemMtuSpec)

+ type SystemMtuStatus struct

+ AtNetworkNode SystemMtuObservation

+ func (in *SystemMtuStatus) DeepCopy() *SystemMtuStatus

+ func (in *SystemMtuStatus) DeepCopyInto(out *SystemMtuStatus)

+ type SystemName struct

+ DomainName *string

+ HostName *string

+ func (in *SystemName) DeepCopy() *SystemName

+ func (in *SystemName) DeepCopyInto(out *SystemName)

+ type SystemNameObservation struct

+ func (in *SystemNameObservation) DeepCopy() *SystemNameObservation

+ func (in *SystemNameObservation) DeepCopyInto(out *SystemNameObservation)

+ type SystemNameParameters struct

+ SrlSystemName *SystemName

+ func (in *SystemNameParameters) DeepCopy() *SystemNameParameters

+ func (in *SystemNameParameters) DeepCopyInto(out *SystemNameParameters)

+ type SystemNameSpec struct

+ ForNetworkNode SystemNameParameters

+ func (in *SystemNameSpec) DeepCopy() *SystemNameSpec

+ func (in *SystemNameSpec) DeepCopyInto(out *SystemNameSpec)

+ type SystemNameStatus struct

+ AtNetworkNode SystemNameObservation

+ func (in *SystemNameStatus) DeepCopy() *SystemNameStatus

+ func (in *SystemNameStatus) DeepCopyInto(out *SystemNameStatus)

+ type SystemNetworkinstanceProtocolsBgpvpn struct

+ BgpInstance []*SystemNetworkinstanceProtocolsBgpvpnBgpInstance

+ func (in *SystemNetworkinstanceProtocolsBgpvpn) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpn

+ func (in *SystemNetworkinstanceProtocolsBgpvpn) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpn)

+ type SystemNetworkinstanceProtocolsBgpvpnBgpInstance struct

+ Id *uint8

+ RouteDistinguisher *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher

+ RouteTarget *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstance) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnBgpInstance

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstance) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnBgpInstance)

+ type SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher struct

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteDistinguisher)

+ type SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget struct

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget

+ func (in *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnBgpInstanceRouteTarget)

+ type SystemNetworkinstanceProtocolsBgpvpnObservation struct

+ func (in *SystemNetworkinstanceProtocolsBgpvpnObservation) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnObservation

+ func (in *SystemNetworkinstanceProtocolsBgpvpnObservation) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnObservation)

+ type SystemNetworkinstanceProtocolsBgpvpnParameters struct

+ SrlSystemNetworkinstanceProtocolsBgpvpn *SystemNetworkinstanceProtocolsBgpvpn

+ func (in *SystemNetworkinstanceProtocolsBgpvpnParameters) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnParameters

+ func (in *SystemNetworkinstanceProtocolsBgpvpnParameters) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnParameters)

+ type SystemNetworkinstanceProtocolsBgpvpnSpec struct

+ ForNetworkNode SystemNetworkinstanceProtocolsBgpvpnParameters

+ func (in *SystemNetworkinstanceProtocolsBgpvpnSpec) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnSpec

+ func (in *SystemNetworkinstanceProtocolsBgpvpnSpec) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnSpec)

+ type SystemNetworkinstanceProtocolsBgpvpnStatus struct

+ AtNetworkNode SystemNetworkinstanceProtocolsBgpvpnObservation

+ func (in *SystemNetworkinstanceProtocolsBgpvpnStatus) DeepCopy() *SystemNetworkinstanceProtocolsBgpvpnStatus

+ func (in *SystemNetworkinstanceProtocolsBgpvpnStatus) DeepCopyInto(out *SystemNetworkinstanceProtocolsBgpvpnStatus)

+ type SystemNetworkinstanceProtocolsEvpn struct

+ EthernetSegments *SystemNetworkinstanceProtocolsEvpnEthernetSegments

+ func (in *SystemNetworkinstanceProtocolsEvpn) DeepCopy() *SystemNetworkinstanceProtocolsEvpn

+ func (in *SystemNetworkinstanceProtocolsEvpn) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpn)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstance struct

+ Id *string

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstance) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstance

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstance) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstance)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi struct

+ AdminState *string

+ DfElection *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection

+ Esi *string

+ Interface *string

+ MultiHomingMode *string

+ Name *string

+ Routes *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection struct

+ Algorithm *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm

+ InterfaceStandbySignalingOnNonDf *bool

+ Timers *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElection)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm struct

+ DefaultAlg *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlg

+ PreferenceAlg *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlg

+ Type *string

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithm)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlg struct

+ Capabilities *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlgCapabilities

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlg) DeepCopy() ...

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlg) DeepCopyInto(...)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlgCapabilities struct

+ AcDf *bool

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlgCapabilities) DeepCopy() ...

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmDefaultAlgCapabilities) DeepCopyInto(...)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlg struct

+ Capabilities *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlgCapabilities

+ PreferenceValue *uint32

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlg) DeepCopy() ...

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlg) DeepCopyInto(...)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlgCapabilities struct

+ AcDf *bool

+ NonRevertive *bool

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlgCapabilities) DeepCopy() ...

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionAlgorithmPreferenceAlgCapabilities) DeepCopyInto(...)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers struct

+ ActivationTimer *uint32

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiDfElectionTimers)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation struct

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters struct

+ BgpInstanceId *string

+ SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsi

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes struct

+ Esi *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment

+ NextHop *string

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutes)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment struct

+ OriginatingIp *string

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiRoutesEthernetSegment)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec struct

+ ForNetworkNode SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiSpec)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus struct

+ AtNetworkNode SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceEsiStatus)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation struct

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters struct

+ SrlSystemNetworkinstanceProtocolsEvpnEsisBgpinstance *SystemNetworkinstanceProtocolsEvpnEsisBgpinstance

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec struct

+ ForNetworkNode SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceSpec)

+ type SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus struct

+ AtNetworkNode SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus

+ func (in *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEsisBgpinstanceStatus)

+ type SystemNetworkinstanceProtocolsEvpnEthernetSegments struct

+ Timers *SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers

+ func (in *SystemNetworkinstanceProtocolsEvpnEthernetSegments) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEthernetSegments

+ func (in *SystemNetworkinstanceProtocolsEvpnEthernetSegments) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEthernetSegments)

+ type SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers struct

+ ActivationTimer *uint32

+ BootTimer *uint32

+ func (in *SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers) DeepCopy() *SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers

+ func (in *SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnEthernetSegmentsTimers)

+ type SystemNetworkinstanceProtocolsEvpnObservation struct

+ func (in *SystemNetworkinstanceProtocolsEvpnObservation) DeepCopy() *SystemNetworkinstanceProtocolsEvpnObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnObservation) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnObservation)

+ type SystemNetworkinstanceProtocolsEvpnParameters struct

+ SrlSystemNetworkinstanceProtocolsEvpn *SystemNetworkinstanceProtocolsEvpn

+ func (in *SystemNetworkinstanceProtocolsEvpnParameters) DeepCopy() *SystemNetworkinstanceProtocolsEvpnParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnParameters) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnParameters)

+ type SystemNetworkinstanceProtocolsEvpnSpec struct

+ ForNetworkNode SystemNetworkinstanceProtocolsEvpnParameters

+ func (in *SystemNetworkinstanceProtocolsEvpnSpec) DeepCopy() *SystemNetworkinstanceProtocolsEvpnSpec

+ func (in *SystemNetworkinstanceProtocolsEvpnSpec) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnSpec)

+ type SystemNetworkinstanceProtocolsEvpnStatus struct

+ AtNetworkNode SystemNetworkinstanceProtocolsEvpnObservation

+ func (in *SystemNetworkinstanceProtocolsEvpnStatus) DeepCopy() *SystemNetworkinstanceProtocolsEvpnStatus

+ func (in *SystemNetworkinstanceProtocolsEvpnStatus) DeepCopyInto(out *SystemNetworkinstanceProtocolsEvpnStatus)

+ type SystemNtp struct

+ AdminState *string

+ NetworkInstance *string

+ Server []*SystemNtpServer

+ func (in *SystemNtp) DeepCopy() *SystemNtp

+ func (in *SystemNtp) DeepCopyInto(out *SystemNtp)

+ type SystemNtpObservation struct

+ func (in *SystemNtpObservation) DeepCopy() *SystemNtpObservation

+ func (in *SystemNtpObservation) DeepCopyInto(out *SystemNtpObservation)

+ type SystemNtpParameters struct

+ SrlSystemNtp *SystemNtp

+ func (in *SystemNtpParameters) DeepCopy() *SystemNtpParameters

+ func (in *SystemNtpParameters) DeepCopyInto(out *SystemNtpParameters)

+ type SystemNtpServer struct

+ Address *string

+ Iburst *bool

+ Prefer *bool

+ func (in *SystemNtpServer) DeepCopy() *SystemNtpServer

+ func (in *SystemNtpServer) DeepCopyInto(out *SystemNtpServer)

+ type SystemNtpSpec struct

+ ForNetworkNode SystemNtpParameters

+ func (in *SystemNtpSpec) DeepCopy() *SystemNtpSpec

+ func (in *SystemNtpSpec) DeepCopyInto(out *SystemNtpSpec)

+ type SystemNtpStatus struct

+ AtNetworkNode SystemNtpObservation

+ func (in *SystemNtpStatus) DeepCopy() *SystemNtpStatus

+ func (in *SystemNtpStatus) DeepCopyInto(out *SystemNtpStatus)

+ type Tunnelinterface struct

+ func (in *Tunnelinterface) DeepCopy() *Tunnelinterface

+ func (in *Tunnelinterface) DeepCopyInto(out *Tunnelinterface)

+ Name *string

+ type TunnelinterfaceObservation struct

+ func (in *TunnelinterfaceObservation) DeepCopy() *TunnelinterfaceObservation

+ func (in *TunnelinterfaceObservation) DeepCopyInto(out *TunnelinterfaceObservation)

+ type TunnelinterfaceParameters struct

+ func (in *TunnelinterfaceParameters) DeepCopy() *TunnelinterfaceParameters

+ func (in *TunnelinterfaceParameters) DeepCopyInto(out *TunnelinterfaceParameters)

+ SrlTunnelinterface *Tunnelinterface

+ type TunnelinterfaceSpec struct

+ func (in *TunnelinterfaceSpec) DeepCopy() *TunnelinterfaceSpec

+ func (in *TunnelinterfaceSpec) DeepCopyInto(out *TunnelinterfaceSpec)

+ ForNetworkNode TunnelinterfaceParameters

+ type TunnelinterfaceStatus struct

+ func (in *TunnelinterfaceStatus) DeepCopy() *TunnelinterfaceStatus

+ func (in *TunnelinterfaceStatus) DeepCopyInto(out *TunnelinterfaceStatus)

+ AtNetworkNode TunnelinterfaceObservation

+ type TunnelinterfaceVxlaninterface struct

+ func (in *TunnelinterfaceVxlaninterface) DeepCopy() *TunnelinterfaceVxlaninterface

+ func (in *TunnelinterfaceVxlaninterface) DeepCopyInto(out *TunnelinterfaceVxlaninterface)

+ BridgeTable *TunnelinterfaceVxlaninterfaceBridgeTable

+ Egress *TunnelinterfaceVxlaninterfaceEgress

+ Index *uint32

+ Ingress *TunnelinterfaceVxlaninterfaceIngress

+ Type *string

+ type TunnelinterfaceVxlaninterfaceBridgeTable struct

+ func (in *TunnelinterfaceVxlaninterfaceBridgeTable) DeepCopy() *TunnelinterfaceVxlaninterfaceBridgeTable

+ func (in *TunnelinterfaceVxlaninterfaceBridgeTable) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceBridgeTable)

+ type TunnelinterfaceVxlaninterfaceEgress struct

+ func (in *TunnelinterfaceVxlaninterfaceEgress) DeepCopy() *TunnelinterfaceVxlaninterfaceEgress

+ func (in *TunnelinterfaceVxlaninterfaceEgress) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceEgress)

+ DestinationGroups *TunnelinterfaceVxlaninterfaceEgressDestinationGroups

+ InnerEthernetHeader *TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader

+ SourceIp *string

+ type TunnelinterfaceVxlaninterfaceEgressDestinationGroups struct

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroups) DeepCopy() *TunnelinterfaceVxlaninterfaceEgressDestinationGroups

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroups) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceEgressDestinationGroups)

+ Group []*TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup

+ type TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup struct

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup) DeepCopy() *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroup)

+ AdminState *string

+ Destination []*TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination

+ Esi *string

+ Name *string

+ type TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination struct

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination) DeepCopy() *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestination)

+ AdminState *string

+ Index *uint16

+ InnerEthernetHeader *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestinationInnerEthernetHeader

+ Vni *uint32

+ type TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestinationInnerEthernetHeader struct

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestinationInnerEthernetHeader) DeepCopy() ...

+ func (in *TunnelinterfaceVxlaninterfaceEgressDestinationGroupsGroupDestinationInnerEthernetHeader) DeepCopyInto(...)

+ DestinationMac *string

+ type TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader struct

+ func (in *TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader) DeepCopy() *TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader

+ func (in *TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceEgressInnerEthernetHeader)

+ SourceMac *string

+ type TunnelinterfaceVxlaninterfaceIngress struct

+ func (in *TunnelinterfaceVxlaninterfaceIngress) DeepCopy() *TunnelinterfaceVxlaninterfaceIngress

+ func (in *TunnelinterfaceVxlaninterfaceIngress) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceIngress)

+ Vni *uint32

+ type TunnelinterfaceVxlaninterfaceObservation struct

+ func (in *TunnelinterfaceVxlaninterfaceObservation) DeepCopy() *TunnelinterfaceVxlaninterfaceObservation

+ func (in *TunnelinterfaceVxlaninterfaceObservation) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceObservation)

+ type TunnelinterfaceVxlaninterfaceParameters struct

+ func (in *TunnelinterfaceVxlaninterfaceParameters) DeepCopy() *TunnelinterfaceVxlaninterfaceParameters

+ func (in *TunnelinterfaceVxlaninterfaceParameters) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceParameters)

+ SrlTunnelinterfaceVxlaninterface *TunnelinterfaceVxlaninterface

+ TunnelInterfaceName *string

+ type TunnelinterfaceVxlaninterfaceSpec struct

+ func (in *TunnelinterfaceVxlaninterfaceSpec) DeepCopy() *TunnelinterfaceVxlaninterfaceSpec

+ func (in *TunnelinterfaceVxlaninterfaceSpec) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceSpec)

+ ForNetworkNode TunnelinterfaceVxlaninterfaceParameters

+ type TunnelinterfaceVxlaninterfaceStatus struct

+ func (in *TunnelinterfaceVxlaninterfaceStatus) DeepCopy() *TunnelinterfaceVxlaninterfaceStatus

+ func (in *TunnelinterfaceVxlaninterfaceStatus) DeepCopyInto(out *TunnelinterfaceVxlaninterfaceStatus)

+ AtNetworkNode TunnelinterfaceVxlaninterfaceObservation

v0.1.3

Sep 5, 2021

v0.1.2

Aug 29, 2021

v0.1.1

Aug 29, 2021

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL