gosnappi

package module
v0.6.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 18, 2021 License: MIT Imports: 19 Imported by: 14

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var BgpAsPathAsSetMode = struct {
	DO_NOT_INCLUDE_LOCAL_AS  BgpAsPathAsSetModeEnum
	INCLUDE_AS_SEQ           BgpAsPathAsSetModeEnum
	INCLUDE_AS_SET           BgpAsPathAsSetModeEnum
	INCLUDE_AS_CONFED_SEQ    BgpAsPathAsSetModeEnum
	INCLUDE_AS_CONFED_SET    BgpAsPathAsSetModeEnum
	PREPEND_TO_FIRST_SEGMENT BgpAsPathAsSetModeEnum
}{
	DO_NOT_INCLUDE_LOCAL_AS:  BgpAsPathAsSetModeEnum("do_not_include_local_as"),
	INCLUDE_AS_SEQ:           BgpAsPathAsSetModeEnum("include_as_seq"),
	INCLUDE_AS_SET:           BgpAsPathAsSetModeEnum("include_as_set"),
	INCLUDE_AS_CONFED_SEQ:    BgpAsPathAsSetModeEnum("include_as_confed_seq"),
	INCLUDE_AS_CONFED_SET:    BgpAsPathAsSetModeEnum("include_as_confed_set"),
	PREPEND_TO_FIRST_SEGMENT: BgpAsPathAsSetModeEnum("prepend_to_first_segment"),
}
View Source 
var BgpAsPathSegmentType = struct {
	AS_SEQ        BgpAsPathSegmentTypeEnum
	AS_SET        BgpAsPathSegmentTypeEnum
	AS_CONFED_SEQ BgpAsPathSegmentTypeEnum
	AS_CONFED_SET BgpAsPathSegmentTypeEnum
}{
	AS_SEQ:        BgpAsPathSegmentTypeEnum("as_seq"),
	AS_SET:        BgpAsPathSegmentTypeEnum("as_set"),
	AS_CONFED_SEQ: BgpAsPathSegmentTypeEnum("as_confed_seq"),
	AS_CONFED_SET: BgpAsPathSegmentTypeEnum("as_confed_set"),
}
View Source 
var BgpCommunityType = struct {
	MANUAL_AS_NUMBER    BgpCommunityTypeEnum
	NO_EXPORT           BgpCommunityTypeEnum
	NO_ADVERTISED       BgpCommunityTypeEnum
	NO_EXPORT_SUBCONFED BgpCommunityTypeEnum
	LLGR_STALE          BgpCommunityTypeEnum
	NO_LLGR             BgpCommunityTypeEnum
}{
	MANUAL_AS_NUMBER:    BgpCommunityTypeEnum("manual_as_number"),
	NO_EXPORT:           BgpCommunityTypeEnum("no_export"),
	NO_ADVERTISED:       BgpCommunityTypeEnum("no_advertised"),
	NO_EXPORT_SUBCONFED: BgpCommunityTypeEnum("no_export_subconfed"),
	LLGR_STALE:          BgpCommunityTypeEnum("llgr_stale"),
	NO_LLGR:             BgpCommunityTypeEnum("no_llgr"),
}
View Source 
var BgpExtCommunitySubtype = struct {
	ROUTE_TARGET       BgpExtCommunitySubtypeEnum
	ORIGIN             BgpExtCommunitySubtypeEnum
	EXTENDED_BANDWIDTH BgpExtCommunitySubtypeEnum
	COLOR              BgpExtCommunitySubtypeEnum
	ENCAPSULATION      BgpExtCommunitySubtypeEnum
	MAC_ADDRESS        BgpExtCommunitySubtypeEnum
}{
	ROUTE_TARGET:       BgpExtCommunitySubtypeEnum("route_target"),
	ORIGIN:             BgpExtCommunitySubtypeEnum("origin"),
	EXTENDED_BANDWIDTH: BgpExtCommunitySubtypeEnum("extended_bandwidth"),
	COLOR:              BgpExtCommunitySubtypeEnum("color"),
	ENCAPSULATION:      BgpExtCommunitySubtypeEnum("encapsulation"),
	MAC_ADDRESS:        BgpExtCommunitySubtypeEnum("mac_address"),
}
View Source 
var BgpExtCommunityType = struct {
	ADMINISTRATOR_AS_2OCTET                BgpExtCommunityTypeEnum
	ADMINISTRATOR_IPV4_ADDRESS             BgpExtCommunityTypeEnum
	ADMINISTRATOR_AS_4OCTET                BgpExtCommunityTypeEnum
	OPAQUE                                 BgpExtCommunityTypeEnum
	EVPN                                   BgpExtCommunityTypeEnum
	ADMINISTRATOR_AS_2OCTET_LINK_BANDWIDTH BgpExtCommunityTypeEnum
}{
	ADMINISTRATOR_AS_2OCTET:                BgpExtCommunityTypeEnum("administrator_as_2octet"),
	ADMINISTRATOR_IPV4_ADDRESS:             BgpExtCommunityTypeEnum("administrator_ipv4_address"),
	ADMINISTRATOR_AS_4OCTET:                BgpExtCommunityTypeEnum("administrator_as_4octet"),
	OPAQUE:                                 BgpExtCommunityTypeEnum("opaque"),
	EVPN:                                   BgpExtCommunityTypeEnum("evpn"),
	ADMINISTRATOR_AS_2OCTET_LINK_BANDWIDTH: BgpExtCommunityTypeEnum("administrator_as_2octet_link_bandwidth"),
}
View Source 
var BgpRouteAdvancedOrigin = struct {
	IGP BgpRouteAdvancedOriginEnum
	EGP BgpRouteAdvancedOriginEnum
}{
	IGP: BgpRouteAdvancedOriginEnum("igp"),
	EGP: BgpRouteAdvancedOriginEnum("egp"),
}
View Source 
var BgpSrteBindingSubTlvBindingSidType = struct {
	NO_BINDING     BgpSrteBindingSubTlvBindingSidTypeEnum
	FOUR_OCTET_SID BgpSrteBindingSubTlvBindingSidTypeEnum
	IPV6_SID       BgpSrteBindingSubTlvBindingSidTypeEnum
}{
	NO_BINDING:     BgpSrteBindingSubTlvBindingSidTypeEnum("no_binding"),
	FOUR_OCTET_SID: BgpSrteBindingSubTlvBindingSidTypeEnum("four_octet_sid"),
	IPV6_SID:       BgpSrteBindingSubTlvBindingSidTypeEnum("ipv6_sid"),
}
View Source 
var BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicy = struct {
	RESERVED_ENLP       BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
	PUSH_IPV4_ENLP      BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
	PUSH_IPV6_ENLP      BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
	PUSH_IPV4_IPV6_ENLP BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
	DO_NOT_PUSH_ENLP    BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
}{
	RESERVED_ENLP:       BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum("reserved_enlp"),
	PUSH_IPV4_ENLP:      BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum("push_ipv4_enlp"),
	PUSH_IPV6_ENLP:      BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum("push_ipv6_enlp"),
	PUSH_IPV4_IPV6_ENLP: BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum("push_ipv4_ipv6_enlp"),
	DO_NOT_PUSH_ENLP:    BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum("do_not_push_enlp"),
}
View Source 
var BgpSrteRemoteEndpointSubTlvAddressFamily = struct {
	IPV4 BgpSrteRemoteEndpointSubTlvAddressFamilyEnum
	IPV6 BgpSrteRemoteEndpointSubTlvAddressFamilyEnum
}{
	IPV4: BgpSrteRemoteEndpointSubTlvAddressFamilyEnum("ipv4"),
	IPV6: BgpSrteRemoteEndpointSubTlvAddressFamilyEnum("ipv6"),
}
View Source 
var BgpSrteSegmentSegmentType = struct {
	TYPE_A BgpSrteSegmentSegmentTypeEnum
	TYPE_B BgpSrteSegmentSegmentTypeEnum
	TYPE_C BgpSrteSegmentSegmentTypeEnum
	TYPE_D BgpSrteSegmentSegmentTypeEnum
	TYPE_E BgpSrteSegmentSegmentTypeEnum
	TYPE_F BgpSrteSegmentSegmentTypeEnum
	TYPE_G BgpSrteSegmentSegmentTypeEnum
	TYPE_H BgpSrteSegmentSegmentTypeEnum
	TYPE_I BgpSrteSegmentSegmentTypeEnum
	TYPE_J BgpSrteSegmentSegmentTypeEnum
	TYPE_K BgpSrteSegmentSegmentTypeEnum
}{
	TYPE_A: BgpSrteSegmentSegmentTypeEnum("type_a"),
	TYPE_B: BgpSrteSegmentSegmentTypeEnum("type_b"),
	TYPE_C: BgpSrteSegmentSegmentTypeEnum("type_c"),
	TYPE_D: BgpSrteSegmentSegmentTypeEnum("type_d"),
	TYPE_E: BgpSrteSegmentSegmentTypeEnum("type_e"),
	TYPE_F: BgpSrteSegmentSegmentTypeEnum("type_f"),
	TYPE_G: BgpSrteSegmentSegmentTypeEnum("type_g"),
	TYPE_H: BgpSrteSegmentSegmentTypeEnum("type_h"),
	TYPE_I: BgpSrteSegmentSegmentTypeEnum("type_i"),
	TYPE_J: BgpSrteSegmentSegmentTypeEnum("type_j"),
	TYPE_K: BgpSrteSegmentSegmentTypeEnum("type_k"),
}
View Source 
var BgpSrteV4PolicyNextHopAddressType = struct {
	IPV4 BgpSrteV4PolicyNextHopAddressTypeEnum
	IPV6 BgpSrteV4PolicyNextHopAddressTypeEnum
}{
	IPV4: BgpSrteV4PolicyNextHopAddressTypeEnum("ipv4"),
	IPV6: BgpSrteV4PolicyNextHopAddressTypeEnum("ipv6"),
}
View Source 
var BgpSrteV4PolicyNextHopMode = struct {
	LOCAL_IP BgpSrteV4PolicyNextHopModeEnum
	MANUAL   BgpSrteV4PolicyNextHopModeEnum
}{
	LOCAL_IP: BgpSrteV4PolicyNextHopModeEnum("local_ip"),
	MANUAL:   BgpSrteV4PolicyNextHopModeEnum("manual"),
}
View Source 
var BgpSrteV6PolicyNextHopAddressType = struct {
	IPV4 BgpSrteV6PolicyNextHopAddressTypeEnum
	IPV6 BgpSrteV6PolicyNextHopAddressTypeEnum
}{
	IPV4: BgpSrteV6PolicyNextHopAddressTypeEnum("ipv4"),
	IPV6: BgpSrteV6PolicyNextHopAddressTypeEnum("ipv6"),
}
View Source 
var BgpSrteV6PolicyNextHopMode = struct {
	LOCAL_IP BgpSrteV6PolicyNextHopModeEnum
	MANUAL   BgpSrteV6PolicyNextHopModeEnum
}{
	LOCAL_IP: BgpSrteV6PolicyNextHopModeEnum("local_ip"),
	MANUAL:   BgpSrteV6PolicyNextHopModeEnum("manual"),
}
View Source 
var BgpV4PeerAsNumberWidth = struct {
	TWO  BgpV4PeerAsNumberWidthEnum
	FOUR BgpV4PeerAsNumberWidthEnum
}{
	TWO:  BgpV4PeerAsNumberWidthEnum("two"),
	FOUR: BgpV4PeerAsNumberWidthEnum("four"),
}
View Source 
var BgpV4PeerAsType = struct {
	IBGP BgpV4PeerAsTypeEnum
	EBGP BgpV4PeerAsTypeEnum
}{
	IBGP: BgpV4PeerAsTypeEnum("ibgp"),
	EBGP: BgpV4PeerAsTypeEnum("ebgp"),
}
View Source 
var BgpV4RouteRangeNextHopAddressType = struct {
	IPV4 BgpV4RouteRangeNextHopAddressTypeEnum
	IPV6 BgpV4RouteRangeNextHopAddressTypeEnum
}{
	IPV4: BgpV4RouteRangeNextHopAddressTypeEnum("ipv4"),
	IPV6: BgpV4RouteRangeNextHopAddressTypeEnum("ipv6"),
}
View Source 
var BgpV4RouteRangeNextHopMode = struct {
	LOCAL_IP BgpV4RouteRangeNextHopModeEnum
	MANUAL   BgpV4RouteRangeNextHopModeEnum
}{
	LOCAL_IP: BgpV4RouteRangeNextHopModeEnum("local_ip"),
	MANUAL:   BgpV4RouteRangeNextHopModeEnum("manual"),
}
View Source 
var BgpV6PeerAsNumberWidth = struct {
	TWO  BgpV6PeerAsNumberWidthEnum
	FOUR BgpV6PeerAsNumberWidthEnum
}{
	TWO:  BgpV6PeerAsNumberWidthEnum("two"),
	FOUR: BgpV6PeerAsNumberWidthEnum("four"),
}
View Source 
var BgpV6PeerAsType = struct {
	IBGP BgpV6PeerAsTypeEnum
	EBGP BgpV6PeerAsTypeEnum
}{
	IBGP: BgpV6PeerAsTypeEnum("ibgp"),
	EBGP: BgpV6PeerAsTypeEnum("ebgp"),
}
View Source 
var BgpV6RouteRangeNextHopAddressType = struct {
	IPV4 BgpV6RouteRangeNextHopAddressTypeEnum
	IPV6 BgpV6RouteRangeNextHopAddressTypeEnum
}{
	IPV4: BgpV6RouteRangeNextHopAddressTypeEnum("ipv4"),
	IPV6: BgpV6RouteRangeNextHopAddressTypeEnum("ipv6"),
}
View Source 
var BgpV6RouteRangeNextHopMode = struct {
	LOCAL_IP BgpV6RouteRangeNextHopModeEnum
	MANUAL   BgpV6RouteRangeNextHopModeEnum
}{
	LOCAL_IP: BgpV6RouteRangeNextHopModeEnum("local_ip"),
	MANUAL:   BgpV6RouteRangeNextHopModeEnum("manual"),
}
View Source 
var Bgpv4MetricSessionState = struct {
	UP   Bgpv4MetricSessionStateEnum
	DOWN Bgpv4MetricSessionStateEnum
}{
	UP:   Bgpv4MetricSessionStateEnum("up"),
	DOWN: Bgpv4MetricSessionStateEnum("down"),
}
View Source 
var Bgpv4MetricsRequestColumnNames = struct {
	SESSION_STATE            Bgpv4MetricsRequestColumnNamesEnum
	SESSION_FLAP_COUNT       Bgpv4MetricsRequestColumnNamesEnum
	ROUTES_ADVERTISED        Bgpv4MetricsRequestColumnNamesEnum
	ROUTES_RECEIVED          Bgpv4MetricsRequestColumnNamesEnum
	ROUTE_WITHDRAWS_SENT     Bgpv4MetricsRequestColumnNamesEnum
	ROUTE_WITHDRAWS_RECEIVED Bgpv4MetricsRequestColumnNamesEnum
	UPDATES_SENT             Bgpv4MetricsRequestColumnNamesEnum
	UPDATES_RECEIVED         Bgpv4MetricsRequestColumnNamesEnum
	OPENS_SENT               Bgpv4MetricsRequestColumnNamesEnum
	OPENS_RECEIVED           Bgpv4MetricsRequestColumnNamesEnum
	KEEPALIVES_SENT          Bgpv4MetricsRequestColumnNamesEnum
	KEEPALIVES_RECEIVED      Bgpv4MetricsRequestColumnNamesEnum
	NOTIFICATIONS_SENT       Bgpv4MetricsRequestColumnNamesEnum
	NOTIFICATIONS_RECEIVED   Bgpv4MetricsRequestColumnNamesEnum
}{
	SESSION_STATE:            Bgpv4MetricsRequestColumnNamesEnum("session_state"),
	SESSION_FLAP_COUNT:       Bgpv4MetricsRequestColumnNamesEnum("session_flap_count"),
	ROUTES_ADVERTISED:        Bgpv4MetricsRequestColumnNamesEnum("routes_advertised"),
	ROUTES_RECEIVED:          Bgpv4MetricsRequestColumnNamesEnum("routes_received"),
	ROUTE_WITHDRAWS_SENT:     Bgpv4MetricsRequestColumnNamesEnum("route_withdraws_sent"),
	ROUTE_WITHDRAWS_RECEIVED: Bgpv4MetricsRequestColumnNamesEnum("route_withdraws_received"),
	UPDATES_SENT:             Bgpv4MetricsRequestColumnNamesEnum("updates_sent"),
	UPDATES_RECEIVED:         Bgpv4MetricsRequestColumnNamesEnum("updates_received"),
	OPENS_SENT:               Bgpv4MetricsRequestColumnNamesEnum("opens_sent"),
	OPENS_RECEIVED:           Bgpv4MetricsRequestColumnNamesEnum("opens_received"),
	KEEPALIVES_SENT:          Bgpv4MetricsRequestColumnNamesEnum("keepalives_sent"),
	KEEPALIVES_RECEIVED:      Bgpv4MetricsRequestColumnNamesEnum("keepalives_received"),
	NOTIFICATIONS_SENT:       Bgpv4MetricsRequestColumnNamesEnum("notifications_sent"),
	NOTIFICATIONS_RECEIVED:   Bgpv4MetricsRequestColumnNamesEnum("notifications_received"),
}
View Source 
var Bgpv6MetricSessionState = struct {
	UP   Bgpv6MetricSessionStateEnum
	DOWN Bgpv6MetricSessionStateEnum
}{
	UP:   Bgpv6MetricSessionStateEnum("up"),
	DOWN: Bgpv6MetricSessionStateEnum("down"),
}
View Source 
var Bgpv6MetricsRequestColumnNames = struct {
	SESSION_STATE            Bgpv6MetricsRequestColumnNamesEnum
	SESSION_FLAP_COUNT       Bgpv6MetricsRequestColumnNamesEnum
	ROUTES_ADVERTISED        Bgpv6MetricsRequestColumnNamesEnum
	ROUTES_RECEIVED          Bgpv6MetricsRequestColumnNamesEnum
	ROUTE_WITHDRAWS_SENT     Bgpv6MetricsRequestColumnNamesEnum
	ROUTE_WITHDRAWS_RECEIVED Bgpv6MetricsRequestColumnNamesEnum
	UPDATES_SENT             Bgpv6MetricsRequestColumnNamesEnum
	UPDATES_RECEIVED         Bgpv6MetricsRequestColumnNamesEnum
	OPENS_SENT               Bgpv6MetricsRequestColumnNamesEnum
	OPENS_RECEIVED           Bgpv6MetricsRequestColumnNamesEnum
	KEEPALIVES_SENT          Bgpv6MetricsRequestColumnNamesEnum
	KEEPALIVES_RECEIVED      Bgpv6MetricsRequestColumnNamesEnum
	NOTIFICATIONS_SENT       Bgpv6MetricsRequestColumnNamesEnum
	NOTIFICATIONS_RECEIVED   Bgpv6MetricsRequestColumnNamesEnum
}{
	SESSION_STATE:            Bgpv6MetricsRequestColumnNamesEnum("session_state"),
	SESSION_FLAP_COUNT:       Bgpv6MetricsRequestColumnNamesEnum("session_flap_count"),
	ROUTES_ADVERTISED:        Bgpv6MetricsRequestColumnNamesEnum("routes_advertised"),
	ROUTES_RECEIVED:          Bgpv6MetricsRequestColumnNamesEnum("routes_received"),
	ROUTE_WITHDRAWS_SENT:     Bgpv6MetricsRequestColumnNamesEnum("route_withdraws_sent"),
	ROUTE_WITHDRAWS_RECEIVED: Bgpv6MetricsRequestColumnNamesEnum("route_withdraws_received"),
	UPDATES_SENT:             Bgpv6MetricsRequestColumnNamesEnum("updates_sent"),
	UPDATES_RECEIVED:         Bgpv6MetricsRequestColumnNamesEnum("updates_received"),
	OPENS_SENT:               Bgpv6MetricsRequestColumnNamesEnum("opens_sent"),
	OPENS_RECEIVED:           Bgpv6MetricsRequestColumnNamesEnum("opens_received"),
	KEEPALIVES_SENT:          Bgpv6MetricsRequestColumnNamesEnum("keepalives_sent"),
	KEEPALIVES_RECEIVED:      Bgpv6MetricsRequestColumnNamesEnum("keepalives_received"),
	NOTIFICATIONS_SENT:       Bgpv6MetricsRequestColumnNamesEnum("notifications_sent"),
	NOTIFICATIONS_RECEIVED:   Bgpv6MetricsRequestColumnNamesEnum("notifications_received"),
}
View Source 
var CaptureFilterChoice = struct {
	CUSTOM   CaptureFilterChoiceEnum
	ETHERNET CaptureFilterChoiceEnum
	VLAN     CaptureFilterChoiceEnum
	IPV4     CaptureFilterChoiceEnum
	IPV6     CaptureFilterChoiceEnum
}{
	CUSTOM:   CaptureFilterChoiceEnum("custom"),
	ETHERNET: CaptureFilterChoiceEnum("ethernet"),
	VLAN:     CaptureFilterChoiceEnum("vlan"),
	IPV4:     CaptureFilterChoiceEnum("ipv4"),
	IPV6:     CaptureFilterChoiceEnum("ipv6"),
}
View Source 
var CaptureFormat = struct {
	PCAP   CaptureFormatEnum
	PCAPNG CaptureFormatEnum
}{
	PCAP:   CaptureFormatEnum("pcap"),
	PCAPNG: CaptureFormatEnum("pcapng"),
}
View Source 
var CaptureStateState = struct {
	START CaptureStateStateEnum
	STOP  CaptureStateStateEnum
}{
	START: CaptureStateStateEnum("start"),
	STOP:  CaptureStateStateEnum("stop"),
}
View Source 
var DeviceVlanTpid = struct {
	X8100 DeviceVlanTpidEnum
	X88A8 DeviceVlanTpidEnum
	X9100 DeviceVlanTpidEnum
	X9200 DeviceVlanTpidEnum
	X9300 DeviceVlanTpidEnum
}{
	X8100: DeviceVlanTpidEnum("x8100"),
	X88A8: DeviceVlanTpidEnum("x88A8"),
	X9100: DeviceVlanTpidEnum("x9100"),
	X9200: DeviceVlanTpidEnum("x9200"),
	X9300: DeviceVlanTpidEnum("x9300"),
}
View Source 
var FlowDelayChoice = struct {
	BYTES        FlowDelayChoiceEnum
	NANOSECONDS  FlowDelayChoiceEnum
	MICROSECONDS FlowDelayChoiceEnum
}{
	BYTES:        FlowDelayChoiceEnum("bytes"),
	NANOSECONDS:  FlowDelayChoiceEnum("nanoseconds"),
	MICROSECONDS: FlowDelayChoiceEnum("microseconds"),
}
View Source 
var FlowDurationChoice = struct {
	FIXED_PACKETS FlowDurationChoiceEnum
	FIXED_SECONDS FlowDurationChoiceEnum
	BURST         FlowDurationChoiceEnum
	CONTINUOUS    FlowDurationChoiceEnum
}{
	FIXED_PACKETS: FlowDurationChoiceEnum("fixed_packets"),
	FIXED_SECONDS: FlowDurationChoiceEnum("fixed_seconds"),
	BURST:         FlowDurationChoiceEnum("burst"),
	CONTINUOUS:    FlowDurationChoiceEnum("continuous"),
}
View Source 
var FlowDurationInterBurstGapChoice = struct {
	BYTES        FlowDurationInterBurstGapChoiceEnum
	NANOSECONDS  FlowDurationInterBurstGapChoiceEnum
	MICROSECONDS FlowDurationInterBurstGapChoiceEnum
}{
	BYTES:        FlowDurationInterBurstGapChoiceEnum("bytes"),
	NANOSECONDS:  FlowDurationInterBurstGapChoiceEnum("nanoseconds"),
	MICROSECONDS: FlowDurationInterBurstGapChoiceEnum("microseconds"),
}
View Source 
var FlowHeaderChoice = struct {
	CUSTOM        FlowHeaderChoiceEnum
	ETHERNET      FlowHeaderChoiceEnum
	VLAN          FlowHeaderChoiceEnum
	VXLAN         FlowHeaderChoiceEnum
	IPV4          FlowHeaderChoiceEnum
	IPV6          FlowHeaderChoiceEnum
	PFCPAUSE      FlowHeaderChoiceEnum
	ETHERNETPAUSE FlowHeaderChoiceEnum
	TCP           FlowHeaderChoiceEnum
	UDP           FlowHeaderChoiceEnum
	GRE           FlowHeaderChoiceEnum
	GTPV1         FlowHeaderChoiceEnum
	GTPV2         FlowHeaderChoiceEnum
	ARP           FlowHeaderChoiceEnum
	ICMP          FlowHeaderChoiceEnum
	ICMPV6        FlowHeaderChoiceEnum
	PPP           FlowHeaderChoiceEnum
	IGMPV1        FlowHeaderChoiceEnum
}{
	CUSTOM:        FlowHeaderChoiceEnum("custom"),
	ETHERNET:      FlowHeaderChoiceEnum("ethernet"),
	VLAN:          FlowHeaderChoiceEnum("vlan"),
	VXLAN:         FlowHeaderChoiceEnum("vxlan"),
	IPV4:          FlowHeaderChoiceEnum("ipv4"),
	IPV6:          FlowHeaderChoiceEnum("ipv6"),
	PFCPAUSE:      FlowHeaderChoiceEnum("pfcpause"),
	ETHERNETPAUSE: FlowHeaderChoiceEnum("ethernetpause"),
	TCP:           FlowHeaderChoiceEnum("tcp"),
	UDP:           FlowHeaderChoiceEnum("udp"),
	GRE:           FlowHeaderChoiceEnum("gre"),
	GTPV1:         FlowHeaderChoiceEnum("gtpv1"),
	GTPV2:         FlowHeaderChoiceEnum("gtpv2"),
	ARP:           FlowHeaderChoiceEnum("arp"),
	ICMP:          FlowHeaderChoiceEnum("icmp"),
	ICMPV6:        FlowHeaderChoiceEnum("icmpv6"),
	PPP:           FlowHeaderChoiceEnum("ppp"),
	IGMPV1:        FlowHeaderChoiceEnum("igmpv1"),
}
View Source 
var FlowIcmpChoice = struct {
	ECHO FlowIcmpChoiceEnum
}{
	ECHO: FlowIcmpChoiceEnum("echo"),
}
View Source 
var FlowIcmpv6Choice = struct {
	ECHO FlowIcmpv6ChoiceEnum
}{
	ECHO: FlowIcmpv6ChoiceEnum("echo"),
}
View Source 
var FlowIpv4PriorityChoice = struct {
	RAW  FlowIpv4PriorityChoiceEnum
	TOS  FlowIpv4PriorityChoiceEnum
	DSCP FlowIpv4PriorityChoiceEnum
}{
	RAW:  FlowIpv4PriorityChoiceEnum("raw"),
	TOS:  FlowIpv4PriorityChoiceEnum("tos"),
	DSCP: FlowIpv4PriorityChoiceEnum("dscp"),
}
View Source 
var FlowLatencyMetricsMode = struct {
	STORE_FORWARD FlowLatencyMetricsModeEnum
	CUT_THROUGH   FlowLatencyMetricsModeEnum
}{
	STORE_FORWARD: FlowLatencyMetricsModeEnum("store_forward"),
	CUT_THROUGH:   FlowLatencyMetricsModeEnum("cut_through"),
}
View Source 
var FlowMetricGroupRequestChoice = struct {
	INGRESS FlowMetricGroupRequestChoiceEnum
	EGRESS  FlowMetricGroupRequestChoiceEnum
}{
	INGRESS: FlowMetricGroupRequestChoiceEnum("ingress"),
	EGRESS:  FlowMetricGroupRequestChoiceEnum("egress"),
}
View Source 
var FlowMetricTransmit = struct {
	STARTED FlowMetricTransmitEnum
	STOPPED FlowMetricTransmitEnum
	PAUSED  FlowMetricTransmitEnum
}{
	STARTED: FlowMetricTransmitEnum("started"),
	STOPPED: FlowMetricTransmitEnum("stopped"),
	PAUSED:  FlowMetricTransmitEnum("paused"),
}
View Source 
var FlowMetricsRequestMetricNames = struct {
	TRANSMIT       FlowMetricsRequestMetricNamesEnum
	FRAMES_TX      FlowMetricsRequestMetricNamesEnum
	FRAMES_RX      FlowMetricsRequestMetricNamesEnum
	BYTES_TX       FlowMetricsRequestMetricNamesEnum
	BYTES_RX       FlowMetricsRequestMetricNamesEnum
	FRAMES_TX_RATE FlowMetricsRequestMetricNamesEnum
	FRAMES_RX_RATE FlowMetricsRequestMetricNamesEnum
}{
	TRANSMIT:       FlowMetricsRequestMetricNamesEnum("transmit"),
	FRAMES_TX:      FlowMetricsRequestMetricNamesEnum("frames_tx"),
	FRAMES_RX:      FlowMetricsRequestMetricNamesEnum("frames_rx"),
	BYTES_TX:       FlowMetricsRequestMetricNamesEnum("bytes_tx"),
	BYTES_RX:       FlowMetricsRequestMetricNamesEnum("bytes_rx"),
	FRAMES_TX_RATE: FlowMetricsRequestMetricNamesEnum("frames_tx_rate"),
	FRAMES_RX_RATE: FlowMetricsRequestMetricNamesEnum("frames_rx_rate"),
}
View Source 
var FlowRateChoice = struct {
	PPS        FlowRateChoiceEnum
	BPS        FlowRateChoiceEnum
	KBPS       FlowRateChoiceEnum
	MBPS       FlowRateChoiceEnum
	GBPS       FlowRateChoiceEnum
	PERCENTAGE FlowRateChoiceEnum
}{
	PPS:        FlowRateChoiceEnum("pps"),
	BPS:        FlowRateChoiceEnum("bps"),
	KBPS:       FlowRateChoiceEnum("kbps"),
	MBPS:       FlowRateChoiceEnum("mbps"),
	GBPS:       FlowRateChoiceEnum("gbps"),
	PERCENTAGE: FlowRateChoiceEnum("percentage"),
}
View Source 
var FlowRouterMode = struct {
	MESH       FlowRouterModeEnum
	ONE_TO_ONE FlowRouterModeEnum
}{
	MESH:       FlowRouterModeEnum("mesh"),
	ONE_TO_ONE: FlowRouterModeEnum("one_to_one"),
}
View Source 
var FlowSizeChoice = struct {
	FIXED     FlowSizeChoiceEnum
	INCREMENT FlowSizeChoiceEnum
	RANDOM    FlowSizeChoiceEnum
}{
	FIXED:     FlowSizeChoiceEnum("fixed"),
	INCREMENT: FlowSizeChoiceEnum("increment"),
	RANDOM:    FlowSizeChoiceEnum("random"),
}
View Source 
var FlowStateTransmit = struct {
	STARTED FlowStateTransmitEnum
	STOPPED FlowStateTransmitEnum
	PAUSED  FlowStateTransmitEnum
}{
	STARTED: FlowStateTransmitEnum("started"),
	STOPPED: FlowStateTransmitEnum("stopped"),
	PAUSED:  FlowStateTransmitEnum("paused"),
}
View Source 
var FlowTxRxChoice = struct {
	PORT   FlowTxRxChoiceEnum
	DEVICE FlowTxRxChoiceEnum
}{
	PORT:   FlowTxRxChoiceEnum("port"),
	DEVICE: FlowTxRxChoiceEnum("device"),
}
View Source 
var FlowsUpdatePropertyNames = struct {
	RATE FlowsUpdatePropertyNamesEnum
	SIZE FlowsUpdatePropertyNamesEnum
}{
	RATE: FlowsUpdatePropertyNamesEnum("rate"),
	SIZE: FlowsUpdatePropertyNamesEnum("size"),
}
View Source 
var IsisAuthenticationBaseChoice = struct {
	MD5      IsisAuthenticationBaseChoiceEnum
	PASSWORD IsisAuthenticationBaseChoiceEnum
}{
	MD5:      IsisAuthenticationBaseChoiceEnum("md5"),
	PASSWORD: IsisAuthenticationBaseChoiceEnum("password"),
}
View Source 
var IsisInterfaceAuthenticationChoice = struct {
	MD5      IsisInterfaceAuthenticationChoiceEnum
	PASSWORD IsisInterfaceAuthenticationChoiceEnum
}{
	MD5:      IsisInterfaceAuthenticationChoiceEnum("md5"),
	PASSWORD: IsisInterfaceAuthenticationChoiceEnum("password"),
}
View Source 
var IsisInterfaceLevelType = struct {
	LEVEL_1   IsisInterfaceLevelTypeEnum
	LEVEL_2   IsisInterfaceLevelTypeEnum
	LEVEL_1_2 IsisInterfaceLevelTypeEnum
}{
	LEVEL_1:   IsisInterfaceLevelTypeEnum("level_1"),
	LEVEL_2:   IsisInterfaceLevelTypeEnum("level_2"),
	LEVEL_1_2: IsisInterfaceLevelTypeEnum("level_1_2"),
}
View Source 
var IsisInterfaceNetworkType = struct {
	BROADCAST      IsisInterfaceNetworkTypeEnum
	POINT_TO_POINT IsisInterfaceNetworkTypeEnum
}{
	BROADCAST:      IsisInterfaceNetworkTypeEnum("broadcast"),
	POINT_TO_POINT: IsisInterfaceNetworkTypeEnum("point_to_point"),
}
View Source 
var IsisV4RouteRangeRedistribution = struct {
	UP   IsisV4RouteRangeRedistributionEnum
	DOWN IsisV4RouteRangeRedistributionEnum
}{
	UP:   IsisV4RouteRangeRedistributionEnum("up"),
	DOWN: IsisV4RouteRangeRedistributionEnum("down"),
}
View Source 
var IsisV4RouteRangeRouteOrigin = struct {
	INTERNAL IsisV4RouteRangeRouteOriginEnum
	EXTERNAL IsisV4RouteRangeRouteOriginEnum
}{
	INTERNAL: IsisV4RouteRangeRouteOriginEnum("internal"),
	EXTERNAL: IsisV4RouteRangeRouteOriginEnum("external"),
}
View Source 
var IsisV6RouteRangeRedistribution = struct {
	UP   IsisV6RouteRangeRedistributionEnum
	DOWN IsisV6RouteRangeRedistributionEnum
}{
	UP:   IsisV6RouteRangeRedistributionEnum("up"),
	DOWN: IsisV6RouteRangeRedistributionEnum("down"),
}
View Source 
var IsisV6RouteRangeRouteOrigin = struct {
	INTERNAL IsisV6RouteRangeRouteOriginEnum
	EXTERNAL IsisV6RouteRangeRouteOriginEnum
}{
	INTERNAL: IsisV6RouteRangeRouteOriginEnum("internal"),
	EXTERNAL: IsisV6RouteRangeRouteOriginEnum("external"),
}
View Source 
var LagLacpActorActivity = struct {
	PASSIVE LagLacpActorActivityEnum
	ACTIVE  LagLacpActorActivityEnum
}{
	PASSIVE: LagLacpActorActivityEnum("passive"),
	ACTIVE:  LagLacpActorActivityEnum("active"),
}
View Source 
var LagProtocolChoice = struct {
	LACP   LagProtocolChoiceEnum
	STATIC LagProtocolChoiceEnum
}{
	LACP:   LagProtocolChoiceEnum("lacp"),
	STATIC: LagProtocolChoiceEnum("static"),
}
View Source 
var Layer1FlowControlChoice = struct {
	IEEE_802_1QBB Layer1FlowControlChoiceEnum
	IEEE_802_3X   Layer1FlowControlChoiceEnum
}{
	IEEE_802_1QBB: Layer1FlowControlChoiceEnum("ieee_802_1qbb"),
	IEEE_802_3X:   Layer1FlowControlChoiceEnum("ieee_802_3x"),
}
View Source 
var Layer1Media = struct {
	COPPER Layer1MediaEnum
	FIBER  Layer1MediaEnum
	SGMII  Layer1MediaEnum
}{
	COPPER: Layer1MediaEnum("copper"),
	FIBER:  Layer1MediaEnum("fiber"),
	SGMII:  Layer1MediaEnum("sgmii"),
}
View Source 
var Layer1Speed = struct {
	SPEED_10_FD_MBPS  Layer1SpeedEnum
	SPEED_10_HD_MBPS  Layer1SpeedEnum
	SPEED_100_FD_MBPS Layer1SpeedEnum
	SPEED_100_HD_MBPS Layer1SpeedEnum
	SPEED_1_GBPS      Layer1SpeedEnum
	SPEED_10_GBPS     Layer1SpeedEnum
	SPEED_25_GBPS     Layer1SpeedEnum
	SPEED_40_GBPS     Layer1SpeedEnum
	SPEED_100_GBPS    Layer1SpeedEnum
	SPEED_200_GBPS    Layer1SpeedEnum
	SPEED_400_GBPS    Layer1SpeedEnum
}{
	SPEED_10_FD_MBPS:  Layer1SpeedEnum("speed_10_fd_mbps"),
	SPEED_10_HD_MBPS:  Layer1SpeedEnum("speed_10_hd_mbps"),
	SPEED_100_FD_MBPS: Layer1SpeedEnum("speed_100_fd_mbps"),
	SPEED_100_HD_MBPS: Layer1SpeedEnum("speed_100_hd_mbps"),
	SPEED_1_GBPS:      Layer1SpeedEnum("speed_1_gbps"),
	SPEED_10_GBPS:     Layer1SpeedEnum("speed_10_gbps"),
	SPEED_25_GBPS:     Layer1SpeedEnum("speed_25_gbps"),
	SPEED_40_GBPS:     Layer1SpeedEnum("speed_40_gbps"),
	SPEED_100_GBPS:    Layer1SpeedEnum("speed_100_gbps"),
	SPEED_200_GBPS:    Layer1SpeedEnum("speed_200_gbps"),
	SPEED_400_GBPS:    Layer1SpeedEnum("speed_400_gbps"),
}
View Source 
var LinkStateState = struct {
	UP   LinkStateStateEnum
	DOWN LinkStateStateEnum
}{
	UP:   LinkStateStateEnum("up"),
	DOWN: LinkStateStateEnum("down"),
}
View Source 
var MetricsRequestChoice = struct {
	PORT  MetricsRequestChoiceEnum
	FLOW  MetricsRequestChoiceEnum
	BGPV4 MetricsRequestChoiceEnum
	BGPV6 MetricsRequestChoiceEnum
}{
	PORT:  MetricsRequestChoiceEnum("port"),
	FLOW:  MetricsRequestChoiceEnum("flow"),
	BGPV4: MetricsRequestChoiceEnum("bgpv4"),
	BGPV6: MetricsRequestChoiceEnum("bgpv6"),
}
View Source 
var MetricsResponseChoice = struct {
	FLOW_METRICS  MetricsResponseChoiceEnum
	PORT_METRICS  MetricsResponseChoiceEnum
	BGPV4_METRICS MetricsResponseChoiceEnum
	BGPV6_METRICS MetricsResponseChoiceEnum
}{
	FLOW_METRICS:  MetricsResponseChoiceEnum("flow_metrics"),
	PORT_METRICS:  MetricsResponseChoiceEnum("port_metrics"),
	BGPV4_METRICS: MetricsResponseChoiceEnum("bgpv4_metrics"),
	BGPV6_METRICS: MetricsResponseChoiceEnum("bgpv6_metrics"),
}
View Source 
var PatternFlowArpHardwareLengthChoice = struct {
	VALUE     PatternFlowArpHardwareLengthChoiceEnum
	VALUES    PatternFlowArpHardwareLengthChoiceEnum
	INCREMENT PatternFlowArpHardwareLengthChoiceEnum
	DECREMENT PatternFlowArpHardwareLengthChoiceEnum
}{
	VALUE:     PatternFlowArpHardwareLengthChoiceEnum("value"),
	VALUES:    PatternFlowArpHardwareLengthChoiceEnum("values"),
	INCREMENT: PatternFlowArpHardwareLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowArpHardwareLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpHardwareTypeChoice = struct {
	VALUE     PatternFlowArpHardwareTypeChoiceEnum
	VALUES    PatternFlowArpHardwareTypeChoiceEnum
	INCREMENT PatternFlowArpHardwareTypeChoiceEnum
	DECREMENT PatternFlowArpHardwareTypeChoiceEnum
}{
	VALUE:     PatternFlowArpHardwareTypeChoiceEnum("value"),
	VALUES:    PatternFlowArpHardwareTypeChoiceEnum("values"),
	INCREMENT: PatternFlowArpHardwareTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowArpHardwareTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpOperationChoice = struct {
	VALUE     PatternFlowArpOperationChoiceEnum
	VALUES    PatternFlowArpOperationChoiceEnum
	INCREMENT PatternFlowArpOperationChoiceEnum
	DECREMENT PatternFlowArpOperationChoiceEnum
}{
	VALUE:     PatternFlowArpOperationChoiceEnum("value"),
	VALUES:    PatternFlowArpOperationChoiceEnum("values"),
	INCREMENT: PatternFlowArpOperationChoiceEnum("increment"),
	DECREMENT: PatternFlowArpOperationChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpProtocolLengthChoice = struct {
	VALUE     PatternFlowArpProtocolLengthChoiceEnum
	VALUES    PatternFlowArpProtocolLengthChoiceEnum
	INCREMENT PatternFlowArpProtocolLengthChoiceEnum
	DECREMENT PatternFlowArpProtocolLengthChoiceEnum
}{
	VALUE:     PatternFlowArpProtocolLengthChoiceEnum("value"),
	VALUES:    PatternFlowArpProtocolLengthChoiceEnum("values"),
	INCREMENT: PatternFlowArpProtocolLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowArpProtocolLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpProtocolTypeChoice = struct {
	VALUE     PatternFlowArpProtocolTypeChoiceEnum
	VALUES    PatternFlowArpProtocolTypeChoiceEnum
	INCREMENT PatternFlowArpProtocolTypeChoiceEnum
	DECREMENT PatternFlowArpProtocolTypeChoiceEnum
}{
	VALUE:     PatternFlowArpProtocolTypeChoiceEnum("value"),
	VALUES:    PatternFlowArpProtocolTypeChoiceEnum("values"),
	INCREMENT: PatternFlowArpProtocolTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowArpProtocolTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpSenderHardwareAddrChoice = struct {
	VALUE     PatternFlowArpSenderHardwareAddrChoiceEnum
	VALUES    PatternFlowArpSenderHardwareAddrChoiceEnum
	INCREMENT PatternFlowArpSenderHardwareAddrChoiceEnum
	DECREMENT PatternFlowArpSenderHardwareAddrChoiceEnum
}{
	VALUE:     PatternFlowArpSenderHardwareAddrChoiceEnum("value"),
	VALUES:    PatternFlowArpSenderHardwareAddrChoiceEnum("values"),
	INCREMENT: PatternFlowArpSenderHardwareAddrChoiceEnum("increment"),
	DECREMENT: PatternFlowArpSenderHardwareAddrChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpSenderProtocolAddrChoice = struct {
	VALUE     PatternFlowArpSenderProtocolAddrChoiceEnum
	VALUES    PatternFlowArpSenderProtocolAddrChoiceEnum
	INCREMENT PatternFlowArpSenderProtocolAddrChoiceEnum
	DECREMENT PatternFlowArpSenderProtocolAddrChoiceEnum
}{
	VALUE:     PatternFlowArpSenderProtocolAddrChoiceEnum("value"),
	VALUES:    PatternFlowArpSenderProtocolAddrChoiceEnum("values"),
	INCREMENT: PatternFlowArpSenderProtocolAddrChoiceEnum("increment"),
	DECREMENT: PatternFlowArpSenderProtocolAddrChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpTargetHardwareAddrChoice = struct {
	VALUE     PatternFlowArpTargetHardwareAddrChoiceEnum
	VALUES    PatternFlowArpTargetHardwareAddrChoiceEnum
	INCREMENT PatternFlowArpTargetHardwareAddrChoiceEnum
	DECREMENT PatternFlowArpTargetHardwareAddrChoiceEnum
}{
	VALUE:     PatternFlowArpTargetHardwareAddrChoiceEnum("value"),
	VALUES:    PatternFlowArpTargetHardwareAddrChoiceEnum("values"),
	INCREMENT: PatternFlowArpTargetHardwareAddrChoiceEnum("increment"),
	DECREMENT: PatternFlowArpTargetHardwareAddrChoiceEnum("decrement"),
}
View Source 
var PatternFlowArpTargetProtocolAddrChoice = struct {
	VALUE     PatternFlowArpTargetProtocolAddrChoiceEnum
	VALUES    PatternFlowArpTargetProtocolAddrChoiceEnum
	INCREMENT PatternFlowArpTargetProtocolAddrChoiceEnum
	DECREMENT PatternFlowArpTargetProtocolAddrChoiceEnum
}{
	VALUE:     PatternFlowArpTargetProtocolAddrChoiceEnum("value"),
	VALUES:    PatternFlowArpTargetProtocolAddrChoiceEnum("values"),
	INCREMENT: PatternFlowArpTargetProtocolAddrChoiceEnum("increment"),
	DECREMENT: PatternFlowArpTargetProtocolAddrChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetDstChoice = struct {
	VALUE     PatternFlowEthernetDstChoiceEnum
	VALUES    PatternFlowEthernetDstChoiceEnum
	INCREMENT PatternFlowEthernetDstChoiceEnum
	DECREMENT PatternFlowEthernetDstChoiceEnum
}{
	VALUE:     PatternFlowEthernetDstChoiceEnum("value"),
	VALUES:    PatternFlowEthernetDstChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetDstChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetDstChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetEtherTypeAuto = struct {
	AUTO PatternFlowEthernetEtherTypeAutoEnum
}{
	AUTO: PatternFlowEthernetEtherTypeAutoEnum("auto"),
}
View Source 
var PatternFlowEthernetEtherTypeChoice = struct {
	VALUE     PatternFlowEthernetEtherTypeChoiceEnum
	VALUES    PatternFlowEthernetEtherTypeChoiceEnum
	AUTO      PatternFlowEthernetEtherTypeChoiceEnum
	INCREMENT PatternFlowEthernetEtherTypeChoiceEnum
	DECREMENT PatternFlowEthernetEtherTypeChoiceEnum
}{
	VALUE:     PatternFlowEthernetEtherTypeChoiceEnum("value"),
	VALUES:    PatternFlowEthernetEtherTypeChoiceEnum("values"),
	AUTO:      PatternFlowEthernetEtherTypeChoiceEnum("auto"),
	INCREMENT: PatternFlowEthernetEtherTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetEtherTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPauseControlOpCodeChoice = struct {
	VALUE     PatternFlowEthernetPauseControlOpCodeChoiceEnum
	VALUES    PatternFlowEthernetPauseControlOpCodeChoiceEnum
	INCREMENT PatternFlowEthernetPauseControlOpCodeChoiceEnum
	DECREMENT PatternFlowEthernetPauseControlOpCodeChoiceEnum
}{
	VALUE:     PatternFlowEthernetPauseControlOpCodeChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPauseControlOpCodeChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPauseControlOpCodeChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPauseControlOpCodeChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPauseDstChoice = struct {
	VALUE     PatternFlowEthernetPauseDstChoiceEnum
	VALUES    PatternFlowEthernetPauseDstChoiceEnum
	INCREMENT PatternFlowEthernetPauseDstChoiceEnum
	DECREMENT PatternFlowEthernetPauseDstChoiceEnum
}{
	VALUE:     PatternFlowEthernetPauseDstChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPauseDstChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPauseDstChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPauseDstChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPauseEtherTypeChoice = struct {
	VALUE     PatternFlowEthernetPauseEtherTypeChoiceEnum
	VALUES    PatternFlowEthernetPauseEtherTypeChoiceEnum
	INCREMENT PatternFlowEthernetPauseEtherTypeChoiceEnum
	DECREMENT PatternFlowEthernetPauseEtherTypeChoiceEnum
}{
	VALUE:     PatternFlowEthernetPauseEtherTypeChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPauseEtherTypeChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPauseEtherTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPauseEtherTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPauseSrcChoice = struct {
	VALUE     PatternFlowEthernetPauseSrcChoiceEnum
	VALUES    PatternFlowEthernetPauseSrcChoiceEnum
	INCREMENT PatternFlowEthernetPauseSrcChoiceEnum
	DECREMENT PatternFlowEthernetPauseSrcChoiceEnum
}{
	VALUE:     PatternFlowEthernetPauseSrcChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPauseSrcChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPauseSrcChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPauseSrcChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPauseTimeChoice = struct {
	VALUE     PatternFlowEthernetPauseTimeChoiceEnum
	VALUES    PatternFlowEthernetPauseTimeChoiceEnum
	INCREMENT PatternFlowEthernetPauseTimeChoiceEnum
	DECREMENT PatternFlowEthernetPauseTimeChoiceEnum
}{
	VALUE:     PatternFlowEthernetPauseTimeChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPauseTimeChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPauseTimeChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPauseTimeChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetPfcQueueChoice = struct {
	VALUE     PatternFlowEthernetPfcQueueChoiceEnum
	VALUES    PatternFlowEthernetPfcQueueChoiceEnum
	INCREMENT PatternFlowEthernetPfcQueueChoiceEnum
	DECREMENT PatternFlowEthernetPfcQueueChoiceEnum
}{
	VALUE:     PatternFlowEthernetPfcQueueChoiceEnum("value"),
	VALUES:    PatternFlowEthernetPfcQueueChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetPfcQueueChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetPfcQueueChoiceEnum("decrement"),
}
View Source 
var PatternFlowEthernetSrcChoice = struct {
	VALUE     PatternFlowEthernetSrcChoiceEnum
	VALUES    PatternFlowEthernetSrcChoiceEnum
	INCREMENT PatternFlowEthernetSrcChoiceEnum
	DECREMENT PatternFlowEthernetSrcChoiceEnum
}{
	VALUE:     PatternFlowEthernetSrcChoiceEnum("value"),
	VALUES:    PatternFlowEthernetSrcChoiceEnum("values"),
	INCREMENT: PatternFlowEthernetSrcChoiceEnum("increment"),
	DECREMENT: PatternFlowEthernetSrcChoiceEnum("decrement"),
}
View Source 
var PatternFlowGreChecksumChoice = struct {
	GENERATED PatternFlowGreChecksumChoiceEnum
	CUSTOM    PatternFlowGreChecksumChoiceEnum
}{
	GENERATED: PatternFlowGreChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowGreChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowGreChecksumGenerated = struct {
	GOOD PatternFlowGreChecksumGeneratedEnum
	BAD  PatternFlowGreChecksumGeneratedEnum
}{
	GOOD: PatternFlowGreChecksumGeneratedEnum("good"),
	BAD:  PatternFlowGreChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowGreChecksumPresentChoice = struct {
	VALUE     PatternFlowGreChecksumPresentChoiceEnum
	VALUES    PatternFlowGreChecksumPresentChoiceEnum
	INCREMENT PatternFlowGreChecksumPresentChoiceEnum
	DECREMENT PatternFlowGreChecksumPresentChoiceEnum
}{
	VALUE:     PatternFlowGreChecksumPresentChoiceEnum("value"),
	VALUES:    PatternFlowGreChecksumPresentChoiceEnum("values"),
	INCREMENT: PatternFlowGreChecksumPresentChoiceEnum("increment"),
	DECREMENT: PatternFlowGreChecksumPresentChoiceEnum("decrement"),
}
View Source 
var PatternFlowGreProtocolChoice = struct {
	VALUE     PatternFlowGreProtocolChoiceEnum
	VALUES    PatternFlowGreProtocolChoiceEnum
	INCREMENT PatternFlowGreProtocolChoiceEnum
	DECREMENT PatternFlowGreProtocolChoiceEnum
}{
	VALUE:     PatternFlowGreProtocolChoiceEnum("value"),
	VALUES:    PatternFlowGreProtocolChoiceEnum("values"),
	INCREMENT: PatternFlowGreProtocolChoiceEnum("increment"),
	DECREMENT: PatternFlowGreProtocolChoiceEnum("decrement"),
}
View Source 
var PatternFlowGreReserved0Choice = struct {
	VALUE     PatternFlowGreReserved0ChoiceEnum
	VALUES    PatternFlowGreReserved0ChoiceEnum
	INCREMENT PatternFlowGreReserved0ChoiceEnum
	DECREMENT PatternFlowGreReserved0ChoiceEnum
}{
	VALUE:     PatternFlowGreReserved0ChoiceEnum("value"),
	VALUES:    PatternFlowGreReserved0ChoiceEnum("values"),
	INCREMENT: PatternFlowGreReserved0ChoiceEnum("increment"),
	DECREMENT: PatternFlowGreReserved0ChoiceEnum("decrement"),
}
View Source 
var PatternFlowGreReserved1Choice = struct {
	VALUE     PatternFlowGreReserved1ChoiceEnum
	VALUES    PatternFlowGreReserved1ChoiceEnum
	INCREMENT PatternFlowGreReserved1ChoiceEnum
	DECREMENT PatternFlowGreReserved1ChoiceEnum
}{
	VALUE:     PatternFlowGreReserved1ChoiceEnum("value"),
	VALUES:    PatternFlowGreReserved1ChoiceEnum("values"),
	INCREMENT: PatternFlowGreReserved1ChoiceEnum("increment"),
	DECREMENT: PatternFlowGreReserved1ChoiceEnum("decrement"),
}
View Source 
var PatternFlowGreVersionChoice = struct {
	VALUE     PatternFlowGreVersionChoiceEnum
	VALUES    PatternFlowGreVersionChoiceEnum
	INCREMENT PatternFlowGreVersionChoiceEnum
	DECREMENT PatternFlowGreVersionChoiceEnum
}{
	VALUE:     PatternFlowGreVersionChoiceEnum("value"),
	VALUES:    PatternFlowGreVersionChoiceEnum("values"),
	INCREMENT: PatternFlowGreVersionChoiceEnum("increment"),
	DECREMENT: PatternFlowGreVersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpExtensionContentsChoice = struct {
	VALUE     PatternFlowGtpExtensionContentsChoiceEnum
	VALUES    PatternFlowGtpExtensionContentsChoiceEnum
	INCREMENT PatternFlowGtpExtensionContentsChoiceEnum
	DECREMENT PatternFlowGtpExtensionContentsChoiceEnum
}{
	VALUE:     PatternFlowGtpExtensionContentsChoiceEnum("value"),
	VALUES:    PatternFlowGtpExtensionContentsChoiceEnum("values"),
	INCREMENT: PatternFlowGtpExtensionContentsChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpExtensionContentsChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpExtensionExtensionLengthChoice = struct {
	VALUE     PatternFlowGtpExtensionExtensionLengthChoiceEnum
	VALUES    PatternFlowGtpExtensionExtensionLengthChoiceEnum
	INCREMENT PatternFlowGtpExtensionExtensionLengthChoiceEnum
	DECREMENT PatternFlowGtpExtensionExtensionLengthChoiceEnum
}{
	VALUE:     PatternFlowGtpExtensionExtensionLengthChoiceEnum("value"),
	VALUES:    PatternFlowGtpExtensionExtensionLengthChoiceEnum("values"),
	INCREMENT: PatternFlowGtpExtensionExtensionLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpExtensionExtensionLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpExtensionNextExtensionHeaderChoice = struct {
	VALUE     PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum
	VALUES    PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum
	INCREMENT PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum
	DECREMENT PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum
}{
	VALUE:     PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum("value"),
	VALUES:    PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum("values"),
	INCREMENT: PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1EFlagChoice = struct {
	VALUE     PatternFlowGtpv1EFlagChoiceEnum
	VALUES    PatternFlowGtpv1EFlagChoiceEnum
	INCREMENT PatternFlowGtpv1EFlagChoiceEnum
	DECREMENT PatternFlowGtpv1EFlagChoiceEnum
}{
	VALUE:     PatternFlowGtpv1EFlagChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1EFlagChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1EFlagChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1EFlagChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1MessageLengthChoice = struct {
	VALUE     PatternFlowGtpv1MessageLengthChoiceEnum
	VALUES    PatternFlowGtpv1MessageLengthChoiceEnum
	INCREMENT PatternFlowGtpv1MessageLengthChoiceEnum
	DECREMENT PatternFlowGtpv1MessageLengthChoiceEnum
}{
	VALUE:     PatternFlowGtpv1MessageLengthChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1MessageLengthChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1MessageLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1MessageLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1MessageTypeChoice = struct {
	VALUE     PatternFlowGtpv1MessageTypeChoiceEnum
	VALUES    PatternFlowGtpv1MessageTypeChoiceEnum
	INCREMENT PatternFlowGtpv1MessageTypeChoiceEnum
	DECREMENT PatternFlowGtpv1MessageTypeChoiceEnum
}{
	VALUE:     PatternFlowGtpv1MessageTypeChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1MessageTypeChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1MessageTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1MessageTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1NPduNumberChoice = struct {
	VALUE     PatternFlowGtpv1NPduNumberChoiceEnum
	VALUES    PatternFlowGtpv1NPduNumberChoiceEnum
	INCREMENT PatternFlowGtpv1NPduNumberChoiceEnum
	DECREMENT PatternFlowGtpv1NPduNumberChoiceEnum
}{
	VALUE:     PatternFlowGtpv1NPduNumberChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1NPduNumberChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1NPduNumberChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1NPduNumberChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1NextExtensionHeaderTypeChoice = struct {
	VALUE     PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum
	VALUES    PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum
	INCREMENT PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum
	DECREMENT PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum
}{
	VALUE:     PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1PnFlagChoice = struct {
	VALUE     PatternFlowGtpv1PnFlagChoiceEnum
	VALUES    PatternFlowGtpv1PnFlagChoiceEnum
	INCREMENT PatternFlowGtpv1PnFlagChoiceEnum
	DECREMENT PatternFlowGtpv1PnFlagChoiceEnum
}{
	VALUE:     PatternFlowGtpv1PnFlagChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1PnFlagChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1PnFlagChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1PnFlagChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1ProtocolTypeChoice = struct {
	VALUE     PatternFlowGtpv1ProtocolTypeChoiceEnum
	VALUES    PatternFlowGtpv1ProtocolTypeChoiceEnum
	INCREMENT PatternFlowGtpv1ProtocolTypeChoiceEnum
	DECREMENT PatternFlowGtpv1ProtocolTypeChoiceEnum
}{
	VALUE:     PatternFlowGtpv1ProtocolTypeChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1ProtocolTypeChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1ProtocolTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1ProtocolTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1ReservedChoice = struct {
	VALUE     PatternFlowGtpv1ReservedChoiceEnum
	VALUES    PatternFlowGtpv1ReservedChoiceEnum
	INCREMENT PatternFlowGtpv1ReservedChoiceEnum
	DECREMENT PatternFlowGtpv1ReservedChoiceEnum
}{
	VALUE:     PatternFlowGtpv1ReservedChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1ReservedChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1ReservedChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1ReservedChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1SFlagChoice = struct {
	VALUE     PatternFlowGtpv1SFlagChoiceEnum
	VALUES    PatternFlowGtpv1SFlagChoiceEnum
	INCREMENT PatternFlowGtpv1SFlagChoiceEnum
	DECREMENT PatternFlowGtpv1SFlagChoiceEnum
}{
	VALUE:     PatternFlowGtpv1SFlagChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1SFlagChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1SFlagChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1SFlagChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1SquenceNumberChoice = struct {
	VALUE     PatternFlowGtpv1SquenceNumberChoiceEnum
	VALUES    PatternFlowGtpv1SquenceNumberChoiceEnum
	INCREMENT PatternFlowGtpv1SquenceNumberChoiceEnum
	DECREMENT PatternFlowGtpv1SquenceNumberChoiceEnum
}{
	VALUE:     PatternFlowGtpv1SquenceNumberChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1SquenceNumberChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1SquenceNumberChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1SquenceNumberChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1TeidChoice = struct {
	VALUE     PatternFlowGtpv1TeidChoiceEnum
	VALUES    PatternFlowGtpv1TeidChoiceEnum
	INCREMENT PatternFlowGtpv1TeidChoiceEnum
	DECREMENT PatternFlowGtpv1TeidChoiceEnum
}{
	VALUE:     PatternFlowGtpv1TeidChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1TeidChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1TeidChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1TeidChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv1VersionChoice = struct {
	VALUE     PatternFlowGtpv1VersionChoiceEnum
	VALUES    PatternFlowGtpv1VersionChoiceEnum
	INCREMENT PatternFlowGtpv1VersionChoiceEnum
	DECREMENT PatternFlowGtpv1VersionChoiceEnum
}{
	VALUE:     PatternFlowGtpv1VersionChoiceEnum("value"),
	VALUES:    PatternFlowGtpv1VersionChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv1VersionChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv1VersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2MessageLengthChoice = struct {
	VALUE     PatternFlowGtpv2MessageLengthChoiceEnum
	VALUES    PatternFlowGtpv2MessageLengthChoiceEnum
	INCREMENT PatternFlowGtpv2MessageLengthChoiceEnum
	DECREMENT PatternFlowGtpv2MessageLengthChoiceEnum
}{
	VALUE:     PatternFlowGtpv2MessageLengthChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2MessageLengthChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2MessageLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2MessageLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2MessageTypeChoice = struct {
	VALUE     PatternFlowGtpv2MessageTypeChoiceEnum
	VALUES    PatternFlowGtpv2MessageTypeChoiceEnum
	INCREMENT PatternFlowGtpv2MessageTypeChoiceEnum
	DECREMENT PatternFlowGtpv2MessageTypeChoiceEnum
}{
	VALUE:     PatternFlowGtpv2MessageTypeChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2MessageTypeChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2MessageTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2MessageTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2PiggybackingFlagChoice = struct {
	VALUE     PatternFlowGtpv2PiggybackingFlagChoiceEnum
	VALUES    PatternFlowGtpv2PiggybackingFlagChoiceEnum
	INCREMENT PatternFlowGtpv2PiggybackingFlagChoiceEnum
	DECREMENT PatternFlowGtpv2PiggybackingFlagChoiceEnum
}{
	VALUE:     PatternFlowGtpv2PiggybackingFlagChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2PiggybackingFlagChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2PiggybackingFlagChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2PiggybackingFlagChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2SequenceNumberChoice = struct {
	VALUE     PatternFlowGtpv2SequenceNumberChoiceEnum
	VALUES    PatternFlowGtpv2SequenceNumberChoiceEnum
	INCREMENT PatternFlowGtpv2SequenceNumberChoiceEnum
	DECREMENT PatternFlowGtpv2SequenceNumberChoiceEnum
}{
	VALUE:     PatternFlowGtpv2SequenceNumberChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2SequenceNumberChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2SequenceNumberChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2SequenceNumberChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2Spare1Choice = struct {
	VALUE     PatternFlowGtpv2Spare1ChoiceEnum
	VALUES    PatternFlowGtpv2Spare1ChoiceEnum
	INCREMENT PatternFlowGtpv2Spare1ChoiceEnum
	DECREMENT PatternFlowGtpv2Spare1ChoiceEnum
}{
	VALUE:     PatternFlowGtpv2Spare1ChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2Spare1ChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2Spare1ChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2Spare1ChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2Spare2Choice = struct {
	VALUE     PatternFlowGtpv2Spare2ChoiceEnum
	VALUES    PatternFlowGtpv2Spare2ChoiceEnum
	INCREMENT PatternFlowGtpv2Spare2ChoiceEnum
	DECREMENT PatternFlowGtpv2Spare2ChoiceEnum
}{
	VALUE:     PatternFlowGtpv2Spare2ChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2Spare2ChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2Spare2ChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2Spare2ChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2TeidChoice = struct {
	VALUE     PatternFlowGtpv2TeidChoiceEnum
	VALUES    PatternFlowGtpv2TeidChoiceEnum
	INCREMENT PatternFlowGtpv2TeidChoiceEnum
	DECREMENT PatternFlowGtpv2TeidChoiceEnum
}{
	VALUE:     PatternFlowGtpv2TeidChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2TeidChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2TeidChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2TeidChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2TeidFlagChoice = struct {
	VALUE     PatternFlowGtpv2TeidFlagChoiceEnum
	VALUES    PatternFlowGtpv2TeidFlagChoiceEnum
	INCREMENT PatternFlowGtpv2TeidFlagChoiceEnum
	DECREMENT PatternFlowGtpv2TeidFlagChoiceEnum
}{
	VALUE:     PatternFlowGtpv2TeidFlagChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2TeidFlagChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2TeidFlagChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2TeidFlagChoiceEnum("decrement"),
}
View Source 
var PatternFlowGtpv2VersionChoice = struct {
	VALUE     PatternFlowGtpv2VersionChoiceEnum
	VALUES    PatternFlowGtpv2VersionChoiceEnum
	INCREMENT PatternFlowGtpv2VersionChoiceEnum
	DECREMENT PatternFlowGtpv2VersionChoiceEnum
}{
	VALUE:     PatternFlowGtpv2VersionChoiceEnum("value"),
	VALUES:    PatternFlowGtpv2VersionChoiceEnum("values"),
	INCREMENT: PatternFlowGtpv2VersionChoiceEnum("increment"),
	DECREMENT: PatternFlowGtpv2VersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpEchoChecksumChoice = struct {
	GENERATED PatternFlowIcmpEchoChecksumChoiceEnum
	CUSTOM    PatternFlowIcmpEchoChecksumChoiceEnum
}{
	GENERATED: PatternFlowIcmpEchoChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowIcmpEchoChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowIcmpEchoChecksumGenerated = struct {
	GOOD PatternFlowIcmpEchoChecksumGeneratedEnum
	BAD  PatternFlowIcmpEchoChecksumGeneratedEnum
}{
	GOOD: PatternFlowIcmpEchoChecksumGeneratedEnum("good"),
	BAD:  PatternFlowIcmpEchoChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowIcmpEchoCodeChoice = struct {
	VALUE     PatternFlowIcmpEchoCodeChoiceEnum
	VALUES    PatternFlowIcmpEchoCodeChoiceEnum
	INCREMENT PatternFlowIcmpEchoCodeChoiceEnum
	DECREMENT PatternFlowIcmpEchoCodeChoiceEnum
}{
	VALUE:     PatternFlowIcmpEchoCodeChoiceEnum("value"),
	VALUES:    PatternFlowIcmpEchoCodeChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpEchoCodeChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpEchoCodeChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpEchoIdentifierChoice = struct {
	VALUE     PatternFlowIcmpEchoIdentifierChoiceEnum
	VALUES    PatternFlowIcmpEchoIdentifierChoiceEnum
	INCREMENT PatternFlowIcmpEchoIdentifierChoiceEnum
	DECREMENT PatternFlowIcmpEchoIdentifierChoiceEnum
}{
	VALUE:     PatternFlowIcmpEchoIdentifierChoiceEnum("value"),
	VALUES:    PatternFlowIcmpEchoIdentifierChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpEchoIdentifierChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpEchoIdentifierChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpEchoSequenceNumberChoice = struct {
	VALUE     PatternFlowIcmpEchoSequenceNumberChoiceEnum
	VALUES    PatternFlowIcmpEchoSequenceNumberChoiceEnum
	INCREMENT PatternFlowIcmpEchoSequenceNumberChoiceEnum
	DECREMENT PatternFlowIcmpEchoSequenceNumberChoiceEnum
}{
	VALUE:     PatternFlowIcmpEchoSequenceNumberChoiceEnum("value"),
	VALUES:    PatternFlowIcmpEchoSequenceNumberChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpEchoSequenceNumberChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpEchoSequenceNumberChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpEchoTypeChoice = struct {
	VALUE     PatternFlowIcmpEchoTypeChoiceEnum
	VALUES    PatternFlowIcmpEchoTypeChoiceEnum
	INCREMENT PatternFlowIcmpEchoTypeChoiceEnum
	DECREMENT PatternFlowIcmpEchoTypeChoiceEnum
}{
	VALUE:     PatternFlowIcmpEchoTypeChoiceEnum("value"),
	VALUES:    PatternFlowIcmpEchoTypeChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpEchoTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpEchoTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpv6EchoChecksumChoice = struct {
	GENERATED PatternFlowIcmpv6EchoChecksumChoiceEnum
	CUSTOM    PatternFlowIcmpv6EchoChecksumChoiceEnum
}{
	GENERATED: PatternFlowIcmpv6EchoChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowIcmpv6EchoChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowIcmpv6EchoChecksumGenerated = struct {
	GOOD PatternFlowIcmpv6EchoChecksumGeneratedEnum
	BAD  PatternFlowIcmpv6EchoChecksumGeneratedEnum
}{
	GOOD: PatternFlowIcmpv6EchoChecksumGeneratedEnum("good"),
	BAD:  PatternFlowIcmpv6EchoChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowIcmpv6EchoCodeChoice = struct {
	VALUE     PatternFlowIcmpv6EchoCodeChoiceEnum
	VALUES    PatternFlowIcmpv6EchoCodeChoiceEnum
	INCREMENT PatternFlowIcmpv6EchoCodeChoiceEnum
	DECREMENT PatternFlowIcmpv6EchoCodeChoiceEnum
}{
	VALUE:     PatternFlowIcmpv6EchoCodeChoiceEnum("value"),
	VALUES:    PatternFlowIcmpv6EchoCodeChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpv6EchoCodeChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpv6EchoCodeChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpv6EchoIdentifierChoice = struct {
	VALUE     PatternFlowIcmpv6EchoIdentifierChoiceEnum
	VALUES    PatternFlowIcmpv6EchoIdentifierChoiceEnum
	INCREMENT PatternFlowIcmpv6EchoIdentifierChoiceEnum
	DECREMENT PatternFlowIcmpv6EchoIdentifierChoiceEnum
}{
	VALUE:     PatternFlowIcmpv6EchoIdentifierChoiceEnum("value"),
	VALUES:    PatternFlowIcmpv6EchoIdentifierChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpv6EchoIdentifierChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpv6EchoIdentifierChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpv6EchoSequenceNumberChoice = struct {
	VALUE     PatternFlowIcmpv6EchoSequenceNumberChoiceEnum
	VALUES    PatternFlowIcmpv6EchoSequenceNumberChoiceEnum
	INCREMENT PatternFlowIcmpv6EchoSequenceNumberChoiceEnum
	DECREMENT PatternFlowIcmpv6EchoSequenceNumberChoiceEnum
}{
	VALUE:     PatternFlowIcmpv6EchoSequenceNumberChoiceEnum("value"),
	VALUES:    PatternFlowIcmpv6EchoSequenceNumberChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpv6EchoSequenceNumberChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpv6EchoSequenceNumberChoiceEnum("decrement"),
}
View Source 
var PatternFlowIcmpv6EchoTypeChoice = struct {
	VALUE     PatternFlowIcmpv6EchoTypeChoiceEnum
	VALUES    PatternFlowIcmpv6EchoTypeChoiceEnum
	INCREMENT PatternFlowIcmpv6EchoTypeChoiceEnum
	DECREMENT PatternFlowIcmpv6EchoTypeChoiceEnum
}{
	VALUE:     PatternFlowIcmpv6EchoTypeChoiceEnum("value"),
	VALUES:    PatternFlowIcmpv6EchoTypeChoiceEnum("values"),
	INCREMENT: PatternFlowIcmpv6EchoTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowIcmpv6EchoTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowIgmpv1ChecksumChoice = struct {
	GENERATED PatternFlowIgmpv1ChecksumChoiceEnum
	CUSTOM    PatternFlowIgmpv1ChecksumChoiceEnum
}{
	GENERATED: PatternFlowIgmpv1ChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowIgmpv1ChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowIgmpv1ChecksumGenerated = struct {
	GOOD PatternFlowIgmpv1ChecksumGeneratedEnum
	BAD  PatternFlowIgmpv1ChecksumGeneratedEnum
}{
	GOOD: PatternFlowIgmpv1ChecksumGeneratedEnum("good"),
	BAD:  PatternFlowIgmpv1ChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowIgmpv1GroupAddressChoice = struct {
	VALUE     PatternFlowIgmpv1GroupAddressChoiceEnum
	VALUES    PatternFlowIgmpv1GroupAddressChoiceEnum
	INCREMENT PatternFlowIgmpv1GroupAddressChoiceEnum
	DECREMENT PatternFlowIgmpv1GroupAddressChoiceEnum
}{
	VALUE:     PatternFlowIgmpv1GroupAddressChoiceEnum("value"),
	VALUES:    PatternFlowIgmpv1GroupAddressChoiceEnum("values"),
	INCREMENT: PatternFlowIgmpv1GroupAddressChoiceEnum("increment"),
	DECREMENT: PatternFlowIgmpv1GroupAddressChoiceEnum("decrement"),
}
View Source 
var PatternFlowIgmpv1TypeChoice = struct {
	VALUE     PatternFlowIgmpv1TypeChoiceEnum
	VALUES    PatternFlowIgmpv1TypeChoiceEnum
	INCREMENT PatternFlowIgmpv1TypeChoiceEnum
	DECREMENT PatternFlowIgmpv1TypeChoiceEnum
}{
	VALUE:     PatternFlowIgmpv1TypeChoiceEnum("value"),
	VALUES:    PatternFlowIgmpv1TypeChoiceEnum("values"),
	INCREMENT: PatternFlowIgmpv1TypeChoiceEnum("increment"),
	DECREMENT: PatternFlowIgmpv1TypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowIgmpv1UnusedChoice = struct {
	VALUE     PatternFlowIgmpv1UnusedChoiceEnum
	VALUES    PatternFlowIgmpv1UnusedChoiceEnum
	INCREMENT PatternFlowIgmpv1UnusedChoiceEnum
	DECREMENT PatternFlowIgmpv1UnusedChoiceEnum
}{
	VALUE:     PatternFlowIgmpv1UnusedChoiceEnum("value"),
	VALUES:    PatternFlowIgmpv1UnusedChoiceEnum("values"),
	INCREMENT: PatternFlowIgmpv1UnusedChoiceEnum("increment"),
	DECREMENT: PatternFlowIgmpv1UnusedChoiceEnum("decrement"),
}
View Source 
var PatternFlowIgmpv1VersionChoice = struct {
	VALUE     PatternFlowIgmpv1VersionChoiceEnum
	VALUES    PatternFlowIgmpv1VersionChoiceEnum
	INCREMENT PatternFlowIgmpv1VersionChoiceEnum
	DECREMENT PatternFlowIgmpv1VersionChoiceEnum
}{
	VALUE:     PatternFlowIgmpv1VersionChoiceEnum("value"),
	VALUES:    PatternFlowIgmpv1VersionChoiceEnum("values"),
	INCREMENT: PatternFlowIgmpv1VersionChoiceEnum("increment"),
	DECREMENT: PatternFlowIgmpv1VersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4DontFragmentChoice = struct {
	VALUE     PatternFlowIpv4DontFragmentChoiceEnum
	VALUES    PatternFlowIpv4DontFragmentChoiceEnum
	INCREMENT PatternFlowIpv4DontFragmentChoiceEnum
	DECREMENT PatternFlowIpv4DontFragmentChoiceEnum
}{
	VALUE:     PatternFlowIpv4DontFragmentChoiceEnum("value"),
	VALUES:    PatternFlowIpv4DontFragmentChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4DontFragmentChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4DontFragmentChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4DscpEcnChoice = struct {
	VALUE     PatternFlowIpv4DscpEcnChoiceEnum
	VALUES    PatternFlowIpv4DscpEcnChoiceEnum
	INCREMENT PatternFlowIpv4DscpEcnChoiceEnum
	DECREMENT PatternFlowIpv4DscpEcnChoiceEnum
}{
	VALUE:     PatternFlowIpv4DscpEcnChoiceEnum("value"),
	VALUES:    PatternFlowIpv4DscpEcnChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4DscpEcnChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4DscpEcnChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4DscpPhbChoice = struct {
	VALUE     PatternFlowIpv4DscpPhbChoiceEnum
	VALUES    PatternFlowIpv4DscpPhbChoiceEnum
	INCREMENT PatternFlowIpv4DscpPhbChoiceEnum
	DECREMENT PatternFlowIpv4DscpPhbChoiceEnum
}{
	VALUE:     PatternFlowIpv4DscpPhbChoiceEnum("value"),
	VALUES:    PatternFlowIpv4DscpPhbChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4DscpPhbChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4DscpPhbChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4DstChoice = struct {
	VALUE     PatternFlowIpv4DstChoiceEnum
	VALUES    PatternFlowIpv4DstChoiceEnum
	INCREMENT PatternFlowIpv4DstChoiceEnum
	DECREMENT PatternFlowIpv4DstChoiceEnum
}{
	VALUE:     PatternFlowIpv4DstChoiceEnum("value"),
	VALUES:    PatternFlowIpv4DstChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4DstChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4DstChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4FragmentOffsetChoice = struct {
	VALUE     PatternFlowIpv4FragmentOffsetChoiceEnum
	VALUES    PatternFlowIpv4FragmentOffsetChoiceEnum
	INCREMENT PatternFlowIpv4FragmentOffsetChoiceEnum
	DECREMENT PatternFlowIpv4FragmentOffsetChoiceEnum
}{
	VALUE:     PatternFlowIpv4FragmentOffsetChoiceEnum("value"),
	VALUES:    PatternFlowIpv4FragmentOffsetChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4FragmentOffsetChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4FragmentOffsetChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4HeaderChecksumChoice = struct {
	GENERATED PatternFlowIpv4HeaderChecksumChoiceEnum
	CUSTOM    PatternFlowIpv4HeaderChecksumChoiceEnum
}{
	GENERATED: PatternFlowIpv4HeaderChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowIpv4HeaderChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowIpv4HeaderChecksumGenerated = struct {
	GOOD PatternFlowIpv4HeaderChecksumGeneratedEnum
	BAD  PatternFlowIpv4HeaderChecksumGeneratedEnum
}{
	GOOD: PatternFlowIpv4HeaderChecksumGeneratedEnum("good"),
	BAD:  PatternFlowIpv4HeaderChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowIpv4HeaderLengthAuto = struct {
	AUTO PatternFlowIpv4HeaderLengthAutoEnum
}{
	AUTO: PatternFlowIpv4HeaderLengthAutoEnum("auto"),
}
View Source 
var PatternFlowIpv4HeaderLengthChoice = struct {
	VALUE     PatternFlowIpv4HeaderLengthChoiceEnum
	VALUES    PatternFlowIpv4HeaderLengthChoiceEnum
	AUTO      PatternFlowIpv4HeaderLengthChoiceEnum
	INCREMENT PatternFlowIpv4HeaderLengthChoiceEnum
	DECREMENT PatternFlowIpv4HeaderLengthChoiceEnum
}{
	VALUE:     PatternFlowIpv4HeaderLengthChoiceEnum("value"),
	VALUES:    PatternFlowIpv4HeaderLengthChoiceEnum("values"),
	AUTO:      PatternFlowIpv4HeaderLengthChoiceEnum("auto"),
	INCREMENT: PatternFlowIpv4HeaderLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4HeaderLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4IdentificationChoice = struct {
	VALUE     PatternFlowIpv4IdentificationChoiceEnum
	VALUES    PatternFlowIpv4IdentificationChoiceEnum
	INCREMENT PatternFlowIpv4IdentificationChoiceEnum
	DECREMENT PatternFlowIpv4IdentificationChoiceEnum
}{
	VALUE:     PatternFlowIpv4IdentificationChoiceEnum("value"),
	VALUES:    PatternFlowIpv4IdentificationChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4IdentificationChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4IdentificationChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4MoreFragmentsChoice = struct {
	VALUE     PatternFlowIpv4MoreFragmentsChoiceEnum
	VALUES    PatternFlowIpv4MoreFragmentsChoiceEnum
	INCREMENT PatternFlowIpv4MoreFragmentsChoiceEnum
	DECREMENT PatternFlowIpv4MoreFragmentsChoiceEnum
}{
	VALUE:     PatternFlowIpv4MoreFragmentsChoiceEnum("value"),
	VALUES:    PatternFlowIpv4MoreFragmentsChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4MoreFragmentsChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4MoreFragmentsChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4PriorityRawChoice = struct {
	VALUE     PatternFlowIpv4PriorityRawChoiceEnum
	VALUES    PatternFlowIpv4PriorityRawChoiceEnum
	INCREMENT PatternFlowIpv4PriorityRawChoiceEnum
	DECREMENT PatternFlowIpv4PriorityRawChoiceEnum
}{
	VALUE:     PatternFlowIpv4PriorityRawChoiceEnum("value"),
	VALUES:    PatternFlowIpv4PriorityRawChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4PriorityRawChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4PriorityRawChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4ProtocolAuto = struct {
	AUTO PatternFlowIpv4ProtocolAutoEnum
}{
	AUTO: PatternFlowIpv4ProtocolAutoEnum("auto"),
}
View Source 
var PatternFlowIpv4ProtocolChoice = struct {
	VALUE     PatternFlowIpv4ProtocolChoiceEnum
	VALUES    PatternFlowIpv4ProtocolChoiceEnum
	AUTO      PatternFlowIpv4ProtocolChoiceEnum
	INCREMENT PatternFlowIpv4ProtocolChoiceEnum
	DECREMENT PatternFlowIpv4ProtocolChoiceEnum
}{
	VALUE:     PatternFlowIpv4ProtocolChoiceEnum("value"),
	VALUES:    PatternFlowIpv4ProtocolChoiceEnum("values"),
	AUTO:      PatternFlowIpv4ProtocolChoiceEnum("auto"),
	INCREMENT: PatternFlowIpv4ProtocolChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4ProtocolChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4ReservedChoice = struct {
	VALUE     PatternFlowIpv4ReservedChoiceEnum
	VALUES    PatternFlowIpv4ReservedChoiceEnum
	INCREMENT PatternFlowIpv4ReservedChoiceEnum
	DECREMENT PatternFlowIpv4ReservedChoiceEnum
}{
	VALUE:     PatternFlowIpv4ReservedChoiceEnum("value"),
	VALUES:    PatternFlowIpv4ReservedChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4ReservedChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4ReservedChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4SrcChoice = struct {
	VALUE     PatternFlowIpv4SrcChoiceEnum
	VALUES    PatternFlowIpv4SrcChoiceEnum
	INCREMENT PatternFlowIpv4SrcChoiceEnum
	DECREMENT PatternFlowIpv4SrcChoiceEnum
}{
	VALUE:     PatternFlowIpv4SrcChoiceEnum("value"),
	VALUES:    PatternFlowIpv4SrcChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4SrcChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4SrcChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TimeToLiveChoice = struct {
	VALUE     PatternFlowIpv4TimeToLiveChoiceEnum
	VALUES    PatternFlowIpv4TimeToLiveChoiceEnum
	INCREMENT PatternFlowIpv4TimeToLiveChoiceEnum
	DECREMENT PatternFlowIpv4TimeToLiveChoiceEnum
}{
	VALUE:     PatternFlowIpv4TimeToLiveChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TimeToLiveChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TimeToLiveChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TimeToLiveChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosDelayChoice = struct {
	VALUE     PatternFlowIpv4TosDelayChoiceEnum
	VALUES    PatternFlowIpv4TosDelayChoiceEnum
	INCREMENT PatternFlowIpv4TosDelayChoiceEnum
	DECREMENT PatternFlowIpv4TosDelayChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosDelayChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosDelayChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosDelayChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosDelayChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosMonetaryChoice = struct {
	VALUE     PatternFlowIpv4TosMonetaryChoiceEnum
	VALUES    PatternFlowIpv4TosMonetaryChoiceEnum
	INCREMENT PatternFlowIpv4TosMonetaryChoiceEnum
	DECREMENT PatternFlowIpv4TosMonetaryChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosMonetaryChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosMonetaryChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosMonetaryChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosMonetaryChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosPrecedenceChoice = struct {
	VALUE     PatternFlowIpv4TosPrecedenceChoiceEnum
	VALUES    PatternFlowIpv4TosPrecedenceChoiceEnum
	INCREMENT PatternFlowIpv4TosPrecedenceChoiceEnum
	DECREMENT PatternFlowIpv4TosPrecedenceChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosPrecedenceChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosPrecedenceChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosPrecedenceChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosPrecedenceChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosReliabilityChoice = struct {
	VALUE     PatternFlowIpv4TosReliabilityChoiceEnum
	VALUES    PatternFlowIpv4TosReliabilityChoiceEnum
	INCREMENT PatternFlowIpv4TosReliabilityChoiceEnum
	DECREMENT PatternFlowIpv4TosReliabilityChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosReliabilityChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosReliabilityChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosReliabilityChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosReliabilityChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosThroughputChoice = struct {
	VALUE     PatternFlowIpv4TosThroughputChoiceEnum
	VALUES    PatternFlowIpv4TosThroughputChoiceEnum
	INCREMENT PatternFlowIpv4TosThroughputChoiceEnum
	DECREMENT PatternFlowIpv4TosThroughputChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosThroughputChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosThroughputChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosThroughputChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosThroughputChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TosUnusedChoice = struct {
	VALUE     PatternFlowIpv4TosUnusedChoiceEnum
	VALUES    PatternFlowIpv4TosUnusedChoiceEnum
	INCREMENT PatternFlowIpv4TosUnusedChoiceEnum
	DECREMENT PatternFlowIpv4TosUnusedChoiceEnum
}{
	VALUE:     PatternFlowIpv4TosUnusedChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TosUnusedChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4TosUnusedChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TosUnusedChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4TotalLengthAuto = struct {
	AUTO PatternFlowIpv4TotalLengthAutoEnum
}{
	AUTO: PatternFlowIpv4TotalLengthAutoEnum("auto"),
}
View Source 
var PatternFlowIpv4TotalLengthChoice = struct {
	VALUE     PatternFlowIpv4TotalLengthChoiceEnum
	VALUES    PatternFlowIpv4TotalLengthChoiceEnum
	AUTO      PatternFlowIpv4TotalLengthChoiceEnum
	INCREMENT PatternFlowIpv4TotalLengthChoiceEnum
	DECREMENT PatternFlowIpv4TotalLengthChoiceEnum
}{
	VALUE:     PatternFlowIpv4TotalLengthChoiceEnum("value"),
	VALUES:    PatternFlowIpv4TotalLengthChoiceEnum("values"),
	AUTO:      PatternFlowIpv4TotalLengthChoiceEnum("auto"),
	INCREMENT: PatternFlowIpv4TotalLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4TotalLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv4VersionChoice = struct {
	VALUE     PatternFlowIpv4VersionChoiceEnum
	VALUES    PatternFlowIpv4VersionChoiceEnum
	INCREMENT PatternFlowIpv4VersionChoiceEnum
	DECREMENT PatternFlowIpv4VersionChoiceEnum
}{
	VALUE:     PatternFlowIpv4VersionChoiceEnum("value"),
	VALUES:    PatternFlowIpv4VersionChoiceEnum("values"),
	INCREMENT: PatternFlowIpv4VersionChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv4VersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6DstChoice = struct {
	VALUE     PatternFlowIpv6DstChoiceEnum
	VALUES    PatternFlowIpv6DstChoiceEnum
	INCREMENT PatternFlowIpv6DstChoiceEnum
	DECREMENT PatternFlowIpv6DstChoiceEnum
}{
	VALUE:     PatternFlowIpv6DstChoiceEnum("value"),
	VALUES:    PatternFlowIpv6DstChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6DstChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6DstChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6FlowLabelChoice = struct {
	VALUE     PatternFlowIpv6FlowLabelChoiceEnum
	VALUES    PatternFlowIpv6FlowLabelChoiceEnum
	INCREMENT PatternFlowIpv6FlowLabelChoiceEnum
	DECREMENT PatternFlowIpv6FlowLabelChoiceEnum
}{
	VALUE:     PatternFlowIpv6FlowLabelChoiceEnum("value"),
	VALUES:    PatternFlowIpv6FlowLabelChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6FlowLabelChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6FlowLabelChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6HopLimitChoice = struct {
	VALUE     PatternFlowIpv6HopLimitChoiceEnum
	VALUES    PatternFlowIpv6HopLimitChoiceEnum
	INCREMENT PatternFlowIpv6HopLimitChoiceEnum
	DECREMENT PatternFlowIpv6HopLimitChoiceEnum
}{
	VALUE:     PatternFlowIpv6HopLimitChoiceEnum("value"),
	VALUES:    PatternFlowIpv6HopLimitChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6HopLimitChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6HopLimitChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6NextHeaderChoice = struct {
	VALUE     PatternFlowIpv6NextHeaderChoiceEnum
	VALUES    PatternFlowIpv6NextHeaderChoiceEnum
	INCREMENT PatternFlowIpv6NextHeaderChoiceEnum
	DECREMENT PatternFlowIpv6NextHeaderChoiceEnum
}{
	VALUE:     PatternFlowIpv6NextHeaderChoiceEnum("value"),
	VALUES:    PatternFlowIpv6NextHeaderChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6NextHeaderChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6NextHeaderChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6PayloadLengthAuto = struct {
	AUTO PatternFlowIpv6PayloadLengthAutoEnum
}{
	AUTO: PatternFlowIpv6PayloadLengthAutoEnum("auto"),
}
View Source 
var PatternFlowIpv6PayloadLengthChoice = struct {
	VALUE     PatternFlowIpv6PayloadLengthChoiceEnum
	VALUES    PatternFlowIpv6PayloadLengthChoiceEnum
	AUTO      PatternFlowIpv6PayloadLengthChoiceEnum
	INCREMENT PatternFlowIpv6PayloadLengthChoiceEnum
	DECREMENT PatternFlowIpv6PayloadLengthChoiceEnum
}{
	VALUE:     PatternFlowIpv6PayloadLengthChoiceEnum("value"),
	VALUES:    PatternFlowIpv6PayloadLengthChoiceEnum("values"),
	AUTO:      PatternFlowIpv6PayloadLengthChoiceEnum("auto"),
	INCREMENT: PatternFlowIpv6PayloadLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6PayloadLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6SrcChoice = struct {
	VALUE     PatternFlowIpv6SrcChoiceEnum
	VALUES    PatternFlowIpv6SrcChoiceEnum
	INCREMENT PatternFlowIpv6SrcChoiceEnum
	DECREMENT PatternFlowIpv6SrcChoiceEnum
}{
	VALUE:     PatternFlowIpv6SrcChoiceEnum("value"),
	VALUES:    PatternFlowIpv6SrcChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6SrcChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6SrcChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6TrafficClassChoice = struct {
	VALUE     PatternFlowIpv6TrafficClassChoiceEnum
	VALUES    PatternFlowIpv6TrafficClassChoiceEnum
	INCREMENT PatternFlowIpv6TrafficClassChoiceEnum
	DECREMENT PatternFlowIpv6TrafficClassChoiceEnum
}{
	VALUE:     PatternFlowIpv6TrafficClassChoiceEnum("value"),
	VALUES:    PatternFlowIpv6TrafficClassChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6TrafficClassChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6TrafficClassChoiceEnum("decrement"),
}
View Source 
var PatternFlowIpv6VersionChoice = struct {
	VALUE     PatternFlowIpv6VersionChoiceEnum
	VALUES    PatternFlowIpv6VersionChoiceEnum
	INCREMENT PatternFlowIpv6VersionChoiceEnum
	DECREMENT PatternFlowIpv6VersionChoiceEnum
}{
	VALUE:     PatternFlowIpv6VersionChoiceEnum("value"),
	VALUES:    PatternFlowIpv6VersionChoiceEnum("values"),
	INCREMENT: PatternFlowIpv6VersionChoiceEnum("increment"),
	DECREMENT: PatternFlowIpv6VersionChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPauseClassEnableVectorChoice = struct {
	VALUE     PatternFlowPfcPauseClassEnableVectorChoiceEnum
	VALUES    PatternFlowPfcPauseClassEnableVectorChoiceEnum
	INCREMENT PatternFlowPfcPauseClassEnableVectorChoiceEnum
	DECREMENT PatternFlowPfcPauseClassEnableVectorChoiceEnum
}{
	VALUE:     PatternFlowPfcPauseClassEnableVectorChoiceEnum("value"),
	VALUES:    PatternFlowPfcPauseClassEnableVectorChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPauseClassEnableVectorChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPauseClassEnableVectorChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPauseControlOpCodeChoice = struct {
	VALUE     PatternFlowPfcPauseControlOpCodeChoiceEnum
	VALUES    PatternFlowPfcPauseControlOpCodeChoiceEnum
	INCREMENT PatternFlowPfcPauseControlOpCodeChoiceEnum
	DECREMENT PatternFlowPfcPauseControlOpCodeChoiceEnum
}{
	VALUE:     PatternFlowPfcPauseControlOpCodeChoiceEnum("value"),
	VALUES:    PatternFlowPfcPauseControlOpCodeChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPauseControlOpCodeChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPauseControlOpCodeChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPauseDstChoice = struct {
	VALUE     PatternFlowPfcPauseDstChoiceEnum
	VALUES    PatternFlowPfcPauseDstChoiceEnum
	INCREMENT PatternFlowPfcPauseDstChoiceEnum
	DECREMENT PatternFlowPfcPauseDstChoiceEnum
}{
	VALUE:     PatternFlowPfcPauseDstChoiceEnum("value"),
	VALUES:    PatternFlowPfcPauseDstChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPauseDstChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPauseDstChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPauseEtherTypeChoice = struct {
	VALUE     PatternFlowPfcPauseEtherTypeChoiceEnum
	VALUES    PatternFlowPfcPauseEtherTypeChoiceEnum
	INCREMENT PatternFlowPfcPauseEtherTypeChoiceEnum
	DECREMENT PatternFlowPfcPauseEtherTypeChoiceEnum
}{
	VALUE:     PatternFlowPfcPauseEtherTypeChoiceEnum("value"),
	VALUES:    PatternFlowPfcPauseEtherTypeChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPauseEtherTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPauseEtherTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass0Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass0ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass0ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass0ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass0ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass0ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass0ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass0ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass0ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass1Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass1ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass1ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass1ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass1ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass1ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass1ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass1ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass1ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass2Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass2ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass2ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass2ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass2ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass2ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass2ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass2ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass2ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass3Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass3ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass3ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass3ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass3ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass3ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass3ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass3ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass3ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass4Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass4ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass4ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass4ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass4ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass4ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass4ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass4ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass4ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass5Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass5ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass5ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass5ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass5ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass5ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass5ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass5ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass5ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass6Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass6ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass6ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass6ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass6ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass6ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass6ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass6ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass6ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPausePauseClass7Choice = struct {
	VALUE     PatternFlowPfcPausePauseClass7ChoiceEnum
	VALUES    PatternFlowPfcPausePauseClass7ChoiceEnum
	INCREMENT PatternFlowPfcPausePauseClass7ChoiceEnum
	DECREMENT PatternFlowPfcPausePauseClass7ChoiceEnum
}{
	VALUE:     PatternFlowPfcPausePauseClass7ChoiceEnum("value"),
	VALUES:    PatternFlowPfcPausePauseClass7ChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPausePauseClass7ChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPausePauseClass7ChoiceEnum("decrement"),
}
View Source 
var PatternFlowPfcPauseSrcChoice = struct {
	VALUE     PatternFlowPfcPauseSrcChoiceEnum
	VALUES    PatternFlowPfcPauseSrcChoiceEnum
	INCREMENT PatternFlowPfcPauseSrcChoiceEnum
	DECREMENT PatternFlowPfcPauseSrcChoiceEnum
}{
	VALUE:     PatternFlowPfcPauseSrcChoiceEnum("value"),
	VALUES:    PatternFlowPfcPauseSrcChoiceEnum("values"),
	INCREMENT: PatternFlowPfcPauseSrcChoiceEnum("increment"),
	DECREMENT: PatternFlowPfcPauseSrcChoiceEnum("decrement"),
}
View Source 
var PatternFlowPppAddressChoice = struct {
	VALUE     PatternFlowPppAddressChoiceEnum
	VALUES    PatternFlowPppAddressChoiceEnum
	INCREMENT PatternFlowPppAddressChoiceEnum
	DECREMENT PatternFlowPppAddressChoiceEnum
}{
	VALUE:     PatternFlowPppAddressChoiceEnum("value"),
	VALUES:    PatternFlowPppAddressChoiceEnum("values"),
	INCREMENT: PatternFlowPppAddressChoiceEnum("increment"),
	DECREMENT: PatternFlowPppAddressChoiceEnum("decrement"),
}
View Source 
var PatternFlowPppControlChoice = struct {
	VALUE     PatternFlowPppControlChoiceEnum
	VALUES    PatternFlowPppControlChoiceEnum
	INCREMENT PatternFlowPppControlChoiceEnum
	DECREMENT PatternFlowPppControlChoiceEnum
}{
	VALUE:     PatternFlowPppControlChoiceEnum("value"),
	VALUES:    PatternFlowPppControlChoiceEnum("values"),
	INCREMENT: PatternFlowPppControlChoiceEnum("increment"),
	DECREMENT: PatternFlowPppControlChoiceEnum("decrement"),
}
View Source 
var PatternFlowPppProtocolTypeAuto = struct {
	AUTO PatternFlowPppProtocolTypeAutoEnum
}{
	AUTO: PatternFlowPppProtocolTypeAutoEnum("auto"),
}
View Source 
var PatternFlowPppProtocolTypeChoice = struct {
	VALUE     PatternFlowPppProtocolTypeChoiceEnum
	VALUES    PatternFlowPppProtocolTypeChoiceEnum
	AUTO      PatternFlowPppProtocolTypeChoiceEnum
	INCREMENT PatternFlowPppProtocolTypeChoiceEnum
	DECREMENT PatternFlowPppProtocolTypeChoiceEnum
}{
	VALUE:     PatternFlowPppProtocolTypeChoiceEnum("value"),
	VALUES:    PatternFlowPppProtocolTypeChoiceEnum("values"),
	AUTO:      PatternFlowPppProtocolTypeChoiceEnum("auto"),
	INCREMENT: PatternFlowPppProtocolTypeChoiceEnum("increment"),
	DECREMENT: PatternFlowPppProtocolTypeChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpAckNumChoice = struct {
	VALUE     PatternFlowTcpAckNumChoiceEnum
	VALUES    PatternFlowTcpAckNumChoiceEnum
	INCREMENT PatternFlowTcpAckNumChoiceEnum
	DECREMENT PatternFlowTcpAckNumChoiceEnum
}{
	VALUE:     PatternFlowTcpAckNumChoiceEnum("value"),
	VALUES:    PatternFlowTcpAckNumChoiceEnum("values"),
	INCREMENT: PatternFlowTcpAckNumChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpAckNumChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlAckChoice = struct {
	VALUE     PatternFlowTcpCtlAckChoiceEnum
	VALUES    PatternFlowTcpCtlAckChoiceEnum
	INCREMENT PatternFlowTcpCtlAckChoiceEnum
	DECREMENT PatternFlowTcpCtlAckChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlAckChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlAckChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlAckChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlAckChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlFinChoice = struct {
	VALUE     PatternFlowTcpCtlFinChoiceEnum
	VALUES    PatternFlowTcpCtlFinChoiceEnum
	INCREMENT PatternFlowTcpCtlFinChoiceEnum
	DECREMENT PatternFlowTcpCtlFinChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlFinChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlFinChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlFinChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlFinChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlPshChoice = struct {
	VALUE     PatternFlowTcpCtlPshChoiceEnum
	VALUES    PatternFlowTcpCtlPshChoiceEnum
	INCREMENT PatternFlowTcpCtlPshChoiceEnum
	DECREMENT PatternFlowTcpCtlPshChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlPshChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlPshChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlPshChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlPshChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlRstChoice = struct {
	VALUE     PatternFlowTcpCtlRstChoiceEnum
	VALUES    PatternFlowTcpCtlRstChoiceEnum
	INCREMENT PatternFlowTcpCtlRstChoiceEnum
	DECREMENT PatternFlowTcpCtlRstChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlRstChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlRstChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlRstChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlRstChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlSynChoice = struct {
	VALUE     PatternFlowTcpCtlSynChoiceEnum
	VALUES    PatternFlowTcpCtlSynChoiceEnum
	INCREMENT PatternFlowTcpCtlSynChoiceEnum
	DECREMENT PatternFlowTcpCtlSynChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlSynChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlSynChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlSynChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlSynChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpCtlUrgChoice = struct {
	VALUE     PatternFlowTcpCtlUrgChoiceEnum
	VALUES    PatternFlowTcpCtlUrgChoiceEnum
	INCREMENT PatternFlowTcpCtlUrgChoiceEnum
	DECREMENT PatternFlowTcpCtlUrgChoiceEnum
}{
	VALUE:     PatternFlowTcpCtlUrgChoiceEnum("value"),
	VALUES:    PatternFlowTcpCtlUrgChoiceEnum("values"),
	INCREMENT: PatternFlowTcpCtlUrgChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpCtlUrgChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpDataOffsetChoice = struct {
	VALUE     PatternFlowTcpDataOffsetChoiceEnum
	VALUES    PatternFlowTcpDataOffsetChoiceEnum
	INCREMENT PatternFlowTcpDataOffsetChoiceEnum
	DECREMENT PatternFlowTcpDataOffsetChoiceEnum
}{
	VALUE:     PatternFlowTcpDataOffsetChoiceEnum("value"),
	VALUES:    PatternFlowTcpDataOffsetChoiceEnum("values"),
	INCREMENT: PatternFlowTcpDataOffsetChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpDataOffsetChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpDstPortChoice = struct {
	VALUE     PatternFlowTcpDstPortChoiceEnum
	VALUES    PatternFlowTcpDstPortChoiceEnum
	INCREMENT PatternFlowTcpDstPortChoiceEnum
	DECREMENT PatternFlowTcpDstPortChoiceEnum
}{
	VALUE:     PatternFlowTcpDstPortChoiceEnum("value"),
	VALUES:    PatternFlowTcpDstPortChoiceEnum("values"),
	INCREMENT: PatternFlowTcpDstPortChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpDstPortChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpEcnCwrChoice = struct {
	VALUE     PatternFlowTcpEcnCwrChoiceEnum
	VALUES    PatternFlowTcpEcnCwrChoiceEnum
	INCREMENT PatternFlowTcpEcnCwrChoiceEnum
	DECREMENT PatternFlowTcpEcnCwrChoiceEnum
}{
	VALUE:     PatternFlowTcpEcnCwrChoiceEnum("value"),
	VALUES:    PatternFlowTcpEcnCwrChoiceEnum("values"),
	INCREMENT: PatternFlowTcpEcnCwrChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpEcnCwrChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpEcnEchoChoice = struct {
	VALUE     PatternFlowTcpEcnEchoChoiceEnum
	VALUES    PatternFlowTcpEcnEchoChoiceEnum
	INCREMENT PatternFlowTcpEcnEchoChoiceEnum
	DECREMENT PatternFlowTcpEcnEchoChoiceEnum
}{
	VALUE:     PatternFlowTcpEcnEchoChoiceEnum("value"),
	VALUES:    PatternFlowTcpEcnEchoChoiceEnum("values"),
	INCREMENT: PatternFlowTcpEcnEchoChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpEcnEchoChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpEcnNsChoice = struct {
	VALUE     PatternFlowTcpEcnNsChoiceEnum
	VALUES    PatternFlowTcpEcnNsChoiceEnum
	INCREMENT PatternFlowTcpEcnNsChoiceEnum
	DECREMENT PatternFlowTcpEcnNsChoiceEnum
}{
	VALUE:     PatternFlowTcpEcnNsChoiceEnum("value"),
	VALUES:    PatternFlowTcpEcnNsChoiceEnum("values"),
	INCREMENT: PatternFlowTcpEcnNsChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpEcnNsChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpSeqNumChoice = struct {
	VALUE     PatternFlowTcpSeqNumChoiceEnum
	VALUES    PatternFlowTcpSeqNumChoiceEnum
	INCREMENT PatternFlowTcpSeqNumChoiceEnum
	DECREMENT PatternFlowTcpSeqNumChoiceEnum
}{
	VALUE:     PatternFlowTcpSeqNumChoiceEnum("value"),
	VALUES:    PatternFlowTcpSeqNumChoiceEnum("values"),
	INCREMENT: PatternFlowTcpSeqNumChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpSeqNumChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpSrcPortChoice = struct {
	VALUE     PatternFlowTcpSrcPortChoiceEnum
	VALUES    PatternFlowTcpSrcPortChoiceEnum
	INCREMENT PatternFlowTcpSrcPortChoiceEnum
	DECREMENT PatternFlowTcpSrcPortChoiceEnum
}{
	VALUE:     PatternFlowTcpSrcPortChoiceEnum("value"),
	VALUES:    PatternFlowTcpSrcPortChoiceEnum("values"),
	INCREMENT: PatternFlowTcpSrcPortChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpSrcPortChoiceEnum("decrement"),
}
View Source 
var PatternFlowTcpWindowChoice = struct {
	VALUE     PatternFlowTcpWindowChoiceEnum
	VALUES    PatternFlowTcpWindowChoiceEnum
	INCREMENT PatternFlowTcpWindowChoiceEnum
	DECREMENT PatternFlowTcpWindowChoiceEnum
}{
	VALUE:     PatternFlowTcpWindowChoiceEnum("value"),
	VALUES:    PatternFlowTcpWindowChoiceEnum("values"),
	INCREMENT: PatternFlowTcpWindowChoiceEnum("increment"),
	DECREMENT: PatternFlowTcpWindowChoiceEnum("decrement"),
}
View Source 
var PatternFlowUdpChecksumChoice = struct {
	GENERATED PatternFlowUdpChecksumChoiceEnum
	CUSTOM    PatternFlowUdpChecksumChoiceEnum
}{
	GENERATED: PatternFlowUdpChecksumChoiceEnum("generated"),
	CUSTOM:    PatternFlowUdpChecksumChoiceEnum("custom"),
}
View Source 
var PatternFlowUdpChecksumGenerated = struct {
	GOOD PatternFlowUdpChecksumGeneratedEnum
	BAD  PatternFlowUdpChecksumGeneratedEnum
}{
	GOOD: PatternFlowUdpChecksumGeneratedEnum("good"),
	BAD:  PatternFlowUdpChecksumGeneratedEnum("bad"),
}
View Source 
var PatternFlowUdpDstPortChoice = struct {
	VALUE     PatternFlowUdpDstPortChoiceEnum
	VALUES    PatternFlowUdpDstPortChoiceEnum
	INCREMENT PatternFlowUdpDstPortChoiceEnum
	DECREMENT PatternFlowUdpDstPortChoiceEnum
}{
	VALUE:     PatternFlowUdpDstPortChoiceEnum("value"),
	VALUES:    PatternFlowUdpDstPortChoiceEnum("values"),
	INCREMENT: PatternFlowUdpDstPortChoiceEnum("increment"),
	DECREMENT: PatternFlowUdpDstPortChoiceEnum("decrement"),
}
View Source 
var PatternFlowUdpLengthChoice = struct {
	VALUE     PatternFlowUdpLengthChoiceEnum
	VALUES    PatternFlowUdpLengthChoiceEnum
	INCREMENT PatternFlowUdpLengthChoiceEnum
	DECREMENT PatternFlowUdpLengthChoiceEnum
}{
	VALUE:     PatternFlowUdpLengthChoiceEnum("value"),
	VALUES:    PatternFlowUdpLengthChoiceEnum("values"),
	INCREMENT: PatternFlowUdpLengthChoiceEnum("increment"),
	DECREMENT: PatternFlowUdpLengthChoiceEnum("decrement"),
}
View Source 
var PatternFlowUdpSrcPortChoice = struct {
	VALUE     PatternFlowUdpSrcPortChoiceEnum
	VALUES    PatternFlowUdpSrcPortChoiceEnum
	INCREMENT PatternFlowUdpSrcPortChoiceEnum
	DECREMENT PatternFlowUdpSrcPortChoiceEnum
}{
	VALUE:     PatternFlowUdpSrcPortChoiceEnum("value"),
	VALUES:    PatternFlowUdpSrcPortChoiceEnum("values"),
	INCREMENT: PatternFlowUdpSrcPortChoiceEnum("increment"),
	DECREMENT: PatternFlowUdpSrcPortChoiceEnum("decrement"),
}
View Source 
var PatternFlowVlanCfiChoice = struct {
	VALUE     PatternFlowVlanCfiChoiceEnum
	VALUES    PatternFlowVlanCfiChoiceEnum
	INCREMENT PatternFlowVlanCfiChoiceEnum
	DECREMENT PatternFlowVlanCfiChoiceEnum
}{
	VALUE:     PatternFlowVlanCfiChoiceEnum("value"),
	VALUES:    PatternFlowVlanCfiChoiceEnum("values"),
	INCREMENT: PatternFlowVlanCfiChoiceEnum("increment"),
	DECREMENT: PatternFlowVlanCfiChoiceEnum("decrement"),
}
View Source 
var PatternFlowVlanIdChoice = struct {
	VALUE     PatternFlowVlanIdChoiceEnum
	VALUES    PatternFlowVlanIdChoiceEnum
	INCREMENT PatternFlowVlanIdChoiceEnum
	DECREMENT PatternFlowVlanIdChoiceEnum
}{
	VALUE:     PatternFlowVlanIdChoiceEnum("value"),
	VALUES:    PatternFlowVlanIdChoiceEnum("values"),
	INCREMENT: PatternFlowVlanIdChoiceEnum("increment"),
	DECREMENT: PatternFlowVlanIdChoiceEnum("decrement"),
}
View Source 
var PatternFlowVlanPriorityChoice = struct {
	VALUE     PatternFlowVlanPriorityChoiceEnum
	VALUES    PatternFlowVlanPriorityChoiceEnum
	INCREMENT PatternFlowVlanPriorityChoiceEnum
	DECREMENT PatternFlowVlanPriorityChoiceEnum
}{
	VALUE:     PatternFlowVlanPriorityChoiceEnum("value"),
	VALUES:    PatternFlowVlanPriorityChoiceEnum("values"),
	INCREMENT: PatternFlowVlanPriorityChoiceEnum("increment"),
	DECREMENT: PatternFlowVlanPriorityChoiceEnum("decrement"),
}
View Source 
var PatternFlowVlanTpidChoice = struct {
	VALUE     PatternFlowVlanTpidChoiceEnum
	VALUES    PatternFlowVlanTpidChoiceEnum
	INCREMENT PatternFlowVlanTpidChoiceEnum
	DECREMENT PatternFlowVlanTpidChoiceEnum
}{
	VALUE:     PatternFlowVlanTpidChoiceEnum("value"),
	VALUES:    PatternFlowVlanTpidChoiceEnum("values"),
	INCREMENT: PatternFlowVlanTpidChoiceEnum("increment"),
	DECREMENT: PatternFlowVlanTpidChoiceEnum("decrement"),
}
View Source 
var PatternFlowVxlanFlagsChoice = struct {
	VALUE     PatternFlowVxlanFlagsChoiceEnum
	VALUES    PatternFlowVxlanFlagsChoiceEnum
	INCREMENT PatternFlowVxlanFlagsChoiceEnum
	DECREMENT PatternFlowVxlanFlagsChoiceEnum
}{
	VALUE:     PatternFlowVxlanFlagsChoiceEnum("value"),
	VALUES:    PatternFlowVxlanFlagsChoiceEnum("values"),
	INCREMENT: PatternFlowVxlanFlagsChoiceEnum("increment"),
	DECREMENT: PatternFlowVxlanFlagsChoiceEnum("decrement"),
}
View Source 
var PatternFlowVxlanReserved0Choice = struct {
	VALUE     PatternFlowVxlanReserved0ChoiceEnum
	VALUES    PatternFlowVxlanReserved0ChoiceEnum
	INCREMENT PatternFlowVxlanReserved0ChoiceEnum
	DECREMENT PatternFlowVxlanReserved0ChoiceEnum
}{
	VALUE:     PatternFlowVxlanReserved0ChoiceEnum("value"),
	VALUES:    PatternFlowVxlanReserved0ChoiceEnum("values"),
	INCREMENT: PatternFlowVxlanReserved0ChoiceEnum("increment"),
	DECREMENT: PatternFlowVxlanReserved0ChoiceEnum("decrement"),
}
View Source 
var PatternFlowVxlanReserved1Choice = struct {
	VALUE     PatternFlowVxlanReserved1ChoiceEnum
	VALUES    PatternFlowVxlanReserved1ChoiceEnum
	INCREMENT PatternFlowVxlanReserved1ChoiceEnum
	DECREMENT PatternFlowVxlanReserved1ChoiceEnum
}{
	VALUE:     PatternFlowVxlanReserved1ChoiceEnum("value"),
	VALUES:    PatternFlowVxlanReserved1ChoiceEnum("values"),
	INCREMENT: PatternFlowVxlanReserved1ChoiceEnum("increment"),
	DECREMENT: PatternFlowVxlanReserved1ChoiceEnum("decrement"),
}
View Source 
var PatternFlowVxlanVniChoice = struct {
	VALUE     PatternFlowVxlanVniChoiceEnum
	VALUES    PatternFlowVxlanVniChoiceEnum
	INCREMENT PatternFlowVxlanVniChoiceEnum
	DECREMENT PatternFlowVxlanVniChoiceEnum
}{
	VALUE:     PatternFlowVxlanVniChoiceEnum("value"),
	VALUES:    PatternFlowVxlanVniChoiceEnum("values"),
	INCREMENT: PatternFlowVxlanVniChoiceEnum("increment"),
	DECREMENT: PatternFlowVxlanVniChoiceEnum("decrement"),
}
View Source 
var PingChoice = struct {
	IPV4 PingChoiceEnum
	IPV6 PingChoiceEnum
}{
	IPV4: PingChoiceEnum("ipv4"),
	IPV6: PingChoiceEnum("ipv6"),
}
View Source 
var PortMetricCapture = struct {
	STARTED PortMetricCaptureEnum
	STOPPED PortMetricCaptureEnum
}{
	STARTED: PortMetricCaptureEnum("started"),
	STOPPED: PortMetricCaptureEnum("stopped"),
}
View Source 
var PortMetricLink = struct {
	UP   PortMetricLinkEnum
	DOWN PortMetricLinkEnum
}{
	UP:   PortMetricLinkEnum("up"),
	DOWN: PortMetricLinkEnum("down"),
}
View Source 
var PortMetricsRequestColumnNames = struct {
	TRANSMIT       PortMetricsRequestColumnNamesEnum
	LOCATION       PortMetricsRequestColumnNamesEnum
	LINK           PortMetricsRequestColumnNamesEnum
	CAPTURE        PortMetricsRequestColumnNamesEnum
	FRAMES_TX      PortMetricsRequestColumnNamesEnum
	FRAMES_RX      PortMetricsRequestColumnNamesEnum
	BYTES_TX       PortMetricsRequestColumnNamesEnum
	BYTES_RX       PortMetricsRequestColumnNamesEnum
	FRAMES_TX_RATE PortMetricsRequestColumnNamesEnum
	FRAMES_RX_RATE PortMetricsRequestColumnNamesEnum
	BYTES_TX_RATE  PortMetricsRequestColumnNamesEnum
	BYTES_RX_RATE  PortMetricsRequestColumnNamesEnum
}{
	TRANSMIT:       PortMetricsRequestColumnNamesEnum("transmit"),
	LOCATION:       PortMetricsRequestColumnNamesEnum("location"),
	LINK:           PortMetricsRequestColumnNamesEnum("link"),
	CAPTURE:        PortMetricsRequestColumnNamesEnum("capture"),
	FRAMES_TX:      PortMetricsRequestColumnNamesEnum("frames_tx"),
	FRAMES_RX:      PortMetricsRequestColumnNamesEnum("frames_rx"),
	BYTES_TX:       PortMetricsRequestColumnNamesEnum("bytes_tx"),
	BYTES_RX:       PortMetricsRequestColumnNamesEnum("bytes_rx"),
	FRAMES_TX_RATE: PortMetricsRequestColumnNamesEnum("frames_tx_rate"),
	FRAMES_RX_RATE: PortMetricsRequestColumnNamesEnum("frames_rx_rate"),
	BYTES_TX_RATE:  PortMetricsRequestColumnNamesEnum("bytes_tx_rate"),
	BYTES_RX_RATE:  PortMetricsRequestColumnNamesEnum("bytes_rx_rate"),
}
View Source 
var PortStateCapture = struct {
	STARTED PortStateCaptureEnum
	STOPPED PortStateCaptureEnum
}{
	STARTED: PortStateCaptureEnum("started"),
	STOPPED: PortStateCaptureEnum("stopped"),
}
View Source 
var PortStateLink = struct {
	UP   PortStateLinkEnum
	DOWN PortStateLinkEnum
}{
	UP:   PortStateLinkEnum("up"),
	DOWN: PortStateLinkEnum("down"),
}
View Source 
var ProtocolStateState = struct {
	START ProtocolStateStateEnum
	STOP  ProtocolStateStateEnum
}{
	START: ProtocolStateStateEnum("start"),
	STOP:  ProtocolStateStateEnum("stop"),
}
View Source 
var ResponseResult = struct {
	SUCCESS ResponseResultEnum
	FAILURE ResponseResultEnum
}{
	SUCCESS: ResponseResultEnum("success"),
	FAILURE: ResponseResultEnum("failure"),
}
View Source 
var RouteStateState = struct {
	WITHDRAW  RouteStateStateEnum
	ADVERTISE RouteStateStateEnum
}{
	WITHDRAW:  RouteStateStateEnum("withdraw"),
	ADVERTISE: RouteStateStateEnum("advertise"),
}
View Source 
var TransmitStateState = struct {
	START TransmitStateStateEnum
	STOP  TransmitStateStateEnum
	PAUSE TransmitStateStateEnum
}{
	START: TransmitStateStateEnum("start"),
	STOP:  TransmitStateStateEnum("stop"),
	PAUSE: TransmitStateStateEnum("pause"),
}

Functions

func StartMockGrpcServer 

func StartMockGrpcServer(location string) error

func StartMockHttpServer 

func StartMockHttpServer(location string)

Types

type Api 

type Api interface {
	NewGrpcTransport() GrpcTransport

	NewHttpTransport() HttpTransport
	// contains filtered or unexported methods
}

type BgpAddPath added in v0.6.1 

type BgpAddPath interface {
	Msg() *snappipb.BgpAddPath
	SetMsg(*snappipb.BgpAddPath) BgpAddPath
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PathId() int32
	SetPathId(value int32) BgpAddPath
	HasPathId() bool
	// contains filtered or unexported methods
}

func NewBgpAddPath added in v0.6.5 

func NewBgpAddPath() BgpAddPath

type BgpAdvanced added in v0.6.1 

type BgpAdvanced interface {
	Msg() *snappipb.BgpAdvanced
	SetMsg(*snappipb.BgpAdvanced) BgpAdvanced
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	HoldTimeInterval() int32
	SetHoldTimeInterval(value int32) BgpAdvanced
	HasHoldTimeInterval() bool
	KeepAliveInterval() int32
	SetKeepAliveInterval(value int32) BgpAdvanced
	HasKeepAliveInterval() bool
	UpdateInterval() int32
	SetUpdateInterval(value int32) BgpAdvanced
	HasUpdateInterval() bool
	TimeToLive() int32
	SetTimeToLive(value int32) BgpAdvanced
	HasTimeToLive() bool
	Md5Key() string
	SetMd5Key(value string) BgpAdvanced
	HasMd5Key() bool
	// contains filtered or unexported methods
}

func NewBgpAdvanced added in v0.6.5 

func NewBgpAdvanced() BgpAdvanced

type BgpAsPath added in v0.6.1 

type BgpAsPath interface {
	Msg() *snappipb.BgpAsPath
	SetMsg(*snappipb.BgpAsPath) BgpAsPath
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	AsSetMode() BgpAsPathAsSetModeEnum
	SetAsSetMode(value BgpAsPathAsSetModeEnum) BgpAsPath
	HasAsSetMode() bool
	Segments() BgpAsPathBgpAsPathSegmentIter
	// contains filtered or unexported methods
}

func NewBgpAsPath added in v0.6.5 

func NewBgpAsPath() BgpAsPath

type BgpAsPathAsSetModeEnum added in v0.6.1 

type BgpAsPathAsSetModeEnum string

type BgpAsPathBgpAsPathSegmentIter added in v0.6.1 

type BgpAsPathBgpAsPathSegmentIter interface {
	Add() BgpAsPathSegment
	Items() []BgpAsPathSegment
}

type BgpAsPathSegment added in v0.6.1 

type BgpAsPathSegment interface {
	Msg() *snappipb.BgpAsPathSegment
	SetMsg(*snappipb.BgpAsPathSegment) BgpAsPathSegment
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Type() BgpAsPathSegmentTypeEnum
	SetType(value BgpAsPathSegmentTypeEnum) BgpAsPathSegment
	HasType() bool
	AsNumbers() []int64
	SetAsNumbers(value []int64) BgpAsPathSegment
	// contains filtered or unexported methods
}

func NewBgpAsPathSegment added in v0.6.5 

func NewBgpAsPathSegment() BgpAsPathSegment

type BgpAsPathSegmentTypeEnum added in v0.6.1 

type BgpAsPathSegmentTypeEnum string

type BgpCapability added in v0.6.1 

type BgpCapability interface {
	Msg() *snappipb.BgpCapability
	SetMsg(*snappipb.BgpCapability) BgpCapability
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ipv4Unicast() bool
	SetIpv4Unicast(value bool) BgpCapability
	HasIpv4Unicast() bool
	Ipv4Multicast() bool
	SetIpv4Multicast(value bool) BgpCapability
	HasIpv4Multicast() bool
	Ipv6Unicast() bool
	SetIpv6Unicast(value bool) BgpCapability
	HasIpv6Unicast() bool
	Ipv6Multicast() bool
	SetIpv6Multicast(value bool) BgpCapability
	HasIpv6Multicast() bool
	Vpls() bool
	SetVpls(value bool) BgpCapability
	HasVpls() bool
	RouteRefresh() bool
	SetRouteRefresh(value bool) BgpCapability
	HasRouteRefresh() bool
	RouteConstraint() bool
	SetRouteConstraint(value bool) BgpCapability
	HasRouteConstraint() bool
	LinkStateNonVpn() bool
	SetLinkStateNonVpn(value bool) BgpCapability
	HasLinkStateNonVpn() bool
	LinkStateVpn() bool
	SetLinkStateVpn(value bool) BgpCapability
	HasLinkStateVpn() bool
	Evpn() bool
	SetEvpn(value bool) BgpCapability
	HasEvpn() bool
	ExtendedNextHopEncoding() bool
	SetExtendedNextHopEncoding(value bool) BgpCapability
	HasExtendedNextHopEncoding() bool
	Ipv4MulticastVpn() bool
	SetIpv4MulticastVpn(value bool) BgpCapability
	HasIpv4MulticastVpn() bool
	Ipv4MplsVpn() bool
	SetIpv4MplsVpn(value bool) BgpCapability
	HasIpv4MplsVpn() bool
	Ipv4Mdt() bool
	SetIpv4Mdt(value bool) BgpCapability
	HasIpv4Mdt() bool
	Ipv4MulticastMplsVpn() bool
	SetIpv4MulticastMplsVpn(value bool) BgpCapability
	HasIpv4MulticastMplsVpn() bool
	Ipv4UnicastFlowSpec() bool
	SetIpv4UnicastFlowSpec(value bool) BgpCapability
	HasIpv4UnicastFlowSpec() bool
	Ipv4SrTePolicy() bool
	SetIpv4SrTePolicy(value bool) BgpCapability
	HasIpv4SrTePolicy() bool
	Ipv4UnicastAddPath() bool
	SetIpv4UnicastAddPath(value bool) BgpCapability
	HasIpv4UnicastAddPath() bool
	Ipv6MulticastVpn() bool
	SetIpv6MulticastVpn(value bool) BgpCapability
	HasIpv6MulticastVpn() bool
	Ipv6MplsVpn() bool
	SetIpv6MplsVpn(value bool) BgpCapability
	HasIpv6MplsVpn() bool
	Ipv6Mdt() bool
	SetIpv6Mdt(value bool) BgpCapability
	HasIpv6Mdt() bool
	Ipv6MulticastMplsVpn() bool
	SetIpv6MulticastMplsVpn(value bool) BgpCapability
	HasIpv6MulticastMplsVpn() bool
	Ipv6UnicastFlowSpec() bool
	SetIpv6UnicastFlowSpec(value bool) BgpCapability
	HasIpv6UnicastFlowSpec() bool
	Ipv6SrTePolicy() bool
	SetIpv6SrTePolicy(value bool) BgpCapability
	HasIpv6SrTePolicy() bool
	Ipv6UnicastAddPath() bool
	SetIpv6UnicastAddPath(value bool) BgpCapability
	HasIpv6UnicastAddPath() bool
	// contains filtered or unexported methods
}

func NewBgpCapability added in v0.6.5 

func NewBgpCapability() BgpCapability

type BgpCommunity added in v0.6.1 

type BgpCommunity interface {
	Msg() *snappipb.BgpCommunity
	SetMsg(*snappipb.BgpCommunity) BgpCommunity
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Type() BgpCommunityTypeEnum
	SetType(value BgpCommunityTypeEnum) BgpCommunity
	HasType() bool
	AsNumber() int32
	SetAsNumber(value int32) BgpCommunity
	HasAsNumber() bool
	AsCustom() int32
	SetAsCustom(value int32) BgpCommunity
	HasAsCustom() bool
	// contains filtered or unexported methods
}

func NewBgpCommunity added in v0.6.5 

func NewBgpCommunity() BgpCommunity

type BgpCommunityTypeEnum added in v0.6.1 

type BgpCommunityTypeEnum string

type BgpExtCommunity added in v0.6.4 

type BgpExtCommunity interface {
	Msg() *snappipb.BgpExtCommunity
	SetMsg(*snappipb.BgpExtCommunity) BgpExtCommunity
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Type() BgpExtCommunityTypeEnum
	SetType(value BgpExtCommunityTypeEnum) BgpExtCommunity
	HasType() bool
	Subtype() BgpExtCommunitySubtypeEnum
	SetSubtype(value BgpExtCommunitySubtypeEnum) BgpExtCommunity
	HasSubtype() bool
	Value() string
	SetValue(value string) BgpExtCommunity
	HasValue() bool
	// contains filtered or unexported methods
}

func NewBgpExtCommunity added in v0.6.5 

func NewBgpExtCommunity() BgpExtCommunity

type BgpExtCommunitySubtypeEnum added in v0.6.4 

type BgpExtCommunitySubtypeEnum string

type BgpExtCommunityTypeEnum added in v0.6.4 

type BgpExtCommunityTypeEnum string

type BgpRouteAdvanced added in v0.6.1 

type BgpRouteAdvanced interface {
	Msg() *snappipb.BgpRouteAdvanced
	SetMsg(*snappipb.BgpRouteAdvanced) BgpRouteAdvanced
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	MultiExitDiscriminator() int32
	SetMultiExitDiscriminator(value int32) BgpRouteAdvanced
	HasMultiExitDiscriminator() bool
	Origin() BgpRouteAdvancedOriginEnum
	SetOrigin(value BgpRouteAdvancedOriginEnum) BgpRouteAdvanced
	HasOrigin() bool
	// contains filtered or unexported methods
}

func NewBgpRouteAdvanced added in v0.6.5 

func NewBgpRouteAdvanced() BgpRouteAdvanced

type BgpRouteAdvancedOriginEnum added in v0.6.1 

type BgpRouteAdvancedOriginEnum string

type BgpSrteBindingSubTlv added in v0.6.4 

type BgpSrteBindingSubTlv interface {
	Msg() *snappipb.BgpSrteBindingSubTlv
	SetMsg(*snappipb.BgpSrteBindingSubTlv) BgpSrteBindingSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	BindingSidType() BgpSrteBindingSubTlvBindingSidTypeEnum
	SetBindingSidType(value BgpSrteBindingSubTlvBindingSidTypeEnum) BgpSrteBindingSubTlv
	HasBindingSidType() bool
	FourOctetSid() int32
	SetFourOctetSid(value int32) BgpSrteBindingSubTlv
	HasFourOctetSid() bool
	Ipv6Sid() string
	SetIpv6Sid(value string) BgpSrteBindingSubTlv
	HasIpv6Sid() bool
	SFlag() bool
	SetSFlag(value bool) BgpSrteBindingSubTlv
	HasSFlag() bool
	IFlag() bool
	SetIFlag(value bool) BgpSrteBindingSubTlv
	HasIFlag() bool
	// contains filtered or unexported methods
}

func NewBgpSrteBindingSubTlv added in v0.6.5 

func NewBgpSrteBindingSubTlv() BgpSrteBindingSubTlv

type BgpSrteBindingSubTlvBindingSidTypeEnum added in v0.6.4 

type BgpSrteBindingSubTlvBindingSidTypeEnum string

type BgpSrteColorSubTlv added in v0.6.4 

type BgpSrteColorSubTlv interface {
	Msg() *snappipb.BgpSrteColorSubTlv
	SetMsg(*snappipb.BgpSrteColorSubTlv) BgpSrteColorSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Color() string
	SetColor(value string) BgpSrteColorSubTlv
	HasColor() bool
	// contains filtered or unexported methods
}

func NewBgpSrteColorSubTlv added in v0.6.5 

func NewBgpSrteColorSubTlv() BgpSrteColorSubTlv

type BgpSrteExplicitNullLabelPolicySubTlv added in v0.6.4 

type BgpSrteExplicitNullLabelPolicySubTlv interface {
	Msg() *snappipb.BgpSrteExplicitNullLabelPolicySubTlv
	SetMsg(*snappipb.BgpSrteExplicitNullLabelPolicySubTlv) BgpSrteExplicitNullLabelPolicySubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	ExplicitNullLabelPolicy() BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum
	SetExplicitNullLabelPolicy(value BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum) BgpSrteExplicitNullLabelPolicySubTlv
	HasExplicitNullLabelPolicy() bool
	// contains filtered or unexported methods
}

func NewBgpSrteExplicitNullLabelPolicySubTlv added in v0.6.5 

func NewBgpSrteExplicitNullLabelPolicySubTlv() BgpSrteExplicitNullLabelPolicySubTlv

type BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum added in v0.6.4 

type BgpSrteExplicitNullLabelPolicySubTlvExplicitNullLabelPolicyEnum string

type BgpSrtePolicyNameSubTlv added in v0.6.4 

type BgpSrtePolicyNameSubTlv interface {
	Msg() *snappipb.BgpSrtePolicyNameSubTlv
	SetMsg(*snappipb.BgpSrtePolicyNameSubTlv) BgpSrtePolicyNameSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PolicyName() string
	SetPolicyName(value string) BgpSrtePolicyNameSubTlv
	HasPolicyName() bool
	// contains filtered or unexported methods
}

func NewBgpSrtePolicyNameSubTlv added in v0.6.5 

func NewBgpSrtePolicyNameSubTlv() BgpSrtePolicyNameSubTlv

type BgpSrtePolicyPrioritySubTlv added in v0.6.4 

type BgpSrtePolicyPrioritySubTlv interface {
	Msg() *snappipb.BgpSrtePolicyPrioritySubTlv
	SetMsg(*snappipb.BgpSrtePolicyPrioritySubTlv) BgpSrtePolicyPrioritySubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PolicyPriority() int32
	SetPolicyPriority(value int32) BgpSrtePolicyPrioritySubTlv
	HasPolicyPriority() bool
	// contains filtered or unexported methods
}

func NewBgpSrtePolicyPrioritySubTlv added in v0.6.5 

func NewBgpSrtePolicyPrioritySubTlv() BgpSrtePolicyPrioritySubTlv

type BgpSrtePreferenceSubTlv added in v0.6.4 

type BgpSrtePreferenceSubTlv interface {
	Msg() *snappipb.BgpSrtePreferenceSubTlv
	SetMsg(*snappipb.BgpSrtePreferenceSubTlv) BgpSrtePreferenceSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Preference() int64
	SetPreference(value int64) BgpSrtePreferenceSubTlv
	HasPreference() bool
	// contains filtered or unexported methods
}

func NewBgpSrtePreferenceSubTlv added in v0.6.5 

func NewBgpSrtePreferenceSubTlv() BgpSrtePreferenceSubTlv

type BgpSrteRemoteEndpointSubTlv added in v0.6.4 

type BgpSrteRemoteEndpointSubTlv interface {
	Msg() *snappipb.BgpSrteRemoteEndpointSubTlv
	SetMsg(*snappipb.BgpSrteRemoteEndpointSubTlv) BgpSrteRemoteEndpointSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	AsNumber() int64
	SetAsNumber(value int64) BgpSrteRemoteEndpointSubTlv
	HasAsNumber() bool
	AddressFamily() BgpSrteRemoteEndpointSubTlvAddressFamilyEnum
	SetAddressFamily(value BgpSrteRemoteEndpointSubTlvAddressFamilyEnum) BgpSrteRemoteEndpointSubTlv
	HasAddressFamily() bool
	Ipv4Address() string
	SetIpv4Address(value string) BgpSrteRemoteEndpointSubTlv
	HasIpv4Address() bool
	Ipv6Address() string
	SetIpv6Address(value string) BgpSrteRemoteEndpointSubTlv
	HasIpv6Address() bool
	// contains filtered or unexported methods
}

func NewBgpSrteRemoteEndpointSubTlv added in v0.6.5 

func NewBgpSrteRemoteEndpointSubTlv() BgpSrteRemoteEndpointSubTlv

type BgpSrteRemoteEndpointSubTlvAddressFamilyEnum added in v0.6.4 

type BgpSrteRemoteEndpointSubTlvAddressFamilyEnum string

type BgpSrteSRv6SIDEndpointBehaviorAndStructure added in v0.6.4 

type BgpSrteSRv6SIDEndpointBehaviorAndStructure interface {
	Msg() *snappipb.BgpSrteSRv6SIDEndpointBehaviorAndStructure
	SetMsg(*snappipb.BgpSrteSRv6SIDEndpointBehaviorAndStructure) BgpSrteSRv6SIDEndpointBehaviorAndStructure
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	LbLength() int32
	SetLbLength(value int32) BgpSrteSRv6SIDEndpointBehaviorAndStructure
	HasLbLength() bool
	LnLength() int32
	SetLnLength(value int32) BgpSrteSRv6SIDEndpointBehaviorAndStructure
	HasLnLength() bool
	FuncLength() int32
	SetFuncLength(value int32) BgpSrteSRv6SIDEndpointBehaviorAndStructure
	HasFuncLength() bool
	ArgLength() int32
	SetArgLength(value int32) BgpSrteSRv6SIDEndpointBehaviorAndStructure
	HasArgLength() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSRv6SIDEndpointBehaviorAndStructure added in v0.6.5 

func NewBgpSrteSRv6SIDEndpointBehaviorAndStructure() BgpSrteSRv6SIDEndpointBehaviorAndStructure

type BgpSrteSegment added in v0.6.4 

type BgpSrteSegment interface {
	Msg() *snappipb.BgpSrteSegment
	SetMsg(*snappipb.BgpSrteSegment) BgpSrteSegment
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SegmentType() BgpSrteSegmentSegmentTypeEnum
	SetSegmentType(value BgpSrteSegmentSegmentTypeEnum) BgpSrteSegment
	TypeA() BgpSrteSegmentATypeSubTlv
	SetTypeA(value BgpSrteSegmentATypeSubTlv) BgpSrteSegment
	HasTypeA() bool
	TypeB() BgpSrteSegmentBTypeSubTlv
	SetTypeB(value BgpSrteSegmentBTypeSubTlv) BgpSrteSegment
	HasTypeB() bool
	TypeC() BgpSrteSegmentCTypeSubTlv
	SetTypeC(value BgpSrteSegmentCTypeSubTlv) BgpSrteSegment
	HasTypeC() bool
	TypeD() BgpSrteSegmentDTypeSubTlv
	SetTypeD(value BgpSrteSegmentDTypeSubTlv) BgpSrteSegment
	HasTypeD() bool
	TypeE() BgpSrteSegmentETypeSubTlv
	SetTypeE(value BgpSrteSegmentETypeSubTlv) BgpSrteSegment
	HasTypeE() bool
	TypeF() BgpSrteSegmentFTypeSubTlv
	SetTypeF(value BgpSrteSegmentFTypeSubTlv) BgpSrteSegment
	HasTypeF() bool
	TypeG() BgpSrteSegmentGTypeSubTlv
	SetTypeG(value BgpSrteSegmentGTypeSubTlv) BgpSrteSegment
	HasTypeG() bool
	TypeH() BgpSrteSegmentHTypeSubTlv
	SetTypeH(value BgpSrteSegmentHTypeSubTlv) BgpSrteSegment
	HasTypeH() bool
	TypeI() BgpSrteSegmentITypeSubTlv
	SetTypeI(value BgpSrteSegmentITypeSubTlv) BgpSrteSegment
	HasTypeI() bool
	TypeJ() BgpSrteSegmentJTypeSubTlv
	SetTypeJ(value BgpSrteSegmentJTypeSubTlv) BgpSrteSegment
	HasTypeJ() bool
	TypeK() BgpSrteSegmentKTypeSubTlv
	SetTypeK(value BgpSrteSegmentKTypeSubTlv) BgpSrteSegment
	HasTypeK() bool
	Name() string
	SetName(value string) BgpSrteSegment
	Active() bool
	SetActive(value bool) BgpSrteSegment
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegment added in v0.6.5 

func NewBgpSrteSegment() BgpSrteSegment

type BgpSrteSegmentATypeSubTlv added in v0.6.4 

type BgpSrteSegmentATypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentATypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentATypeSubTlv) BgpSrteSegmentATypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentATypeSubTlv
	HasFlags() bool
	Label() int32
	SetLabel(value int32) BgpSrteSegmentATypeSubTlv
	HasLabel() bool
	Tc() int32
	SetTc(value int32) BgpSrteSegmentATypeSubTlv
	HasTc() bool
	SBit() bool
	SetSBit(value bool) BgpSrteSegmentATypeSubTlv
	HasSBit() bool
	Ttl() int32
	SetTtl(value int32) BgpSrteSegmentATypeSubTlv
	HasTtl() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentATypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentATypeSubTlv() BgpSrteSegmentATypeSubTlv

type BgpSrteSegmentBTypeSubTlv added in v0.6.4 

type BgpSrteSegmentBTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentBTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentBTypeSubTlv) BgpSrteSegmentBTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentBTypeSubTlv
	HasFlags() bool
	Srv6Sid() string
	SetSrv6Sid(value string) BgpSrteSegmentBTypeSubTlv
	Srv6SidEndpointBehavior() BgpSrteSRv6SIDEndpointBehaviorAndStructure
	SetSrv6SidEndpointBehavior(value BgpSrteSRv6SIDEndpointBehaviorAndStructure) BgpSrteSegmentBTypeSubTlv
	HasSrv6SidEndpointBehavior() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentBTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentBTypeSubTlv() BgpSrteSegmentBTypeSubTlv

type BgpSrteSegmentCTypeSubTlv added in v0.6.4 

type BgpSrteSegmentCTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentCTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentCTypeSubTlv) BgpSrteSegmentCTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentCTypeSubTlv
	HasFlags() bool
	SrAlgorithm() int32
	SetSrAlgorithm(value int32) BgpSrteSegmentCTypeSubTlv
	HasSrAlgorithm() bool
	Ipv4NodeAddress() string
	SetIpv4NodeAddress(value string) BgpSrteSegmentCTypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentCTypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentCTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentCTypeSubTlv() BgpSrteSegmentCTypeSubTlv

type BgpSrteSegmentDTypeSubTlv added in v0.6.4 

type BgpSrteSegmentDTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentDTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentDTypeSubTlv) BgpSrteSegmentDTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentDTypeSubTlv
	HasFlags() bool
	SrAlgorithm() int32
	SetSrAlgorithm(value int32) BgpSrteSegmentDTypeSubTlv
	HasSrAlgorithm() bool
	Ipv6NodeAddress() string
	SetIpv6NodeAddress(value string) BgpSrteSegmentDTypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentDTypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentDTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentDTypeSubTlv() BgpSrteSegmentDTypeSubTlv

type BgpSrteSegmentETypeSubTlv added in v0.6.4 

type BgpSrteSegmentETypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentETypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentETypeSubTlv) BgpSrteSegmentETypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentETypeSubTlv
	HasFlags() bool
	LocalInterfaceId() int32
	SetLocalInterfaceId(value int32) BgpSrteSegmentETypeSubTlv
	HasLocalInterfaceId() bool
	Ipv4NodeAddress() string
	SetIpv4NodeAddress(value string) BgpSrteSegmentETypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentETypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentETypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentETypeSubTlv() BgpSrteSegmentETypeSubTlv

type BgpSrteSegmentFTypeSubTlv added in v0.6.4 

type BgpSrteSegmentFTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentFTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentFTypeSubTlv) BgpSrteSegmentFTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentFTypeSubTlv
	HasFlags() bool
	LocalIpv4Address() string
	SetLocalIpv4Address(value string) BgpSrteSegmentFTypeSubTlv
	RemoteIpv4Address() string
	SetRemoteIpv4Address(value string) BgpSrteSegmentFTypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentFTypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentFTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentFTypeSubTlv() BgpSrteSegmentFTypeSubTlv

type BgpSrteSegmentGTypeSubTlv added in v0.6.4 

type BgpSrteSegmentGTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentGTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentGTypeSubTlv) BgpSrteSegmentGTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentGTypeSubTlv
	HasFlags() bool
	LocalInterfaceId() int32
	SetLocalInterfaceId(value int32) BgpSrteSegmentGTypeSubTlv
	HasLocalInterfaceId() bool
	LocalIpv6NodeAddress() string
	SetLocalIpv6NodeAddress(value string) BgpSrteSegmentGTypeSubTlv
	RemoteInterfaceId() int32
	SetRemoteInterfaceId(value int32) BgpSrteSegmentGTypeSubTlv
	HasRemoteInterfaceId() bool
	RemoteIpv6NodeAddress() string
	SetRemoteIpv6NodeAddress(value string) BgpSrteSegmentGTypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentGTypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentGTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentGTypeSubTlv() BgpSrteSegmentGTypeSubTlv

type BgpSrteSegmentHTypeSubTlv added in v0.6.4 

type BgpSrteSegmentHTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentHTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentHTypeSubTlv) BgpSrteSegmentHTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentHTypeSubTlv
	HasFlags() bool
	LocalIpv6Address() string
	SetLocalIpv6Address(value string) BgpSrteSegmentHTypeSubTlv
	RemoteIpv6Address() string
	SetRemoteIpv6Address(value string) BgpSrteSegmentHTypeSubTlv
	SrMplsSid() BgpSrteSrMplsSid
	SetSrMplsSid(value BgpSrteSrMplsSid) BgpSrteSegmentHTypeSubTlv
	HasSrMplsSid() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentHTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentHTypeSubTlv() BgpSrteSegmentHTypeSubTlv

type BgpSrteSegmentITypeSubTlv added in v0.6.4 

type BgpSrteSegmentITypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentITypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentITypeSubTlv) BgpSrteSegmentITypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentITypeSubTlv
	HasFlags() bool
	Ipv6NodeAddress() string
	SetIpv6NodeAddress(value string) BgpSrteSegmentITypeSubTlv
	Srv6Sid() string
	SetSrv6Sid(value string) BgpSrteSegmentITypeSubTlv
	HasSrv6Sid() bool
	Srv6SidEndpointBehavior() BgpSrteSRv6SIDEndpointBehaviorAndStructure
	SetSrv6SidEndpointBehavior(value BgpSrteSRv6SIDEndpointBehaviorAndStructure) BgpSrteSegmentITypeSubTlv
	HasSrv6SidEndpointBehavior() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentITypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentITypeSubTlv() BgpSrteSegmentITypeSubTlv

type BgpSrteSegmentJTypeSubTlv added in v0.6.4 

type BgpSrteSegmentJTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentJTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentJTypeSubTlv) BgpSrteSegmentJTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentJTypeSubTlv
	HasFlags() bool
	SrAlgorithm() int32
	SetSrAlgorithm(value int32) BgpSrteSegmentJTypeSubTlv
	HasSrAlgorithm() bool
	LocalInterfaceId() int32
	SetLocalInterfaceId(value int32) BgpSrteSegmentJTypeSubTlv
	HasLocalInterfaceId() bool
	LocalIpv6NodeAddress() string
	SetLocalIpv6NodeAddress(value string) BgpSrteSegmentJTypeSubTlv
	RemoteInterfaceId() int32
	SetRemoteInterfaceId(value int32) BgpSrteSegmentJTypeSubTlv
	HasRemoteInterfaceId() bool
	RemoteIpv6NodeAddress() string
	SetRemoteIpv6NodeAddress(value string) BgpSrteSegmentJTypeSubTlv
	Srv6Sid() string
	SetSrv6Sid(value string) BgpSrteSegmentJTypeSubTlv
	HasSrv6Sid() bool
	Srv6SidEndpointBehavior() BgpSrteSRv6SIDEndpointBehaviorAndStructure
	SetSrv6SidEndpointBehavior(value BgpSrteSRv6SIDEndpointBehaviorAndStructure) BgpSrteSegmentJTypeSubTlv
	HasSrv6SidEndpointBehavior() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentJTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentJTypeSubTlv() BgpSrteSegmentJTypeSubTlv

type BgpSrteSegmentKTypeSubTlv added in v0.6.4 

type BgpSrteSegmentKTypeSubTlv interface {
	Msg() *snappipb.BgpSrteSegmentKTypeSubTlv
	SetMsg(*snappipb.BgpSrteSegmentKTypeSubTlv) BgpSrteSegmentKTypeSubTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() string
	SetFlags(value string) BgpSrteSegmentKTypeSubTlv
	HasFlags() bool
	SrAlgorithm() int32
	SetSrAlgorithm(value int32) BgpSrteSegmentKTypeSubTlv
	HasSrAlgorithm() bool
	LocalIpv6Address() string
	SetLocalIpv6Address(value string) BgpSrteSegmentKTypeSubTlv
	RemoteIpv6Address() string
	SetRemoteIpv6Address(value string) BgpSrteSegmentKTypeSubTlv
	Srv6Sid() string
	SetSrv6Sid(value string) BgpSrteSegmentKTypeSubTlv
	HasSrv6Sid() bool
	Srv6SidEndpointBehavior() BgpSrteSRv6SIDEndpointBehaviorAndStructure
	SetSrv6SidEndpointBehavior(value BgpSrteSRv6SIDEndpointBehaviorAndStructure) BgpSrteSegmentKTypeSubTlv
	HasSrv6SidEndpointBehavior() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentKTypeSubTlv added in v0.6.5 

func NewBgpSrteSegmentKTypeSubTlv() BgpSrteSegmentKTypeSubTlv

type BgpSrteSegmentList added in v0.6.4 

type BgpSrteSegmentList interface {
	Msg() *snappipb.BgpSrteSegmentList
	SetMsg(*snappipb.BgpSrteSegmentList) BgpSrteSegmentList
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Weight() int64
	SetWeight(value int64) BgpSrteSegmentList
	HasWeight() bool
	Segments() BgpSrteSegmentListBgpSrteSegmentIter
	Name() string
	SetName(value string) BgpSrteSegmentList
	Active() bool
	SetActive(value bool) BgpSrteSegmentList
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSegmentList added in v0.6.5 

func NewBgpSrteSegmentList() BgpSrteSegmentList

type BgpSrteSegmentListBgpSrteSegmentIter added in v0.6.4 

type BgpSrteSegmentListBgpSrteSegmentIter interface {
	Add() BgpSrteSegment
	Items() []BgpSrteSegment
}

type BgpSrteSegmentSegmentTypeEnum added in v0.6.4 

type BgpSrteSegmentSegmentTypeEnum string

type BgpSrteSrMplsSid added in v0.6.4 

type BgpSrteSrMplsSid interface {
	Msg() *snappipb.BgpSrteSrMplsSid
	SetMsg(*snappipb.BgpSrteSrMplsSid) BgpSrteSrMplsSid
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Label() int32
	SetLabel(value int32) BgpSrteSrMplsSid
	HasLabel() bool
	Tc() int32
	SetTc(value int32) BgpSrteSrMplsSid
	HasTc() bool
	SBit() bool
	SetSBit(value bool) BgpSrteSrMplsSid
	HasSBit() bool
	Ttl() int32
	SetTtl(value int32) BgpSrteSrMplsSid
	HasTtl() bool
	// contains filtered or unexported methods
}

func NewBgpSrteSrMplsSid added in v0.6.5 

func NewBgpSrteSrMplsSid() BgpSrteSrMplsSid

type BgpSrteV4Policy added in v0.6.4 

type BgpSrteV4Policy interface {
	Msg() *snappipb.BgpSrteV4Policy
	SetMsg(*snappipb.BgpSrteV4Policy) BgpSrteV4Policy
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Distinguisher() int64
	SetDistinguisher(value int64) BgpSrteV4Policy
	HasDistinguisher() bool
	Color() int64
	SetColor(value int64) BgpSrteV4Policy
	HasColor() bool
	Ipv4Endpoint() string
	SetIpv4Endpoint(value string) BgpSrteV4Policy
	NextHopMode() BgpSrteV4PolicyNextHopModeEnum
	SetNextHopMode(value BgpSrteV4PolicyNextHopModeEnum) BgpSrteV4Policy
	HasNextHopMode() bool
	NextHopAddressType() BgpSrteV4PolicyNextHopAddressTypeEnum
	SetNextHopAddressType(value BgpSrteV4PolicyNextHopAddressTypeEnum) BgpSrteV4Policy
	HasNextHopAddressType() bool
	NextHopIpv4Address() string
	SetNextHopIpv4Address(value string) BgpSrteV4Policy
	HasNextHopIpv4Address() bool
	NextHopIpv6Address() string
	SetNextHopIpv6Address(value string) BgpSrteV4Policy
	HasNextHopIpv6Address() bool
	Advanced() BgpRouteAdvanced
	SetAdvanced(value BgpRouteAdvanced) BgpSrteV4Policy
	HasAdvanced() bool
	AddPath() BgpAddPath
	SetAddPath(value BgpAddPath) BgpSrteV4Policy
	HasAddPath() bool
	AsPath() BgpAsPath
	SetAsPath(value BgpAsPath) BgpSrteV4Policy
	HasAsPath() bool
	Communities() BgpSrteV4PolicyBgpCommunityIter
	ExtCommunities() BgpSrteV4PolicyBgpExtCommunityIter
	TunnelTlvs() BgpSrteV4PolicyBgpSrteV4TunnelTlvIter
	Name() string
	SetName(value string) BgpSrteV4Policy
	Active() bool
	SetActive(value bool) BgpSrteV4Policy
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteV4Policy added in v0.6.5 

func NewBgpSrteV4Policy() BgpSrteV4Policy

type BgpSrteV4PolicyBgpCommunityIter added in v0.6.4 

type BgpSrteV4PolicyBgpCommunityIter interface {
	Add() BgpCommunity
	Items() []BgpCommunity
}

type BgpSrteV4PolicyBgpExtCommunityIter added in v0.6.4 

type BgpSrteV4PolicyBgpExtCommunityIter interface {
	Add() BgpExtCommunity
	Items() []BgpExtCommunity
}

type BgpSrteV4PolicyBgpSrteV4TunnelTlvIter added in v0.6.4 

type BgpSrteV4PolicyBgpSrteV4TunnelTlvIter interface {
	Add() BgpSrteV4TunnelTlv
	Items() []BgpSrteV4TunnelTlv
}

type BgpSrteV4PolicyNextHopAddressTypeEnum added in v0.6.4 

type BgpSrteV4PolicyNextHopAddressTypeEnum string

type BgpSrteV4PolicyNextHopModeEnum added in v0.6.4 

type BgpSrteV4PolicyNextHopModeEnum string

type BgpSrteV4TunnelTlv added in v0.6.4 

type BgpSrteV4TunnelTlv interface {
	Msg() *snappipb.BgpSrteV4TunnelTlv
	SetMsg(*snappipb.BgpSrteV4TunnelTlv) BgpSrteV4TunnelTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	RemoteEndpointSubTlv() BgpSrteRemoteEndpointSubTlv
	SetRemoteEndpointSubTlv(value BgpSrteRemoteEndpointSubTlv) BgpSrteV4TunnelTlv
	HasRemoteEndpointSubTlv() bool
	ColorSubTlv() BgpSrteColorSubTlv
	SetColorSubTlv(value BgpSrteColorSubTlv) BgpSrteV4TunnelTlv
	HasColorSubTlv() bool
	BindingSubTlv() BgpSrteBindingSubTlv
	SetBindingSubTlv(value BgpSrteBindingSubTlv) BgpSrteV4TunnelTlv
	HasBindingSubTlv() bool
	PreferenceSubTlv() BgpSrtePreferenceSubTlv
	SetPreferenceSubTlv(value BgpSrtePreferenceSubTlv) BgpSrteV4TunnelTlv
	HasPreferenceSubTlv() bool
	PolicyPrioritySubTlv() BgpSrtePolicyPrioritySubTlv
	SetPolicyPrioritySubTlv(value BgpSrtePolicyPrioritySubTlv) BgpSrteV4TunnelTlv
	HasPolicyPrioritySubTlv() bool
	PolicyNameSubTlv() BgpSrtePolicyNameSubTlv
	SetPolicyNameSubTlv(value BgpSrtePolicyNameSubTlv) BgpSrteV4TunnelTlv
	HasPolicyNameSubTlv() bool
	ExplicitNullLabelPolicySubTlv() BgpSrteExplicitNullLabelPolicySubTlv
	SetExplicitNullLabelPolicySubTlv(value BgpSrteExplicitNullLabelPolicySubTlv) BgpSrteV4TunnelTlv
	HasExplicitNullLabelPolicySubTlv() bool
	SegmentLists() BgpSrteV4TunnelTlvBgpSrteSegmentListIter
	Name() string
	SetName(value string) BgpSrteV4TunnelTlv
	Active() bool
	SetActive(value bool) BgpSrteV4TunnelTlv
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteV4TunnelTlv added in v0.6.5 

func NewBgpSrteV4TunnelTlv() BgpSrteV4TunnelTlv

type BgpSrteV4TunnelTlvBgpSrteSegmentListIter added in v0.6.4 

type BgpSrteV4TunnelTlvBgpSrteSegmentListIter interface {
	Add() BgpSrteSegmentList
	Items() []BgpSrteSegmentList
}

type BgpSrteV6Policy added in v0.6.4 

type BgpSrteV6Policy interface {
	Msg() *snappipb.BgpSrteV6Policy
	SetMsg(*snappipb.BgpSrteV6Policy) BgpSrteV6Policy
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Distinguisher() int64
	SetDistinguisher(value int64) BgpSrteV6Policy
	HasDistinguisher() bool
	Color() int64
	SetColor(value int64) BgpSrteV6Policy
	HasColor() bool
	Ipv6Endpoint() string
	SetIpv6Endpoint(value string) BgpSrteV6Policy
	NextHopMode() BgpSrteV6PolicyNextHopModeEnum
	SetNextHopMode(value BgpSrteV6PolicyNextHopModeEnum) BgpSrteV6Policy
	HasNextHopMode() bool
	NextHopAddressType() BgpSrteV6PolicyNextHopAddressTypeEnum
	SetNextHopAddressType(value BgpSrteV6PolicyNextHopAddressTypeEnum) BgpSrteV6Policy
	HasNextHopAddressType() bool
	NextHopIpv4Address() string
	SetNextHopIpv4Address(value string) BgpSrteV6Policy
	HasNextHopIpv4Address() bool
	NextHopIpv6Address() string
	SetNextHopIpv6Address(value string) BgpSrteV6Policy
	HasNextHopIpv6Address() bool
	Advanced() BgpRouteAdvanced
	SetAdvanced(value BgpRouteAdvanced) BgpSrteV6Policy
	HasAdvanced() bool
	AddPath() BgpAddPath
	SetAddPath(value BgpAddPath) BgpSrteV6Policy
	HasAddPath() bool
	AsPath() BgpAsPath
	SetAsPath(value BgpAsPath) BgpSrteV6Policy
	HasAsPath() bool
	Communities() BgpSrteV6PolicyBgpCommunityIter
	Extcommunities() BgpSrteV6PolicyBgpExtCommunityIter
	TunnelTlvs() BgpSrteV6PolicyBgpSrteV6TunnelTlvIter
	Name() string
	SetName(value string) BgpSrteV6Policy
	Active() bool
	SetActive(value bool) BgpSrteV6Policy
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteV6Policy added in v0.6.5 

func NewBgpSrteV6Policy() BgpSrteV6Policy

type BgpSrteV6PolicyBgpCommunityIter added in v0.6.4 

type BgpSrteV6PolicyBgpCommunityIter interface {
	Add() BgpCommunity
	Items() []BgpCommunity
}

type BgpSrteV6PolicyBgpExtCommunityIter added in v0.6.4 

type BgpSrteV6PolicyBgpExtCommunityIter interface {
	Add() BgpExtCommunity
	Items() []BgpExtCommunity
}

type BgpSrteV6PolicyBgpSrteV6TunnelTlvIter added in v0.6.4 

type BgpSrteV6PolicyBgpSrteV6TunnelTlvIter interface {
	Add() BgpSrteV6TunnelTlv
	Items() []BgpSrteV6TunnelTlv
}

type BgpSrteV6PolicyNextHopAddressTypeEnum added in v0.6.4 

type BgpSrteV6PolicyNextHopAddressTypeEnum string

type BgpSrteV6PolicyNextHopModeEnum added in v0.6.4 

type BgpSrteV6PolicyNextHopModeEnum string

type BgpSrteV6TunnelTlv added in v0.6.4 

type BgpSrteV6TunnelTlv interface {
	Msg() *snappipb.BgpSrteV6TunnelTlv
	SetMsg(*snappipb.BgpSrteV6TunnelTlv) BgpSrteV6TunnelTlv
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	RemoteEndpointSubTlv() BgpSrteRemoteEndpointSubTlv
	SetRemoteEndpointSubTlv(value BgpSrteRemoteEndpointSubTlv) BgpSrteV6TunnelTlv
	HasRemoteEndpointSubTlv() bool
	ColorSubTlv() BgpSrteColorSubTlv
	SetColorSubTlv(value BgpSrteColorSubTlv) BgpSrteV6TunnelTlv
	HasColorSubTlv() bool
	BindingSubTlv() BgpSrteBindingSubTlv
	SetBindingSubTlv(value BgpSrteBindingSubTlv) BgpSrteV6TunnelTlv
	HasBindingSubTlv() bool
	PreferenceSubTlv() BgpSrtePreferenceSubTlv
	SetPreferenceSubTlv(value BgpSrtePreferenceSubTlv) BgpSrteV6TunnelTlv
	HasPreferenceSubTlv() bool
	PolicyPrioritySubTlv() BgpSrtePolicyPrioritySubTlv
	SetPolicyPrioritySubTlv(value BgpSrtePolicyPrioritySubTlv) BgpSrteV6TunnelTlv
	HasPolicyPrioritySubTlv() bool
	PolicyNameSubTlv() BgpSrtePolicyNameSubTlv
	SetPolicyNameSubTlv(value BgpSrtePolicyNameSubTlv) BgpSrteV6TunnelTlv
	HasPolicyNameSubTlv() bool
	ExplicitNullLabelPolicySubTlv() BgpSrteExplicitNullLabelPolicySubTlv
	SetExplicitNullLabelPolicySubTlv(value BgpSrteExplicitNullLabelPolicySubTlv) BgpSrteV6TunnelTlv
	HasExplicitNullLabelPolicySubTlv() bool
	SegmentLists() BgpSrteV6TunnelTlvBgpSrteSegmentListIter
	Name() string
	SetName(value string) BgpSrteV6TunnelTlv
	Active() bool
	SetActive(value bool) BgpSrteV6TunnelTlv
	HasActive() bool
	// contains filtered or unexported methods
}

func NewBgpSrteV6TunnelTlv added in v0.6.5 

func NewBgpSrteV6TunnelTlv() BgpSrteV6TunnelTlv

type BgpSrteV6TunnelTlvBgpSrteSegmentListIter added in v0.6.4 

type BgpSrteV6TunnelTlvBgpSrteSegmentListIter interface {
	Add() BgpSrteSegmentList
	Items() []BgpSrteSegmentList
}

type BgpV4Interface added in v0.6.1 

type BgpV4Interface interface {
	Msg() *snappipb.BgpV4Interface
	SetMsg(*snappipb.BgpV4Interface) BgpV4Interface
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ipv4Name() string
	SetIpv4Name(value string) BgpV4Interface
	Peers() BgpV4InterfaceBgpV4PeerIter
	// contains filtered or unexported methods
}

func NewBgpV4Interface added in v0.6.5 

func NewBgpV4Interface() BgpV4Interface

type BgpV4InterfaceBgpV4PeerIter added in v0.6.1 

type BgpV4InterfaceBgpV4PeerIter interface {
	Add() BgpV4Peer
	Items() []BgpV4Peer
}

type BgpV4Peer added in v0.6.1 

type BgpV4Peer interface {
	Msg() *snappipb.BgpV4Peer
	SetMsg(*snappipb.BgpV4Peer) BgpV4Peer
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PeerAddress() string
	SetPeerAddress(value string) BgpV4Peer
	AsType() BgpV4PeerAsTypeEnum
	SetAsType(value BgpV4PeerAsTypeEnum) BgpV4Peer
	AsNumber() int32
	SetAsNumber(value int32) BgpV4Peer
	AsNumberWidth() BgpV4PeerAsNumberWidthEnum
	SetAsNumberWidth(value BgpV4PeerAsNumberWidthEnum) BgpV4Peer
	HasAsNumberWidth() bool
	Advanced() BgpAdvanced
	SetAdvanced(value BgpAdvanced) BgpV4Peer
	HasAdvanced() bool
	Capability() BgpCapability
	SetCapability(value BgpCapability) BgpV4Peer
	HasCapability() bool
	V4Routes() BgpV4PeerBgpV4RouteRangeIter
	V6Routes() BgpV4PeerBgpV6RouteRangeIter
	V4SrtePolicies() BgpV4PeerBgpSrteV4PolicyIter
	V6SrtePolicies() BgpV4PeerBgpSrteV6PolicyIter
	Name() string
	SetName(value string) BgpV4Peer
	// contains filtered or unexported methods
}

func NewBgpV4Peer added in v0.6.5 

func NewBgpV4Peer() BgpV4Peer

type BgpV4PeerAsNumberWidthEnum added in v0.6.1 

type BgpV4PeerAsNumberWidthEnum string

type BgpV4PeerAsTypeEnum added in v0.6.1 

type BgpV4PeerAsTypeEnum string

type BgpV4PeerBgpSrteV4PolicyIter added in v0.6.4 

type BgpV4PeerBgpSrteV4PolicyIter interface {
	Add() BgpSrteV4Policy
	Items() []BgpSrteV4Policy
}

type BgpV4PeerBgpSrteV6PolicyIter added in v0.6.4 

type BgpV4PeerBgpSrteV6PolicyIter interface {
	Add() BgpSrteV6Policy
	Items() []BgpSrteV6Policy
}

type BgpV4PeerBgpV4RouteRangeIter added in v0.6.1 

type BgpV4PeerBgpV4RouteRangeIter interface {
	Add() BgpV4RouteRange
	Items() []BgpV4RouteRange
}

type BgpV4PeerBgpV6RouteRangeIter added in v0.6.1 

type BgpV4PeerBgpV6RouteRangeIter interface {
	Add() BgpV6RouteRange
	Items() []BgpV6RouteRange
}

type BgpV4RouteRange added in v0.6.1 

type BgpV4RouteRange interface {
	Msg() *snappipb.BgpV4RouteRange
	SetMsg(*snappipb.BgpV4RouteRange) BgpV4RouteRange
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Addresses() BgpV4RouteRangeV4RouteAddressIter
	NextHopMode() BgpV4RouteRangeNextHopModeEnum
	SetNextHopMode(value BgpV4RouteRangeNextHopModeEnum) BgpV4RouteRange
	HasNextHopMode() bool
	NextHopAddressType() BgpV4RouteRangeNextHopAddressTypeEnum
	SetNextHopAddressType(value BgpV4RouteRangeNextHopAddressTypeEnum) BgpV4RouteRange
	HasNextHopAddressType() bool
	NextHopIpv4Address() string
	SetNextHopIpv4Address(value string) BgpV4RouteRange
	HasNextHopIpv4Address() bool
	NextHopIpv6Address() string
	SetNextHopIpv6Address(value string) BgpV4RouteRange
	HasNextHopIpv6Address() bool
	Advanced() BgpRouteAdvanced
	SetAdvanced(value BgpRouteAdvanced) BgpV4RouteRange
	HasAdvanced() bool
	Communities() BgpV4RouteRangeBgpCommunityIter
	AsPath() BgpAsPath
	SetAsPath(value BgpAsPath) BgpV4RouteRange
	HasAsPath() bool
	AddPath() BgpAddPath
	SetAddPath(value BgpAddPath) BgpV4RouteRange
	HasAddPath() bool
	Name() string
	SetName(value string) BgpV4RouteRange
	// contains filtered or unexported methods
}

func NewBgpV4RouteRange added in v0.6.5 

func NewBgpV4RouteRange() BgpV4RouteRange

type BgpV4RouteRangeBgpCommunityIter added in v0.6.1 

type BgpV4RouteRangeBgpCommunityIter interface {
	Add() BgpCommunity
	Items() []BgpCommunity
}

type BgpV4RouteRangeNextHopAddressTypeEnum added in v0.6.1 

type BgpV4RouteRangeNextHopAddressTypeEnum string

type BgpV4RouteRangeNextHopModeEnum added in v0.6.1 

type BgpV4RouteRangeNextHopModeEnum string

type BgpV4RouteRangeV4RouteAddressIter added in v0.6.1 

type BgpV4RouteRangeV4RouteAddressIter interface {
	Add() V4RouteAddress
	Items() []V4RouteAddress
}

type BgpV6Interface added in v0.6.1 

type BgpV6Interface interface {
	Msg() *snappipb.BgpV6Interface
	SetMsg(*snappipb.BgpV6Interface) BgpV6Interface
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ipv6Name() string
	SetIpv6Name(value string) BgpV6Interface
	Peers() BgpV6InterfaceBgpV6PeerIter
	// contains filtered or unexported methods
}

func NewBgpV6Interface added in v0.6.5 

func NewBgpV6Interface() BgpV6Interface

type BgpV6InterfaceBgpV6PeerIter added in v0.6.1 

type BgpV6InterfaceBgpV6PeerIter interface {
	Add() BgpV6Peer
	Items() []BgpV6Peer
}

type BgpV6Peer added in v0.6.1 

type BgpV6Peer interface {
	Msg() *snappipb.BgpV6Peer
	SetMsg(*snappipb.BgpV6Peer) BgpV6Peer
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PeerAddress() string
	SetPeerAddress(value string) BgpV6Peer
	SegmentRouting() BgpV6SegmentRouting
	SetSegmentRouting(value BgpV6SegmentRouting) BgpV6Peer
	HasSegmentRouting() bool
	AsType() BgpV6PeerAsTypeEnum
	SetAsType(value BgpV6PeerAsTypeEnum) BgpV6Peer
	AsNumber() int32
	SetAsNumber(value int32) BgpV6Peer
	AsNumberWidth() BgpV6PeerAsNumberWidthEnum
	SetAsNumberWidth(value BgpV6PeerAsNumberWidthEnum) BgpV6Peer
	HasAsNumberWidth() bool
	Advanced() BgpAdvanced
	SetAdvanced(value BgpAdvanced) BgpV6Peer
	HasAdvanced() bool
	Capability() BgpCapability
	SetCapability(value BgpCapability) BgpV6Peer
	HasCapability() bool
	V4Routes() BgpV6PeerBgpV4RouteRangeIter
	V6Routes() BgpV6PeerBgpV6RouteRangeIter
	V4SrtePolicies() BgpV6PeerBgpSrteV4PolicyIter
	V6SrtePolicies() BgpV6PeerBgpSrteV6PolicyIter
	Name() string
	SetName(value string) BgpV6Peer
	// contains filtered or unexported methods
}

func NewBgpV6Peer added in v0.6.5 

func NewBgpV6Peer() BgpV6Peer

type BgpV6PeerAsNumberWidthEnum added in v0.6.1 

type BgpV6PeerAsNumberWidthEnum string

type BgpV6PeerAsTypeEnum added in v0.6.1 

type BgpV6PeerAsTypeEnum string

type BgpV6PeerBgpSrteV4PolicyIter added in v0.6.4 

type BgpV6PeerBgpSrteV4PolicyIter interface {
	Add() BgpSrteV4Policy
	Items() []BgpSrteV4Policy
}

type BgpV6PeerBgpSrteV6PolicyIter added in v0.6.4 

type BgpV6PeerBgpSrteV6PolicyIter interface {
	Add() BgpSrteV6Policy
	Items() []BgpSrteV6Policy
}

type BgpV6PeerBgpV4RouteRangeIter added in v0.6.1 

type BgpV6PeerBgpV4RouteRangeIter interface {
	Add() BgpV4RouteRange
	Items() []BgpV4RouteRange
}

type BgpV6PeerBgpV6RouteRangeIter added in v0.6.1 

type BgpV6PeerBgpV6RouteRangeIter interface {
	Add() BgpV6RouteRange
	Items() []BgpV6RouteRange
}

type BgpV6RouteRange added in v0.6.1 

type BgpV6RouteRange interface {
	Msg() *snappipb.BgpV6RouteRange
	SetMsg(*snappipb.BgpV6RouteRange) BgpV6RouteRange
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Addresses() BgpV6RouteRangeV6RouteAddressIter
	NextHopMode() BgpV6RouteRangeNextHopModeEnum
	SetNextHopMode(value BgpV6RouteRangeNextHopModeEnum) BgpV6RouteRange
	HasNextHopMode() bool
	NextHopAddressType() BgpV6RouteRangeNextHopAddressTypeEnum
	SetNextHopAddressType(value BgpV6RouteRangeNextHopAddressTypeEnum) BgpV6RouteRange
	HasNextHopAddressType() bool
	NextHopIpv4Address() string
	SetNextHopIpv4Address(value string) BgpV6RouteRange
	HasNextHopIpv4Address() bool
	NextHopIpv6Address() string
	SetNextHopIpv6Address(value string) BgpV6RouteRange
	HasNextHopIpv6Address() bool
	Advanced() BgpRouteAdvanced
	SetAdvanced(value BgpRouteAdvanced) BgpV6RouteRange
	HasAdvanced() bool
	Communities() BgpV6RouteRangeBgpCommunityIter
	AsPath() BgpAsPath
	SetAsPath(value BgpAsPath) BgpV6RouteRange
	HasAsPath() bool
	AddPath() BgpAddPath
	SetAddPath(value BgpAddPath) BgpV6RouteRange
	HasAddPath() bool
	Name() string
	SetName(value string) BgpV6RouteRange
	// contains filtered or unexported methods
}

func NewBgpV6RouteRange added in v0.6.5 

func NewBgpV6RouteRange() BgpV6RouteRange

type BgpV6RouteRangeBgpCommunityIter added in v0.6.1 

type BgpV6RouteRangeBgpCommunityIter interface {
	Add() BgpCommunity
	Items() []BgpCommunity
}

type BgpV6RouteRangeNextHopAddressTypeEnum added in v0.6.1 

type BgpV6RouteRangeNextHopAddressTypeEnum string

type BgpV6RouteRangeNextHopModeEnum added in v0.6.1 

type BgpV6RouteRangeNextHopModeEnum string

type BgpV6RouteRangeV6RouteAddressIter added in v0.6.1 

type BgpV6RouteRangeV6RouteAddressIter interface {
	Add() V6RouteAddress
	Items() []V6RouteAddress
}

type BgpV6SegmentRouting added in v0.6.1 

type BgpV6SegmentRouting interface {
	Msg() *snappipb.BgpV6SegmentRouting
	SetMsg(*snappipb.BgpV6SegmentRouting) BgpV6SegmentRouting
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	IngressSupportsVpn() bool
	SetIngressSupportsVpn(value bool) BgpV6SegmentRouting
	HasIngressSupportsVpn() bool
	ReducedEncapsulation() bool
	SetReducedEncapsulation(value bool) BgpV6SegmentRouting
	HasReducedEncapsulation() bool
	CopyTimeToLive() bool
	SetCopyTimeToLive(value bool) BgpV6SegmentRouting
	HasCopyTimeToLive() bool
	TimeToLive() int32
	SetTimeToLive(value int32) BgpV6SegmentRouting
	HasTimeToLive() bool
	MaxSidsPerSrh() int32
	SetMaxSidsPerSrh(value int32) BgpV6SegmentRouting
	HasMaxSidsPerSrh() bool
	AutoGenerateSegmentLeftValue() bool
	SetAutoGenerateSegmentLeftValue(value bool) BgpV6SegmentRouting
	HasAutoGenerateSegmentLeftValue() bool
	SegmentLeftValue() int32
	SetSegmentLeftValue(value int32) BgpV6SegmentRouting
	HasSegmentLeftValue() bool
	AdvertiseSrTePolicy() bool
	SetAdvertiseSrTePolicy(value bool) BgpV6SegmentRouting
	HasAdvertiseSrTePolicy() bool
	// contains filtered or unexported methods
}

func NewBgpV6SegmentRouting added in v0.6.5 

func NewBgpV6SegmentRouting() BgpV6SegmentRouting

type Bgpv4Metric 

type Bgpv4Metric interface {
	Msg() *snappipb.Bgpv4Metric
	SetMsg(*snappipb.Bgpv4Metric) Bgpv4Metric
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) Bgpv4Metric
	HasName() bool
	SessionState() Bgpv4MetricSessionStateEnum
	SetSessionState(value Bgpv4MetricSessionStateEnum) Bgpv4Metric
	HasSessionState() bool
	SessionFlapCount() int32
	SetSessionFlapCount(value int32) Bgpv4Metric
	HasSessionFlapCount() bool
	RoutesAdvertised() int32
	SetRoutesAdvertised(value int32) Bgpv4Metric
	HasRoutesAdvertised() bool
	RoutesReceived() int32
	SetRoutesReceived(value int32) Bgpv4Metric
	HasRoutesReceived() bool
	RouteWithdrawsSent() int32
	SetRouteWithdrawsSent(value int32) Bgpv4Metric
	HasRouteWithdrawsSent() bool
	RouteWithdrawsReceived() int32
	SetRouteWithdrawsReceived(value int32) Bgpv4Metric
	HasRouteWithdrawsReceived() bool
	UpdatesSent() int32
	SetUpdatesSent(value int32) Bgpv4Metric
	HasUpdatesSent() bool
	UpdatesReceived() int32
	SetUpdatesReceived(value int32) Bgpv4Metric
	HasUpdatesReceived() bool
	OpensSent() int32
	SetOpensSent(value int32) Bgpv4Metric
	HasOpensSent() bool
	OpensReceived() int32
	SetOpensReceived(value int32) Bgpv4Metric
	HasOpensReceived() bool
	KeepalivesSent() int32
	SetKeepalivesSent(value int32) Bgpv4Metric
	HasKeepalivesSent() bool
	KeepalivesReceived() int32
	SetKeepalivesReceived(value int32) Bgpv4Metric
	HasKeepalivesReceived() bool
	NotificationsSent() int32
	SetNotificationsSent(value int32) Bgpv4Metric
	HasNotificationsSent() bool
	NotificationsReceived() int32
	SetNotificationsReceived(value int32) Bgpv4Metric
	HasNotificationsReceived() bool
	// contains filtered or unexported methods
}

func NewBgpv4Metric added in v0.6.5 

func NewBgpv4Metric() Bgpv4Metric

type Bgpv4MetricSessionStateEnum 

type Bgpv4MetricSessionStateEnum string

type Bgpv4MetricsRequest 

type Bgpv4MetricsRequest interface {
	Msg() *snappipb.Bgpv4MetricsRequest
	SetMsg(*snappipb.Bgpv4MetricsRequest) Bgpv4MetricsRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PeerNames() []string
	SetPeerNames(value []string) Bgpv4MetricsRequest
	ColumnNames() []Bgpv4MetricsRequestColumnNamesEnum
	SetColumnNames(value []Bgpv4MetricsRequestColumnNamesEnum) Bgpv4MetricsRequest
	// contains filtered or unexported methods
}

func NewBgpv4MetricsRequest added in v0.6.5 

func NewBgpv4MetricsRequest() Bgpv4MetricsRequest

type Bgpv4MetricsRequestColumnNamesEnum 

type Bgpv4MetricsRequestColumnNamesEnum string

type Bgpv6Metric 

type Bgpv6Metric interface {
	Msg() *snappipb.Bgpv6Metric
	SetMsg(*snappipb.Bgpv6Metric) Bgpv6Metric
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) Bgpv6Metric
	HasName() bool
	SessionState() Bgpv6MetricSessionStateEnum
	SetSessionState(value Bgpv6MetricSessionStateEnum) Bgpv6Metric
	HasSessionState() bool
	SessionFlapCount() int32
	SetSessionFlapCount(value int32) Bgpv6Metric
	HasSessionFlapCount() bool
	RoutesAdvertised() int32
	SetRoutesAdvertised(value int32) Bgpv6Metric
	HasRoutesAdvertised() bool
	RoutesReceived() int32
	SetRoutesReceived(value int32) Bgpv6Metric
	HasRoutesReceived() bool
	RouteWithdrawsSent() int32
	SetRouteWithdrawsSent(value int32) Bgpv6Metric
	HasRouteWithdrawsSent() bool
	RouteWithdrawsReceived() int32
	SetRouteWithdrawsReceived(value int32) Bgpv6Metric
	HasRouteWithdrawsReceived() bool
	UpdatesSent() int32
	SetUpdatesSent(value int32) Bgpv6Metric
	HasUpdatesSent() bool
	UpdatesReceived() int32
	SetUpdatesReceived(value int32) Bgpv6Metric
	HasUpdatesReceived() bool
	OpensSent() int32
	SetOpensSent(value int32) Bgpv6Metric
	HasOpensSent() bool
	OpensReceived() int32
	SetOpensReceived(value int32) Bgpv6Metric
	HasOpensReceived() bool
	KeepalivesSent() int32
	SetKeepalivesSent(value int32) Bgpv6Metric
	HasKeepalivesSent() bool
	KeepalivesReceived() int32
	SetKeepalivesReceived(value int32) Bgpv6Metric
	HasKeepalivesReceived() bool
	NotificationsSent() int32
	SetNotificationsSent(value int32) Bgpv6Metric
	HasNotificationsSent() bool
	NotificationsReceived() int32
	SetNotificationsReceived(value int32) Bgpv6Metric
	HasNotificationsReceived() bool
	// contains filtered or unexported methods
}

func NewBgpv6Metric added in v0.6.5 

func NewBgpv6Metric() Bgpv6Metric

type Bgpv6MetricSessionStateEnum 

type Bgpv6MetricSessionStateEnum string

type Bgpv6MetricsRequest 

type Bgpv6MetricsRequest interface {
	Msg() *snappipb.Bgpv6MetricsRequest
	SetMsg(*snappipb.Bgpv6MetricsRequest) Bgpv6MetricsRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PeerNames() []string
	SetPeerNames(value []string) Bgpv6MetricsRequest
	ColumnNames() []Bgpv6MetricsRequestColumnNamesEnum
	SetColumnNames(value []Bgpv6MetricsRequestColumnNamesEnum) Bgpv6MetricsRequest
	// contains filtered or unexported methods
}

func NewBgpv6MetricsRequest added in v0.6.5 

func NewBgpv6MetricsRequest() Bgpv6MetricsRequest

type Bgpv6MetricsRequestColumnNamesEnum 

type Bgpv6MetricsRequestColumnNamesEnum string

type Capture 

type Capture interface {
	Msg() *snappipb.Capture
	SetMsg(*snappipb.Capture) Capture
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortNames() []string
	SetPortNames(value []string) Capture
	Filters() CaptureCaptureFilterIter
	Overwrite() bool
	SetOverwrite(value bool) Capture
	HasOverwrite() bool
	PacketSize() int32
	SetPacketSize(value int32) Capture
	HasPacketSize() bool
	Format() CaptureFormatEnum
	SetFormat(value CaptureFormatEnum) Capture
	HasFormat() bool
	Name() string
	SetName(value string) Capture
	// contains filtered or unexported methods
}

func NewCapture added in v0.6.5 

func NewCapture() Capture

type CaptureCaptureFilterIter 

type CaptureCaptureFilterIter interface {
	Add() CaptureFilter
	Items() []CaptureFilter
}

type CaptureCustom 

type CaptureCustom interface {
	Msg() *snappipb.CaptureCustom
	SetMsg(*snappipb.CaptureCustom) CaptureCustom
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Offset() int32
	SetOffset(value int32) CaptureCustom
	HasOffset() bool
	BitLength() int32
	SetBitLength(value int32) CaptureCustom
	HasBitLength() bool
	Value() string
	SetValue(value string) CaptureCustom
	HasValue() bool
	Mask() string
	SetMask(value string) CaptureCustom
	HasMask() bool
	Negate() bool
	SetNegate(value bool) CaptureCustom
	HasNegate() bool
	// contains filtered or unexported methods
}

func NewCaptureCustom added in v0.6.5 

func NewCaptureCustom() CaptureCustom

type CaptureEthernet 

type CaptureEthernet interface {
	Msg() *snappipb.CaptureEthernet
	SetMsg(*snappipb.CaptureEthernet) CaptureEthernet
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Src() CaptureField
	SetSrc(value CaptureField) CaptureEthernet
	HasSrc() bool
	Dst() CaptureField
	SetDst(value CaptureField) CaptureEthernet
	HasDst() bool
	EtherType() CaptureField
	SetEtherType(value CaptureField) CaptureEthernet
	HasEtherType() bool
	PfcQueue() CaptureField
	SetPfcQueue(value CaptureField) CaptureEthernet
	HasPfcQueue() bool
	// contains filtered or unexported methods
}

func NewCaptureEthernet added in v0.6.5 

func NewCaptureEthernet() CaptureEthernet

type CaptureField 

type CaptureField interface {
	Msg() *snappipb.CaptureField
	SetMsg(*snappipb.CaptureField) CaptureField
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Value() string
	SetValue(value string) CaptureField
	HasValue() bool
	Mask() string
	SetMask(value string) CaptureField
	HasMask() bool
	Negate() bool
	SetNegate(value bool) CaptureField
	HasNegate() bool
	// contains filtered or unexported methods
}

func NewCaptureField added in v0.6.5 

func NewCaptureField() CaptureField

type CaptureFilter 

type CaptureFilter interface {
	Msg() *snappipb.CaptureFilter
	SetMsg(*snappipb.CaptureFilter) CaptureFilter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() CaptureFilterChoiceEnum
	SetChoice(value CaptureFilterChoiceEnum) CaptureFilter
	HasChoice() bool
	Custom() CaptureCustom
	SetCustom(value CaptureCustom) CaptureFilter
	HasCustom() bool
	Ethernet() CaptureEthernet
	SetEthernet(value CaptureEthernet) CaptureFilter
	HasEthernet() bool
	Vlan() CaptureVlan
	SetVlan(value CaptureVlan) CaptureFilter
	HasVlan() bool
	Ipv4() CaptureIpv4
	SetIpv4(value CaptureIpv4) CaptureFilter
	HasIpv4() bool
	Ipv6() CaptureIpv6
	SetIpv6(value CaptureIpv6) CaptureFilter
	HasIpv6() bool
	// contains filtered or unexported methods
}

func NewCaptureFilter added in v0.6.5 

func NewCaptureFilter() CaptureFilter

type CaptureFilterChoiceEnum 

type CaptureFilterChoiceEnum string

type CaptureFormatEnum 

type CaptureFormatEnum string

type CaptureIpv4 

type CaptureIpv4 interface {
	Msg() *snappipb.CaptureIpv4
	SetMsg(*snappipb.CaptureIpv4) CaptureIpv4
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() CaptureField
	SetVersion(value CaptureField) CaptureIpv4
	HasVersion() bool
	HeaderLength() CaptureField
	SetHeaderLength(value CaptureField) CaptureIpv4
	HasHeaderLength() bool
	Priority() CaptureField
	SetPriority(value CaptureField) CaptureIpv4
	HasPriority() bool
	TotalLength() CaptureField
	SetTotalLength(value CaptureField) CaptureIpv4
	HasTotalLength() bool
	Identification() CaptureField
	SetIdentification(value CaptureField) CaptureIpv4
	HasIdentification() bool
	Reserved() CaptureField
	SetReserved(value CaptureField) CaptureIpv4
	HasReserved() bool
	DontFragment() CaptureField
	SetDontFragment(value CaptureField) CaptureIpv4
	HasDontFragment() bool
	MoreFragments() CaptureField
	SetMoreFragments(value CaptureField) CaptureIpv4
	HasMoreFragments() bool
	FragmentOffset() CaptureField
	SetFragmentOffset(value CaptureField) CaptureIpv4
	HasFragmentOffset() bool
	TimeToLive() CaptureField
	SetTimeToLive(value CaptureField) CaptureIpv4
	HasTimeToLive() bool
	Protocol() CaptureField
	SetProtocol(value CaptureField) CaptureIpv4
	HasProtocol() bool
	HeaderChecksum() CaptureField
	SetHeaderChecksum(value CaptureField) CaptureIpv4
	HasHeaderChecksum() bool
	Src() CaptureField
	SetSrc(value CaptureField) CaptureIpv4
	HasSrc() bool
	Dst() CaptureField
	SetDst(value CaptureField) CaptureIpv4
	HasDst() bool
	// contains filtered or unexported methods
}

func NewCaptureIpv4 added in v0.6.5 

func NewCaptureIpv4() CaptureIpv4

type CaptureIpv6 

type CaptureIpv6 interface {
	Msg() *snappipb.CaptureIpv6
	SetMsg(*snappipb.CaptureIpv6) CaptureIpv6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() CaptureField
	SetVersion(value CaptureField) CaptureIpv6
	HasVersion() bool
	TrafficClass() CaptureField
	SetTrafficClass(value CaptureField) CaptureIpv6
	HasTrafficClass() bool
	FlowLabel() CaptureField
	SetFlowLabel(value CaptureField) CaptureIpv6
	HasFlowLabel() bool
	PayloadLength() CaptureField
	SetPayloadLength(value CaptureField) CaptureIpv6
	HasPayloadLength() bool
	NextHeader() CaptureField
	SetNextHeader(value CaptureField) CaptureIpv6
	HasNextHeader() bool
	HopLimit() CaptureField
	SetHopLimit(value CaptureField) CaptureIpv6
	HasHopLimit() bool
	Src() CaptureField
	SetSrc(value CaptureField) CaptureIpv6
	HasSrc() bool
	Dst() CaptureField
	SetDst(value CaptureField) CaptureIpv6
	HasDst() bool
	// contains filtered or unexported methods
}

func NewCaptureIpv6 added in v0.6.5 

func NewCaptureIpv6() CaptureIpv6

type CaptureRequest 

type CaptureRequest interface {
	Msg() *snappipb.CaptureRequest
	SetMsg(*snappipb.CaptureRequest) CaptureRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortName() string
	SetPortName(value string) CaptureRequest
	// contains filtered or unexported methods
}

func NewCaptureRequest added in v0.6.5 

func NewCaptureRequest() CaptureRequest

type CaptureState 

type CaptureState interface {
	Msg() *snappipb.CaptureState
	SetMsg(*snappipb.CaptureState) CaptureState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortNames() []string
	SetPortNames(value []string) CaptureState
	State() CaptureStateStateEnum
	SetState(value CaptureStateStateEnum) CaptureState
	// contains filtered or unexported methods
}

func NewCaptureState added in v0.6.5 

func NewCaptureState() CaptureState

type CaptureStateStateEnum 

type CaptureStateStateEnum string

type CaptureVlan 

type CaptureVlan interface {
	Msg() *snappipb.CaptureVlan
	SetMsg(*snappipb.CaptureVlan) CaptureVlan
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Priority() CaptureField
	SetPriority(value CaptureField) CaptureVlan
	HasPriority() bool
	Cfi() CaptureField
	SetCfi(value CaptureField) CaptureVlan
	HasCfi() bool
	Id() CaptureField
	SetId(value CaptureField) CaptureVlan
	HasId() bool
	Protocol() CaptureField
	SetProtocol(value CaptureField) CaptureVlan
	HasProtocol() bool
	// contains filtered or unexported methods
}

func NewCaptureVlan added in v0.6.5 

func NewCaptureVlan() CaptureVlan

type Config 

type Config interface {
	Msg() *snappipb.Config
	SetMsg(*snappipb.Config) Config
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ports() ConfigPortIter
	Lags() ConfigLagIter
	Layer1() ConfigLayer1Iter
	Captures() ConfigCaptureIter
	Devices() ConfigDeviceIter
	Flows() ConfigFlowIter
	Events() Event
	SetEvents(value Event) Config
	HasEvents() bool
	Options() ConfigOptions
	SetOptions(value ConfigOptions) Config
	HasOptions() bool
	// contains filtered or unexported methods
}

func NewConfig added in v0.6.5 

func NewConfig() Config

type ConfigCaptureIter 

type ConfigCaptureIter interface {
	Add() Capture
	Items() []Capture
}

type ConfigDeviceIter 

type ConfigDeviceIter interface {
	Add() Device
	Items() []Device
}

type ConfigFlowIter 

type ConfigFlowIter interface {
	Add() Flow
	Items() []Flow
}

type ConfigLagIter 

type ConfigLagIter interface {
	Add() Lag
	Items() []Lag
}

type ConfigLayer1Iter 

type ConfigLayer1Iter interface {
	Add() Layer1
	Items() []Layer1
}

type ConfigOptions 

type ConfigOptions interface {
	Msg() *snappipb.ConfigOptions
	SetMsg(*snappipb.ConfigOptions) ConfigOptions
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortOptions() PortOptions
	SetPortOptions(value PortOptions) ConfigOptions
	HasPortOptions() bool
	// contains filtered or unexported methods
}

func NewConfigOptions added in v0.6.5 

func NewConfigOptions() ConfigOptions

type ConfigPortIter 

type ConfigPortIter interface {
	Add() Port
	Items() []Port
}

type Device 

type Device interface {
	Msg() *snappipb.Device
	SetMsg(*snappipb.Device) Device
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ethernets() DeviceDeviceEthernetIter
	Ipv4Loopbacks() DeviceDeviceIpv4LoopbackIter
	Ipv6Loopbacks() DeviceDeviceIpv6LoopbackIter
	Isis() DeviceIsisRouter
	SetIsis(value DeviceIsisRouter) Device
	HasIsis() bool
	Bgp() DeviceBgpRouter
	SetBgp(value DeviceBgpRouter) Device
	HasBgp() bool
	Name() string
	SetName(value string) Device
	// contains filtered or unexported methods
}

func NewDevice added in v0.6.5 

func NewDevice() Device

type DeviceBgpRouter added in v0.6.1 

type DeviceBgpRouter interface {
	Msg() *snappipb.DeviceBgpRouter
	SetMsg(*snappipb.DeviceBgpRouter) DeviceBgpRouter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	RouterId() string
	SetRouterId(value string) DeviceBgpRouter
	Ipv4Interfaces() DeviceBgpRouterBgpV4InterfaceIter
	Ipv6Interfaces() DeviceBgpRouterBgpV6InterfaceIter
	// contains filtered or unexported methods
}

func NewDeviceBgpRouter added in v0.6.5 

func NewDeviceBgpRouter() DeviceBgpRouter

type DeviceBgpRouterBgpV4InterfaceIter added in v0.6.1 

type DeviceBgpRouterBgpV4InterfaceIter interface {
	Add() BgpV4Interface
	Items() []BgpV4Interface
}

type DeviceBgpRouterBgpV6InterfaceIter added in v0.6.1 

type DeviceBgpRouterBgpV6InterfaceIter interface {
	Add() BgpV6Interface
	Items() []BgpV6Interface
}

type DeviceDeviceEthernetIter added in v0.6.1 

type DeviceDeviceEthernetIter interface {
	Add() DeviceEthernet
	Items() []DeviceEthernet
}

type DeviceDeviceIpv4LoopbackIter added in v0.6.1 

type DeviceDeviceIpv4LoopbackIter interface {
	Add() DeviceIpv4Loopback
	Items() []DeviceIpv4Loopback
}

type DeviceDeviceIpv6LoopbackIter added in v0.6.1 

type DeviceDeviceIpv6LoopbackIter interface {
	Add() DeviceIpv6Loopback
	Items() []DeviceIpv6Loopback
}

type DeviceEthernet 

type DeviceEthernet interface {
	Msg() *snappipb.DeviceEthernet
	SetMsg(*snappipb.DeviceEthernet) DeviceEthernet
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortName() string
	SetPortName(value string) DeviceEthernet
	Ipv4Addresses() DeviceEthernetDeviceIpv4Iter
	Ipv6Addresses() DeviceEthernetDeviceIpv6Iter
	Mac() string
	SetMac(value string) DeviceEthernet
	Mtu() int32
	SetMtu(value int32) DeviceEthernet
	HasMtu() bool
	Vlans() DeviceEthernetDeviceVlanIter
	Name() string
	SetName(value string) DeviceEthernet
	// contains filtered or unexported methods
}

func NewDeviceEthernet added in v0.6.5 

func NewDeviceEthernet() DeviceEthernet

type DeviceEthernetBase 

type DeviceEthernetBase interface {
	Msg() *snappipb.DeviceEthernetBase
	SetMsg(*snappipb.DeviceEthernetBase) DeviceEthernetBase
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Mac() string
	SetMac(value string) DeviceEthernetBase
	Mtu() int32
	SetMtu(value int32) DeviceEthernetBase
	HasMtu() bool
	Vlans() DeviceEthernetBaseDeviceVlanIter
	Name() string
	SetName(value string) DeviceEthernetBase
	// contains filtered or unexported methods
}

func NewDeviceEthernetBase added in v0.6.5 

func NewDeviceEthernetBase() DeviceEthernetBase

type DeviceEthernetBaseDeviceVlanIter 

type DeviceEthernetBaseDeviceVlanIter interface {
	Add() DeviceVlan
	Items() []DeviceVlan
}

type DeviceEthernetDeviceIpv4Iter added in v0.6.1 

type DeviceEthernetDeviceIpv4Iter interface {
	Add() DeviceIpv4
	Items() []DeviceIpv4
}

type DeviceEthernetDeviceIpv6Iter added in v0.6.1 

type DeviceEthernetDeviceIpv6Iter interface {
	Add() DeviceIpv6
	Items() []DeviceIpv6
}

type DeviceEthernetDeviceVlanIter 

type DeviceEthernetDeviceVlanIter interface {
	Add() DeviceVlan
	Items() []DeviceVlan
}

type DeviceIpv4 

type DeviceIpv4 interface {
	Msg() *snappipb.DeviceIpv4
	SetMsg(*snappipb.DeviceIpv4) DeviceIpv4
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Gateway() string
	SetGateway(value string) DeviceIpv4
	Address() string
	SetAddress(value string) DeviceIpv4
	Prefix() int32
	SetPrefix(value int32) DeviceIpv4
	HasPrefix() bool
	Name() string
	SetName(value string) DeviceIpv4
	// contains filtered or unexported methods
}

func NewDeviceIpv4 added in v0.6.5 

func NewDeviceIpv4() DeviceIpv4

type DeviceIpv4Loopback added in v0.6.1 

type DeviceIpv4Loopback interface {
	Msg() *snappipb.DeviceIpv4Loopback
	SetMsg(*snappipb.DeviceIpv4Loopback) DeviceIpv4Loopback
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	EthName() string
	SetEthName(value string) DeviceIpv4Loopback
	Address() string
	SetAddress(value string) DeviceIpv4Loopback
	HasAddress() bool
	Name() string
	SetName(value string) DeviceIpv4Loopback
	// contains filtered or unexported methods
}

func NewDeviceIpv4Loopback added in v0.6.5 

func NewDeviceIpv4Loopback() DeviceIpv4Loopback

type DeviceIpv6 

type DeviceIpv6 interface {
	Msg() *snappipb.DeviceIpv6
	SetMsg(*snappipb.DeviceIpv6) DeviceIpv6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Gateway() string
	SetGateway(value string) DeviceIpv6
	Address() string
	SetAddress(value string) DeviceIpv6
	Prefix() int32
	SetPrefix(value int32) DeviceIpv6
	HasPrefix() bool
	Name() string
	SetName(value string) DeviceIpv6
	// contains filtered or unexported methods
}

func NewDeviceIpv6 added in v0.6.5 

func NewDeviceIpv6() DeviceIpv6

type DeviceIpv6Loopback added in v0.6.1 

type DeviceIpv6Loopback interface {
	Msg() *snappipb.DeviceIpv6Loopback
	SetMsg(*snappipb.DeviceIpv6Loopback) DeviceIpv6Loopback
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	EthName() string
	SetEthName(value string) DeviceIpv6Loopback
	Address() string
	SetAddress(value string) DeviceIpv6Loopback
	HasAddress() bool
	Name() string
	SetName(value string) DeviceIpv6Loopback
	// contains filtered or unexported methods
}

func NewDeviceIpv6Loopback added in v0.6.5 

func NewDeviceIpv6Loopback() DeviceIpv6Loopback

type DeviceIsisMultiInstance added in v0.6.1 

type DeviceIsisMultiInstance interface {
	Msg() *snappipb.DeviceIsisMultiInstance
	SetMsg(*snappipb.DeviceIsisMultiInstance) DeviceIsisMultiInstance
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Iid() int32
	SetIid(value int32) DeviceIsisMultiInstance
	HasIid() bool
	Itids() []int32
	SetItids(value []int32) DeviceIsisMultiInstance
	// contains filtered or unexported methods
}

func NewDeviceIsisMultiInstance added in v0.6.5 

func NewDeviceIsisMultiInstance() DeviceIsisMultiInstance

type DeviceIsisRouter added in v0.6.1 

type DeviceIsisRouter interface {
	Msg() *snappipb.DeviceIsisRouter
	SetMsg(*snappipb.DeviceIsisRouter) DeviceIsisRouter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Instance() DeviceIsisMultiInstance
	SetInstance(value DeviceIsisMultiInstance) DeviceIsisRouter
	HasInstance() bool
	SystemId() string
	SetSystemId(value string) DeviceIsisRouter
	Interfaces() DeviceIsisRouterIsisInterfaceIter
	Basic() IsisBasic
	SetBasic(value IsisBasic) DeviceIsisRouter
	HasBasic() bool
	Advanced() IsisAdvanced
	SetAdvanced(value IsisAdvanced) DeviceIsisRouter
	HasAdvanced() bool
	RouterAuth() IsisAuthentication
	SetRouterAuth(value IsisAuthentication) DeviceIsisRouter
	HasRouterAuth() bool
	V4Routes() DeviceIsisRouterIsisV4RouteRangeIter
	V6Routes() DeviceIsisRouterIsisV6RouteRangeIter
	Name() string
	SetName(value string) DeviceIsisRouter
	// contains filtered or unexported methods
}

func NewDeviceIsisRouter added in v0.6.5 

func NewDeviceIsisRouter() DeviceIsisRouter

type DeviceIsisRouterIsisInterfaceIter added in v0.6.1 

type DeviceIsisRouterIsisInterfaceIter interface {
	Add() IsisInterface
	Items() []IsisInterface
}

type DeviceIsisRouterIsisV4RouteRangeIter added in v0.6.1 

type DeviceIsisRouterIsisV4RouteRangeIter interface {
	Add() IsisV4RouteRange
	Items() []IsisV4RouteRange
}

type DeviceIsisRouterIsisV6RouteRangeIter added in v0.6.1 

type DeviceIsisRouterIsisV6RouteRangeIter interface {
	Add() IsisV6RouteRange
	Items() []IsisV6RouteRange
}

type DeviceVlan 

type DeviceVlan interface {
	Msg() *snappipb.DeviceVlan
	SetMsg(*snappipb.DeviceVlan) DeviceVlan
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Tpid() DeviceVlanTpidEnum
	SetTpid(value DeviceVlanTpidEnum) DeviceVlan
	HasTpid() bool
	Priority() int32
	SetPriority(value int32) DeviceVlan
	HasPriority() bool
	Id() int32
	SetId(value int32) DeviceVlan
	HasId() bool
	Name() string
	SetName(value string) DeviceVlan
	// contains filtered or unexported methods
}

func NewDeviceVlan added in v0.6.5 

func NewDeviceVlan() DeviceVlan

type DeviceVlanTpidEnum 

type DeviceVlanTpidEnum string

type Event 

type Event interface {
	Msg() *snappipb.Event
	SetMsg(*snappipb.Event) Event
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) Event
	HasEnable() bool
	Link() EventLink
	SetLink(value EventLink) Event
	HasLink() bool
	RxRateThreshold() EventRxRateThreshold
	SetRxRateThreshold(value EventRxRateThreshold) Event
	HasRxRateThreshold() bool
	RouteAdvertiseWithdraw() EventRouteAdvertiseWithdraw
	SetRouteAdvertiseWithdraw(value EventRouteAdvertiseWithdraw) Event
	HasRouteAdvertiseWithdraw() bool
	// contains filtered or unexported methods
}

func NewEvent added in v0.6.5 

func NewEvent() Event
type EventLink interface {
	Msg() *snappipb.EventLink
	SetMsg(*snappipb.EventLink) EventLink
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) EventLink
	HasEnable() bool
	// contains filtered or unexported methods
}
func NewEventLink() EventLink

type EventRouteAdvertiseWithdraw 

type EventRouteAdvertiseWithdraw interface {
	Msg() *snappipb.EventRouteAdvertiseWithdraw
	SetMsg(*snappipb.EventRouteAdvertiseWithdraw) EventRouteAdvertiseWithdraw
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) EventRouteAdvertiseWithdraw
	HasEnable() bool
	// contains filtered or unexported methods
}

func NewEventRouteAdvertiseWithdraw added in v0.6.5 

func NewEventRouteAdvertiseWithdraw() EventRouteAdvertiseWithdraw

type EventRxRateThreshold 

type EventRxRateThreshold interface {
	Msg() *snappipb.EventRxRateThreshold
	SetMsg(*snappipb.EventRxRateThreshold) EventRxRateThreshold
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) EventRxRateThreshold
	HasEnable() bool
	Threshold() float32
	SetThreshold(value float32) EventRxRateThreshold
	HasThreshold() bool
	// contains filtered or unexported methods
}

func NewEventRxRateThreshold added in v0.6.5 

func NewEventRxRateThreshold() EventRxRateThreshold

type Flow 

type Flow interface {
	Msg() *snappipb.Flow
	SetMsg(*snappipb.Flow) Flow
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	TxRx() FlowTxRx
	SetTxRx(value FlowTxRx) Flow
	Packet() FlowFlowHeaderIter
	Size() FlowSize
	SetSize(value FlowSize) Flow
	HasSize() bool
	Rate() FlowRate
	SetRate(value FlowRate) Flow
	HasRate() bool
	Duration() FlowDuration
	SetDuration(value FlowDuration) Flow
	HasDuration() bool
	Metrics() FlowMetrics
	SetMetrics(value FlowMetrics) Flow
	HasMetrics() bool
	Name() string
	SetName(value string) Flow
	// contains filtered or unexported methods
}

func NewFlow added in v0.6.5 

func NewFlow() Flow

type FlowArp 

type FlowArp interface {
	Msg() *snappipb.FlowArp
	SetMsg(*snappipb.FlowArp) FlowArp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	HardwareType() PatternFlowArpHardwareType
	SetHardwareType(value PatternFlowArpHardwareType) FlowArp
	HasHardwareType() bool
	ProtocolType() PatternFlowArpProtocolType
	SetProtocolType(value PatternFlowArpProtocolType) FlowArp
	HasProtocolType() bool
	HardwareLength() PatternFlowArpHardwareLength
	SetHardwareLength(value PatternFlowArpHardwareLength) FlowArp
	HasHardwareLength() bool
	ProtocolLength() PatternFlowArpProtocolLength
	SetProtocolLength(value PatternFlowArpProtocolLength) FlowArp
	HasProtocolLength() bool
	Operation() PatternFlowArpOperation
	SetOperation(value PatternFlowArpOperation) FlowArp
	HasOperation() bool
	SenderHardwareAddr() PatternFlowArpSenderHardwareAddr
	SetSenderHardwareAddr(value PatternFlowArpSenderHardwareAddr) FlowArp
	HasSenderHardwareAddr() bool
	SenderProtocolAddr() PatternFlowArpSenderProtocolAddr
	SetSenderProtocolAddr(value PatternFlowArpSenderProtocolAddr) FlowArp
	HasSenderProtocolAddr() bool
	TargetHardwareAddr() PatternFlowArpTargetHardwareAddr
	SetTargetHardwareAddr(value PatternFlowArpTargetHardwareAddr) FlowArp
	HasTargetHardwareAddr() bool
	TargetProtocolAddr() PatternFlowArpTargetProtocolAddr
	SetTargetProtocolAddr(value PatternFlowArpTargetProtocolAddr) FlowArp
	HasTargetProtocolAddr() bool
	// contains filtered or unexported methods
}

func NewFlowArp added in v0.6.5 

func NewFlowArp() FlowArp

type FlowBurst 

type FlowBurst interface {
	Msg() *snappipb.FlowBurst
	SetMsg(*snappipb.FlowBurst) FlowBurst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Bursts() int32
	SetBursts(value int32) FlowBurst
	HasBursts() bool
	Packets() int32
	SetPackets(value int32) FlowBurst
	HasPackets() bool
	Gap() int32
	SetGap(value int32) FlowBurst
	HasGap() bool
	InterBurstGap() FlowDurationInterBurstGap
	SetInterBurstGap(value FlowDurationInterBurstGap) FlowBurst
	HasInterBurstGap() bool
	// contains filtered or unexported methods
}

func NewFlowBurst added in v0.6.5 

func NewFlowBurst() FlowBurst

type FlowContinuous 

type FlowContinuous interface {
	Msg() *snappipb.FlowContinuous
	SetMsg(*snappipb.FlowContinuous) FlowContinuous
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Gap() int32
	SetGap(value int32) FlowContinuous
	HasGap() bool
	Delay() FlowDelay
	SetDelay(value FlowDelay) FlowContinuous
	HasDelay() bool
	// contains filtered or unexported methods
}

func NewFlowContinuous added in v0.6.5 

func NewFlowContinuous() FlowContinuous

type FlowCustom 

type FlowCustom interface {
	Msg() *snappipb.FlowCustom
	SetMsg(*snappipb.FlowCustom) FlowCustom
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Bytes() string
	SetBytes(value string) FlowCustom
	// contains filtered or unexported methods
}

func NewFlowCustom added in v0.6.5 

func NewFlowCustom() FlowCustom

type FlowDelay 

type FlowDelay interface {
	Msg() *snappipb.FlowDelay
	SetMsg(*snappipb.FlowDelay) FlowDelay
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowDelayChoiceEnum
	SetChoice(value FlowDelayChoiceEnum) FlowDelay
	HasChoice() bool
	Bytes() float32
	SetBytes(value float32) FlowDelay
	HasBytes() bool
	Nanoseconds() float32
	SetNanoseconds(value float32) FlowDelay
	HasNanoseconds() bool
	Microseconds() float32
	SetMicroseconds(value float32) FlowDelay
	HasMicroseconds() bool
	// contains filtered or unexported methods
}

func NewFlowDelay added in v0.6.5 

func NewFlowDelay() FlowDelay

type FlowDelayChoiceEnum 

type FlowDelayChoiceEnum string

type FlowDuration 

type FlowDuration interface {
	Msg() *snappipb.FlowDuration
	SetMsg(*snappipb.FlowDuration) FlowDuration
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowDurationChoiceEnum
	SetChoice(value FlowDurationChoiceEnum) FlowDuration
	HasChoice() bool
	FixedPackets() FlowFixedPackets
	SetFixedPackets(value FlowFixedPackets) FlowDuration
	HasFixedPackets() bool
	FixedSeconds() FlowFixedSeconds
	SetFixedSeconds(value FlowFixedSeconds) FlowDuration
	HasFixedSeconds() bool
	Burst() FlowBurst
	SetBurst(value FlowBurst) FlowDuration
	HasBurst() bool
	Continuous() FlowContinuous
	SetContinuous(value FlowContinuous) FlowDuration
	HasContinuous() bool
	// contains filtered or unexported methods
}

func NewFlowDuration added in v0.6.5 

func NewFlowDuration() FlowDuration

type FlowDurationChoiceEnum 

type FlowDurationChoiceEnum string

type FlowDurationInterBurstGap 

type FlowDurationInterBurstGap interface {
	Msg() *snappipb.FlowDurationInterBurstGap
	SetMsg(*snappipb.FlowDurationInterBurstGap) FlowDurationInterBurstGap
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowDurationInterBurstGapChoiceEnum
	SetChoice(value FlowDurationInterBurstGapChoiceEnum) FlowDurationInterBurstGap
	HasChoice() bool
	Bytes() float64
	SetBytes(value float64) FlowDurationInterBurstGap
	HasBytes() bool
	Nanoseconds() float64
	SetNanoseconds(value float64) FlowDurationInterBurstGap
	HasNanoseconds() bool
	Microseconds() float64
	SetMicroseconds(value float64) FlowDurationInterBurstGap
	HasMicroseconds() bool
	// contains filtered or unexported methods
}

func NewFlowDurationInterBurstGap added in v0.6.5 

func NewFlowDurationInterBurstGap() FlowDurationInterBurstGap

type FlowDurationInterBurstGapChoiceEnum 

type FlowDurationInterBurstGapChoiceEnum string

type FlowEthernet 

type FlowEthernet interface {
	Msg() *snappipb.FlowEthernet
	SetMsg(*snappipb.FlowEthernet) FlowEthernet
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Dst() PatternFlowEthernetDst
	SetDst(value PatternFlowEthernetDst) FlowEthernet
	HasDst() bool
	Src() PatternFlowEthernetSrc
	SetSrc(value PatternFlowEthernetSrc) FlowEthernet
	HasSrc() bool
	EtherType() PatternFlowEthernetEtherType
	SetEtherType(value PatternFlowEthernetEtherType) FlowEthernet
	HasEtherType() bool
	PfcQueue() PatternFlowEthernetPfcQueue
	SetPfcQueue(value PatternFlowEthernetPfcQueue) FlowEthernet
	HasPfcQueue() bool
	// contains filtered or unexported methods
}

func NewFlowEthernet added in v0.6.5 

func NewFlowEthernet() FlowEthernet

type FlowEthernetPause 

type FlowEthernetPause interface {
	Msg() *snappipb.FlowEthernetPause
	SetMsg(*snappipb.FlowEthernetPause) FlowEthernetPause
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Dst() PatternFlowEthernetPauseDst
	SetDst(value PatternFlowEthernetPauseDst) FlowEthernetPause
	HasDst() bool
	Src() PatternFlowEthernetPauseSrc
	SetSrc(value PatternFlowEthernetPauseSrc) FlowEthernetPause
	HasSrc() bool
	EtherType() PatternFlowEthernetPauseEtherType
	SetEtherType(value PatternFlowEthernetPauseEtherType) FlowEthernetPause
	HasEtherType() bool
	ControlOpCode() PatternFlowEthernetPauseControlOpCode
	SetControlOpCode(value PatternFlowEthernetPauseControlOpCode) FlowEthernetPause
	HasControlOpCode() bool
	Time() PatternFlowEthernetPauseTime
	SetTime(value PatternFlowEthernetPauseTime) FlowEthernetPause
	HasTime() bool
	// contains filtered or unexported methods
}

func NewFlowEthernetPause added in v0.6.5 

func NewFlowEthernetPause() FlowEthernetPause

type FlowFixedPackets 

type FlowFixedPackets interface {
	Msg() *snappipb.FlowFixedPackets
	SetMsg(*snappipb.FlowFixedPackets) FlowFixedPackets
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Packets() int32
	SetPackets(value int32) FlowFixedPackets
	HasPackets() bool
	Gap() int32
	SetGap(value int32) FlowFixedPackets
	HasGap() bool
	Delay() FlowDelay
	SetDelay(value FlowDelay) FlowFixedPackets
	HasDelay() bool
	// contains filtered or unexported methods
}

func NewFlowFixedPackets added in v0.6.5 

func NewFlowFixedPackets() FlowFixedPackets

type FlowFixedSeconds 

type FlowFixedSeconds interface {
	Msg() *snappipb.FlowFixedSeconds
	SetMsg(*snappipb.FlowFixedSeconds) FlowFixedSeconds
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Seconds() float32
	SetSeconds(value float32) FlowFixedSeconds
	HasSeconds() bool
	Gap() int32
	SetGap(value int32) FlowFixedSeconds
	HasGap() bool
	Delay() FlowDelay
	SetDelay(value FlowDelay) FlowFixedSeconds
	HasDelay() bool
	// contains filtered or unexported methods
}

func NewFlowFixedSeconds added in v0.6.5 

func NewFlowFixedSeconds() FlowFixedSeconds

type FlowFlowHeaderIter 

type FlowFlowHeaderIter interface {
	Add() FlowHeader
	Items() []FlowHeader
}

type FlowGre 

type FlowGre interface {
	Msg() *snappipb.FlowGre
	SetMsg(*snappipb.FlowGre) FlowGre
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	ChecksumPresent() PatternFlowGreChecksumPresent
	SetChecksumPresent(value PatternFlowGreChecksumPresent) FlowGre
	HasChecksumPresent() bool
	Reserved0() PatternFlowGreReserved0
	SetReserved0(value PatternFlowGreReserved0) FlowGre
	HasReserved0() bool
	Version() PatternFlowGreVersion
	SetVersion(value PatternFlowGreVersion) FlowGre
	HasVersion() bool
	Protocol() PatternFlowGreProtocol
	SetProtocol(value PatternFlowGreProtocol) FlowGre
	HasProtocol() bool
	Checksum() PatternFlowGreChecksum
	SetChecksum(value PatternFlowGreChecksum) FlowGre
	HasChecksum() bool
	Reserved1() PatternFlowGreReserved1
	SetReserved1(value PatternFlowGreReserved1) FlowGre
	HasReserved1() bool
	// contains filtered or unexported methods
}

func NewFlowGre added in v0.6.5 

func NewFlowGre() FlowGre

type FlowGtpExtension 

type FlowGtpExtension interface {
	Msg() *snappipb.FlowGtpExtension
	SetMsg(*snappipb.FlowGtpExtension) FlowGtpExtension
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	ExtensionLength() PatternFlowGtpExtensionExtensionLength
	SetExtensionLength(value PatternFlowGtpExtensionExtensionLength) FlowGtpExtension
	HasExtensionLength() bool
	Contents() PatternFlowGtpExtensionContents
	SetContents(value PatternFlowGtpExtensionContents) FlowGtpExtension
	HasContents() bool
	NextExtensionHeader() PatternFlowGtpExtensionNextExtensionHeader
	SetNextExtensionHeader(value PatternFlowGtpExtensionNextExtensionHeader) FlowGtpExtension
	HasNextExtensionHeader() bool
	// contains filtered or unexported methods
}

func NewFlowGtpExtension added in v0.6.5 

func NewFlowGtpExtension() FlowGtpExtension

type FlowGtpv1 

type FlowGtpv1 interface {
	Msg() *snappipb.FlowGtpv1
	SetMsg(*snappipb.FlowGtpv1) FlowGtpv1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() PatternFlowGtpv1Version
	SetVersion(value PatternFlowGtpv1Version) FlowGtpv1
	HasVersion() bool
	ProtocolType() PatternFlowGtpv1ProtocolType
	SetProtocolType(value PatternFlowGtpv1ProtocolType) FlowGtpv1
	HasProtocolType() bool
	Reserved() PatternFlowGtpv1Reserved
	SetReserved(value PatternFlowGtpv1Reserved) FlowGtpv1
	HasReserved() bool
	EFlag() PatternFlowGtpv1EFlag
	SetEFlag(value PatternFlowGtpv1EFlag) FlowGtpv1
	HasEFlag() bool
	SFlag() PatternFlowGtpv1SFlag
	SetSFlag(value PatternFlowGtpv1SFlag) FlowGtpv1
	HasSFlag() bool
	PnFlag() PatternFlowGtpv1PnFlag
	SetPnFlag(value PatternFlowGtpv1PnFlag) FlowGtpv1
	HasPnFlag() bool
	MessageType() PatternFlowGtpv1MessageType
	SetMessageType(value PatternFlowGtpv1MessageType) FlowGtpv1
	HasMessageType() bool
	MessageLength() PatternFlowGtpv1MessageLength
	SetMessageLength(value PatternFlowGtpv1MessageLength) FlowGtpv1
	HasMessageLength() bool
	Teid() PatternFlowGtpv1Teid
	SetTeid(value PatternFlowGtpv1Teid) FlowGtpv1
	HasTeid() bool
	SquenceNumber() PatternFlowGtpv1SquenceNumber
	SetSquenceNumber(value PatternFlowGtpv1SquenceNumber) FlowGtpv1
	HasSquenceNumber() bool
	NPduNumber() PatternFlowGtpv1NPduNumber
	SetNPduNumber(value PatternFlowGtpv1NPduNumber) FlowGtpv1
	HasNPduNumber() bool
	NextExtensionHeaderType() PatternFlowGtpv1NextExtensionHeaderType
	SetNextExtensionHeaderType(value PatternFlowGtpv1NextExtensionHeaderType) FlowGtpv1
	HasNextExtensionHeaderType() bool
	ExtensionHeaders() FlowGtpv1FlowGtpExtensionIter
	// contains filtered or unexported methods
}

func NewFlowGtpv1 added in v0.6.5 

func NewFlowGtpv1() FlowGtpv1

type FlowGtpv1FlowGtpExtensionIter 

type FlowGtpv1FlowGtpExtensionIter interface {
	Add() FlowGtpExtension
	Items() []FlowGtpExtension
}

type FlowGtpv2 

type FlowGtpv2 interface {
	Msg() *snappipb.FlowGtpv2
	SetMsg(*snappipb.FlowGtpv2) FlowGtpv2
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() PatternFlowGtpv2Version
	SetVersion(value PatternFlowGtpv2Version) FlowGtpv2
	HasVersion() bool
	PiggybackingFlag() PatternFlowGtpv2PiggybackingFlag
	SetPiggybackingFlag(value PatternFlowGtpv2PiggybackingFlag) FlowGtpv2
	HasPiggybackingFlag() bool
	TeidFlag() PatternFlowGtpv2TeidFlag
	SetTeidFlag(value PatternFlowGtpv2TeidFlag) FlowGtpv2
	HasTeidFlag() bool
	Spare1() PatternFlowGtpv2Spare1
	SetSpare1(value PatternFlowGtpv2Spare1) FlowGtpv2
	HasSpare1() bool
	MessageType() PatternFlowGtpv2MessageType
	SetMessageType(value PatternFlowGtpv2MessageType) FlowGtpv2
	HasMessageType() bool
	MessageLength() PatternFlowGtpv2MessageLength
	SetMessageLength(value PatternFlowGtpv2MessageLength) FlowGtpv2
	HasMessageLength() bool
	Teid() PatternFlowGtpv2Teid
	SetTeid(value PatternFlowGtpv2Teid) FlowGtpv2
	HasTeid() bool
	SequenceNumber() PatternFlowGtpv2SequenceNumber
	SetSequenceNumber(value PatternFlowGtpv2SequenceNumber) FlowGtpv2
	HasSequenceNumber() bool
	Spare2() PatternFlowGtpv2Spare2
	SetSpare2(value PatternFlowGtpv2Spare2) FlowGtpv2
	HasSpare2() bool
	// contains filtered or unexported methods
}

func NewFlowGtpv2 added in v0.6.5 

func NewFlowGtpv2() FlowGtpv2

type FlowHeader 

type FlowHeader interface {
	Msg() *snappipb.FlowHeader
	SetMsg(*snappipb.FlowHeader) FlowHeader
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowHeaderChoiceEnum
	SetChoice(value FlowHeaderChoiceEnum) FlowHeader
	HasChoice() bool
	Custom() FlowCustom
	SetCustom(value FlowCustom) FlowHeader
	HasCustom() bool
	Ethernet() FlowEthernet
	SetEthernet(value FlowEthernet) FlowHeader
	HasEthernet() bool
	Vlan() FlowVlan
	SetVlan(value FlowVlan) FlowHeader
	HasVlan() bool
	Vxlan() FlowVxlan
	SetVxlan(value FlowVxlan) FlowHeader
	HasVxlan() bool
	Ipv4() FlowIpv4
	SetIpv4(value FlowIpv4) FlowHeader
	HasIpv4() bool
	Ipv6() FlowIpv6
	SetIpv6(value FlowIpv6) FlowHeader
	HasIpv6() bool
	Pfcpause() FlowPfcPause
	SetPfcpause(value FlowPfcPause) FlowHeader
	HasPfcpause() bool
	Ethernetpause() FlowEthernetPause
	SetEthernetpause(value FlowEthernetPause) FlowHeader
	HasEthernetpause() bool
	Tcp() FlowTcp
	SetTcp(value FlowTcp) FlowHeader
	HasTcp() bool
	Udp() FlowUdp
	SetUdp(value FlowUdp) FlowHeader
	HasUdp() bool
	Gre() FlowGre
	SetGre(value FlowGre) FlowHeader
	HasGre() bool
	Gtpv1() FlowGtpv1
	SetGtpv1(value FlowGtpv1) FlowHeader
	HasGtpv1() bool
	Gtpv2() FlowGtpv2
	SetGtpv2(value FlowGtpv2) FlowHeader
	HasGtpv2() bool
	Arp() FlowArp
	SetArp(value FlowArp) FlowHeader
	HasArp() bool
	Icmp() FlowIcmp
	SetIcmp(value FlowIcmp) FlowHeader
	HasIcmp() bool
	Icmpv6() FlowIcmpv6
	SetIcmpv6(value FlowIcmpv6) FlowHeader
	HasIcmpv6() bool
	Ppp() FlowPpp
	SetPpp(value FlowPpp) FlowHeader
	HasPpp() bool
	Igmpv1() FlowIgmpv1
	SetIgmpv1(value FlowIgmpv1) FlowHeader
	HasIgmpv1() bool
	// contains filtered or unexported methods
}

func NewFlowHeader added in v0.6.5 

func NewFlowHeader() FlowHeader

type FlowHeaderChoiceEnum 

type FlowHeaderChoiceEnum string

type FlowIcmp 

type FlowIcmp interface {
	Msg() *snappipb.FlowIcmp
	SetMsg(*snappipb.FlowIcmp) FlowIcmp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowIcmpChoiceEnum
	SetChoice(value FlowIcmpChoiceEnum) FlowIcmp
	HasChoice() bool
	Echo() FlowIcmpEcho
	SetEcho(value FlowIcmpEcho) FlowIcmp
	HasEcho() bool
	// contains filtered or unexported methods
}

func NewFlowIcmp added in v0.6.5 

func NewFlowIcmp() FlowIcmp

type FlowIcmpChoiceEnum 

type FlowIcmpChoiceEnum string

type FlowIcmpEcho 

type FlowIcmpEcho interface {
	Msg() *snappipb.FlowIcmpEcho
	SetMsg(*snappipb.FlowIcmpEcho) FlowIcmpEcho
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Type() PatternFlowIcmpEchoType
	SetType(value PatternFlowIcmpEchoType) FlowIcmpEcho
	HasType() bool
	Code() PatternFlowIcmpEchoCode
	SetCode(value PatternFlowIcmpEchoCode) FlowIcmpEcho
	HasCode() bool
	Checksum() PatternFlowIcmpEchoChecksum
	SetChecksum(value PatternFlowIcmpEchoChecksum) FlowIcmpEcho
	HasChecksum() bool
	Identifier() PatternFlowIcmpEchoIdentifier
	SetIdentifier(value PatternFlowIcmpEchoIdentifier) FlowIcmpEcho
	HasIdentifier() bool
	SequenceNumber() PatternFlowIcmpEchoSequenceNumber
	SetSequenceNumber(value PatternFlowIcmpEchoSequenceNumber) FlowIcmpEcho
	HasSequenceNumber() bool
	// contains filtered or unexported methods
}

func NewFlowIcmpEcho added in v0.6.5 

func NewFlowIcmpEcho() FlowIcmpEcho

type FlowIcmpv6 

type FlowIcmpv6 interface {
	Msg() *snappipb.FlowIcmpv6
	SetMsg(*snappipb.FlowIcmpv6) FlowIcmpv6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowIcmpv6ChoiceEnum
	SetChoice(value FlowIcmpv6ChoiceEnum) FlowIcmpv6
	HasChoice() bool
	Echo() FlowIcmpv6Echo
	SetEcho(value FlowIcmpv6Echo) FlowIcmpv6
	HasEcho() bool
	// contains filtered or unexported methods
}

func NewFlowIcmpv6 added in v0.6.5 

func NewFlowIcmpv6() FlowIcmpv6

type FlowIcmpv6ChoiceEnum 

type FlowIcmpv6ChoiceEnum string

type FlowIcmpv6Echo 

type FlowIcmpv6Echo interface {
	Msg() *snappipb.FlowIcmpv6Echo
	SetMsg(*snappipb.FlowIcmpv6Echo) FlowIcmpv6Echo
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Type() PatternFlowIcmpv6EchoType
	SetType(value PatternFlowIcmpv6EchoType) FlowIcmpv6Echo
	HasType() bool
	Code() PatternFlowIcmpv6EchoCode
	SetCode(value PatternFlowIcmpv6EchoCode) FlowIcmpv6Echo
	HasCode() bool
	Identifier() PatternFlowIcmpv6EchoIdentifier
	SetIdentifier(value PatternFlowIcmpv6EchoIdentifier) FlowIcmpv6Echo
	HasIdentifier() bool
	SequenceNumber() PatternFlowIcmpv6EchoSequenceNumber
	SetSequenceNumber(value PatternFlowIcmpv6EchoSequenceNumber) FlowIcmpv6Echo
	HasSequenceNumber() bool
	Checksum() PatternFlowIcmpv6EchoChecksum
	SetChecksum(value PatternFlowIcmpv6EchoChecksum) FlowIcmpv6Echo
	HasChecksum() bool
	// contains filtered or unexported methods
}

func NewFlowIcmpv6Echo added in v0.6.5 

func NewFlowIcmpv6Echo() FlowIcmpv6Echo

type FlowIgmpv1 

type FlowIgmpv1 interface {
	Msg() *snappipb.FlowIgmpv1
	SetMsg(*snappipb.FlowIgmpv1) FlowIgmpv1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() PatternFlowIgmpv1Version
	SetVersion(value PatternFlowIgmpv1Version) FlowIgmpv1
	HasVersion() bool
	Type() PatternFlowIgmpv1Type
	SetType(value PatternFlowIgmpv1Type) FlowIgmpv1
	HasType() bool
	Unused() PatternFlowIgmpv1Unused
	SetUnused(value PatternFlowIgmpv1Unused) FlowIgmpv1
	HasUnused() bool
	Checksum() PatternFlowIgmpv1Checksum
	SetChecksum(value PatternFlowIgmpv1Checksum) FlowIgmpv1
	HasChecksum() bool
	GroupAddress() PatternFlowIgmpv1GroupAddress
	SetGroupAddress(value PatternFlowIgmpv1GroupAddress) FlowIgmpv1
	HasGroupAddress() bool
	// contains filtered or unexported methods
}

func NewFlowIgmpv1 added in v0.6.5 

func NewFlowIgmpv1() FlowIgmpv1

type FlowIpv4 

type FlowIpv4 interface {
	Msg() *snappipb.FlowIpv4
	SetMsg(*snappipb.FlowIpv4) FlowIpv4
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() PatternFlowIpv4Version
	SetVersion(value PatternFlowIpv4Version) FlowIpv4
	HasVersion() bool
	HeaderLength() PatternFlowIpv4HeaderLength
	SetHeaderLength(value PatternFlowIpv4HeaderLength) FlowIpv4
	HasHeaderLength() bool
	Priority() FlowIpv4Priority
	SetPriority(value FlowIpv4Priority) FlowIpv4
	HasPriority() bool
	TotalLength() PatternFlowIpv4TotalLength
	SetTotalLength(value PatternFlowIpv4TotalLength) FlowIpv4
	HasTotalLength() bool
	Identification() PatternFlowIpv4Identification
	SetIdentification(value PatternFlowIpv4Identification) FlowIpv4
	HasIdentification() bool
	Reserved() PatternFlowIpv4Reserved
	SetReserved(value PatternFlowIpv4Reserved) FlowIpv4
	HasReserved() bool
	DontFragment() PatternFlowIpv4DontFragment
	SetDontFragment(value PatternFlowIpv4DontFragment) FlowIpv4
	HasDontFragment() bool
	MoreFragments() PatternFlowIpv4MoreFragments
	SetMoreFragments(value PatternFlowIpv4MoreFragments) FlowIpv4
	HasMoreFragments() bool
	FragmentOffset() PatternFlowIpv4FragmentOffset
	SetFragmentOffset(value PatternFlowIpv4FragmentOffset) FlowIpv4
	HasFragmentOffset() bool
	TimeToLive() PatternFlowIpv4TimeToLive
	SetTimeToLive(value PatternFlowIpv4TimeToLive) FlowIpv4
	HasTimeToLive() bool
	Protocol() PatternFlowIpv4Protocol
	SetProtocol(value PatternFlowIpv4Protocol) FlowIpv4
	HasProtocol() bool
	HeaderChecksum() PatternFlowIpv4HeaderChecksum
	SetHeaderChecksum(value PatternFlowIpv4HeaderChecksum) FlowIpv4
	HasHeaderChecksum() bool
	Src() PatternFlowIpv4Src
	SetSrc(value PatternFlowIpv4Src) FlowIpv4
	HasSrc() bool
	Dst() PatternFlowIpv4Dst
	SetDst(value PatternFlowIpv4Dst) FlowIpv4
	HasDst() bool
	// contains filtered or unexported methods
}

func NewFlowIpv4 added in v0.6.5 

func NewFlowIpv4() FlowIpv4

type FlowIpv4Dscp 

type FlowIpv4Dscp interface {
	Msg() *snappipb.FlowIpv4Dscp
	SetMsg(*snappipb.FlowIpv4Dscp) FlowIpv4Dscp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Phb() PatternFlowIpv4DscpPhb
	SetPhb(value PatternFlowIpv4DscpPhb) FlowIpv4Dscp
	HasPhb() bool
	Ecn() PatternFlowIpv4DscpEcn
	SetEcn(value PatternFlowIpv4DscpEcn) FlowIpv4Dscp
	HasEcn() bool
	// contains filtered or unexported methods
}

func NewFlowIpv4Dscp added in v0.6.5 

func NewFlowIpv4Dscp() FlowIpv4Dscp

type FlowIpv4Priority 

type FlowIpv4Priority interface {
	Msg() *snappipb.FlowIpv4Priority
	SetMsg(*snappipb.FlowIpv4Priority) FlowIpv4Priority
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowIpv4PriorityChoiceEnum
	SetChoice(value FlowIpv4PriorityChoiceEnum) FlowIpv4Priority
	HasChoice() bool
	Raw() PatternFlowIpv4PriorityRaw
	SetRaw(value PatternFlowIpv4PriorityRaw) FlowIpv4Priority
	HasRaw() bool
	Tos() FlowIpv4Tos
	SetTos(value FlowIpv4Tos) FlowIpv4Priority
	HasTos() bool
	Dscp() FlowIpv4Dscp
	SetDscp(value FlowIpv4Dscp) FlowIpv4Priority
	HasDscp() bool
	// contains filtered or unexported methods
}

func NewFlowIpv4Priority added in v0.6.5 

func NewFlowIpv4Priority() FlowIpv4Priority

type FlowIpv4PriorityChoiceEnum 

type FlowIpv4PriorityChoiceEnum string

type FlowIpv4Tos 

type FlowIpv4Tos interface {
	Msg() *snappipb.FlowIpv4Tos
	SetMsg(*snappipb.FlowIpv4Tos) FlowIpv4Tos
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Precedence() PatternFlowIpv4TosPrecedence
	SetPrecedence(value PatternFlowIpv4TosPrecedence) FlowIpv4Tos
	HasPrecedence() bool
	Delay() PatternFlowIpv4TosDelay
	SetDelay(value PatternFlowIpv4TosDelay) FlowIpv4Tos
	HasDelay() bool
	Throughput() PatternFlowIpv4TosThroughput
	SetThroughput(value PatternFlowIpv4TosThroughput) FlowIpv4Tos
	HasThroughput() bool
	Reliability() PatternFlowIpv4TosReliability
	SetReliability(value PatternFlowIpv4TosReliability) FlowIpv4Tos
	HasReliability() bool
	Monetary() PatternFlowIpv4TosMonetary
	SetMonetary(value PatternFlowIpv4TosMonetary) FlowIpv4Tos
	HasMonetary() bool
	Unused() PatternFlowIpv4TosUnused
	SetUnused(value PatternFlowIpv4TosUnused) FlowIpv4Tos
	HasUnused() bool
	// contains filtered or unexported methods
}

func NewFlowIpv4Tos added in v0.6.5 

func NewFlowIpv4Tos() FlowIpv4Tos

type FlowIpv6 

type FlowIpv6 interface {
	Msg() *snappipb.FlowIpv6
	SetMsg(*snappipb.FlowIpv6) FlowIpv6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Version() PatternFlowIpv6Version
	SetVersion(value PatternFlowIpv6Version) FlowIpv6
	HasVersion() bool
	TrafficClass() PatternFlowIpv6TrafficClass
	SetTrafficClass(value PatternFlowIpv6TrafficClass) FlowIpv6
	HasTrafficClass() bool
	FlowLabel() PatternFlowIpv6FlowLabel
	SetFlowLabel(value PatternFlowIpv6FlowLabel) FlowIpv6
	HasFlowLabel() bool
	PayloadLength() PatternFlowIpv6PayloadLength
	SetPayloadLength(value PatternFlowIpv6PayloadLength) FlowIpv6
	HasPayloadLength() bool
	NextHeader() PatternFlowIpv6NextHeader
	SetNextHeader(value PatternFlowIpv6NextHeader) FlowIpv6
	HasNextHeader() bool
	HopLimit() PatternFlowIpv6HopLimit
	SetHopLimit(value PatternFlowIpv6HopLimit) FlowIpv6
	HasHopLimit() bool
	Src() PatternFlowIpv6Src
	SetSrc(value PatternFlowIpv6Src) FlowIpv6
	HasSrc() bool
	Dst() PatternFlowIpv6Dst
	SetDst(value PatternFlowIpv6Dst) FlowIpv6
	HasDst() bool
	// contains filtered or unexported methods
}

func NewFlowIpv6 added in v0.6.5 

func NewFlowIpv6() FlowIpv6

type FlowLatencyMetrics 

type FlowLatencyMetrics interface {
	Msg() *snappipb.FlowLatencyMetrics
	SetMsg(*snappipb.FlowLatencyMetrics) FlowLatencyMetrics
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) FlowLatencyMetrics
	HasEnable() bool
	Mode() FlowLatencyMetricsModeEnum
	SetMode(value FlowLatencyMetricsModeEnum) FlowLatencyMetrics
	HasMode() bool
	// contains filtered or unexported methods
}

func NewFlowLatencyMetrics added in v0.6.5 

func NewFlowLatencyMetrics() FlowLatencyMetrics

type FlowLatencyMetricsModeEnum 

type FlowLatencyMetricsModeEnum string

type FlowMetric 

type FlowMetric interface {
	Msg() *snappipb.FlowMetric
	SetMsg(*snappipb.FlowMetric) FlowMetric
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) FlowMetric
	HasName() bool
	PortTx() string
	SetPortTx(value string) FlowMetric
	HasPortTx() bool
	PortRx() string
	SetPortRx(value string) FlowMetric
	HasPortRx() bool
	MetricGroups() FlowMetricFlowMetricGroupIter
	Transmit() FlowMetricTransmitEnum
	SetTransmit(value FlowMetricTransmitEnum) FlowMetric
	HasTransmit() bool
	FramesTx() int32
	SetFramesTx(value int32) FlowMetric
	HasFramesTx() bool
	FramesRx() int32
	SetFramesRx(value int32) FlowMetric
	HasFramesRx() bool
	BytesTx() int32
	SetBytesTx(value int32) FlowMetric
	HasBytesTx() bool
	BytesRx() int32
	SetBytesRx(value int32) FlowMetric
	HasBytesRx() bool
	FramesTxRate() float32
	SetFramesTxRate(value float32) FlowMetric
	HasFramesTxRate() bool
	FramesRxRate() float32
	SetFramesRxRate(value float32) FlowMetric
	HasFramesRxRate() bool
	Loss() float32
	SetLoss(value float32) FlowMetric
	HasLoss() bool
	Timestamps() MetricTimestamp
	SetTimestamps(value MetricTimestamp) FlowMetric
	HasTimestamps() bool
	Latency() MetricLatency
	SetLatency(value MetricLatency) FlowMetric
	HasLatency() bool
	// contains filtered or unexported methods
}

func NewFlowMetric added in v0.6.5 

func NewFlowMetric() FlowMetric

type FlowMetricFlowMetricGroupIter 

type FlowMetricFlowMetricGroupIter interface {
	Add() FlowMetricGroup
	Items() []FlowMetricGroup
}

type FlowMetricGroup 

type FlowMetricGroup interface {
	Msg() *snappipb.FlowMetricGroup
	SetMsg(*snappipb.FlowMetricGroup) FlowMetricGroup
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) FlowMetricGroup
	HasName() bool
	Value() string
	SetValue(value string) FlowMetricGroup
	HasValue() bool
	// contains filtered or unexported methods
}

func NewFlowMetricGroup added in v0.6.5 

func NewFlowMetricGroup() FlowMetricGroup

type FlowMetricGroupRequest 

type FlowMetricGroupRequest interface {
	Msg() *snappipb.FlowMetricGroupRequest
	SetMsg(*snappipb.FlowMetricGroupRequest) FlowMetricGroupRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowMetricGroupRequestChoiceEnum
	SetChoice(value FlowMetricGroupRequestChoiceEnum) FlowMetricGroupRequest
	HasChoice() bool
	Ingress() []string
	SetIngress(value []string) FlowMetricGroupRequest
	Egress() []string
	SetEgress(value []string) FlowMetricGroupRequest
	// contains filtered or unexported methods
}

func NewFlowMetricGroupRequest added in v0.6.5 

func NewFlowMetricGroupRequest() FlowMetricGroupRequest

type FlowMetricGroupRequestChoiceEnum 

type FlowMetricGroupRequestChoiceEnum string

type FlowMetricTransmitEnum 

type FlowMetricTransmitEnum string

type FlowMetrics 

type FlowMetrics interface {
	Msg() *snappipb.FlowMetrics
	SetMsg(*snappipb.FlowMetrics) FlowMetrics
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Enable() bool
	SetEnable(value bool) FlowMetrics
	HasEnable() bool
	Loss() bool
	SetLoss(value bool) FlowMetrics
	HasLoss() bool
	Timestamps() bool
	SetTimestamps(value bool) FlowMetrics
	HasTimestamps() bool
	Latency() FlowLatencyMetrics
	SetLatency(value FlowLatencyMetrics) FlowMetrics
	HasLatency() bool
	// contains filtered or unexported methods
}

func NewFlowMetrics added in v0.6.5 

func NewFlowMetrics() FlowMetrics

type FlowMetricsRequest 

type FlowMetricsRequest interface {
	Msg() *snappipb.FlowMetricsRequest
	SetMsg(*snappipb.FlowMetricsRequest) FlowMetricsRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	FlowNames() []string
	SetFlowNames(value []string) FlowMetricsRequest
	MetricGroups() FlowMetricGroupRequest
	SetMetricGroups(value FlowMetricGroupRequest) FlowMetricsRequest
	HasMetricGroups() bool
	MetricNames() []FlowMetricsRequestMetricNamesEnum
	SetMetricNames(value []FlowMetricsRequestMetricNamesEnum) FlowMetricsRequest
	// contains filtered or unexported methods
}

func NewFlowMetricsRequest added in v0.6.5 

func NewFlowMetricsRequest() FlowMetricsRequest

type FlowMetricsRequestMetricNamesEnum 

type FlowMetricsRequestMetricNamesEnum string

type FlowPfcPause 

type FlowPfcPause interface {
	Msg() *snappipb.FlowPfcPause
	SetMsg(*snappipb.FlowPfcPause) FlowPfcPause
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Dst() PatternFlowPfcPauseDst
	SetDst(value PatternFlowPfcPauseDst) FlowPfcPause
	HasDst() bool
	Src() PatternFlowPfcPauseSrc
	SetSrc(value PatternFlowPfcPauseSrc) FlowPfcPause
	HasSrc() bool
	EtherType() PatternFlowPfcPauseEtherType
	SetEtherType(value PatternFlowPfcPauseEtherType) FlowPfcPause
	HasEtherType() bool
	ControlOpCode() PatternFlowPfcPauseControlOpCode
	SetControlOpCode(value PatternFlowPfcPauseControlOpCode) FlowPfcPause
	HasControlOpCode() bool
	ClassEnableVector() PatternFlowPfcPauseClassEnableVector
	SetClassEnableVector(value PatternFlowPfcPauseClassEnableVector) FlowPfcPause
	HasClassEnableVector() bool
	PauseClass0() PatternFlowPfcPausePauseClass0
	SetPauseClass0(value PatternFlowPfcPausePauseClass0) FlowPfcPause
	HasPauseClass0() bool
	PauseClass1() PatternFlowPfcPausePauseClass1
	SetPauseClass1(value PatternFlowPfcPausePauseClass1) FlowPfcPause
	HasPauseClass1() bool
	PauseClass2() PatternFlowPfcPausePauseClass2
	SetPauseClass2(value PatternFlowPfcPausePauseClass2) FlowPfcPause
	HasPauseClass2() bool
	PauseClass3() PatternFlowPfcPausePauseClass3
	SetPauseClass3(value PatternFlowPfcPausePauseClass3) FlowPfcPause
	HasPauseClass3() bool
	PauseClass4() PatternFlowPfcPausePauseClass4
	SetPauseClass4(value PatternFlowPfcPausePauseClass4) FlowPfcPause
	HasPauseClass4() bool
	PauseClass5() PatternFlowPfcPausePauseClass5
	SetPauseClass5(value PatternFlowPfcPausePauseClass5) FlowPfcPause
	HasPauseClass5() bool
	PauseClass6() PatternFlowPfcPausePauseClass6
	SetPauseClass6(value PatternFlowPfcPausePauseClass6) FlowPfcPause
	HasPauseClass6() bool
	PauseClass7() PatternFlowPfcPausePauseClass7
	SetPauseClass7(value PatternFlowPfcPausePauseClass7) FlowPfcPause
	HasPauseClass7() bool
	// contains filtered or unexported methods
}

func NewFlowPfcPause added in v0.6.5 

func NewFlowPfcPause() FlowPfcPause

type FlowPort 

type FlowPort interface {
	Msg() *snappipb.FlowPort
	SetMsg(*snappipb.FlowPort) FlowPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	TxName() string
	SetTxName(value string) FlowPort
	RxName() string
	SetRxName(value string) FlowPort
	HasRxName() bool
	// contains filtered or unexported methods
}

func NewFlowPort added in v0.6.5 

func NewFlowPort() FlowPort

type FlowPpp 

type FlowPpp interface {
	Msg() *snappipb.FlowPpp
	SetMsg(*snappipb.FlowPpp) FlowPpp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Address() PatternFlowPppAddress
	SetAddress(value PatternFlowPppAddress) FlowPpp
	HasAddress() bool
	Control() PatternFlowPppControl
	SetControl(value PatternFlowPppControl) FlowPpp
	HasControl() bool
	ProtocolType() PatternFlowPppProtocolType
	SetProtocolType(value PatternFlowPppProtocolType) FlowPpp
	HasProtocolType() bool
	// contains filtered or unexported methods
}

func NewFlowPpp added in v0.6.5 

func NewFlowPpp() FlowPpp

type FlowRate 

type FlowRate interface {
	Msg() *snappipb.FlowRate
	SetMsg(*snappipb.FlowRate) FlowRate
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowRateChoiceEnum
	SetChoice(value FlowRateChoiceEnum) FlowRate
	HasChoice() bool
	Pps() int64
	SetPps(value int64) FlowRate
	HasPps() bool
	Bps() int64
	SetBps(value int64) FlowRate
	HasBps() bool
	Kbps() int64
	SetKbps(value int64) FlowRate
	HasKbps() bool
	Mbps() int64
	SetMbps(value int64) FlowRate
	HasMbps() bool
	Gbps() int32
	SetGbps(value int32) FlowRate
	HasGbps() bool
	Percentage() float32
	SetPercentage(value float32) FlowRate
	HasPercentage() bool
	// contains filtered or unexported methods
}

func NewFlowRate added in v0.6.5 

func NewFlowRate() FlowRate

type FlowRateChoiceEnum 

type FlowRateChoiceEnum string

type FlowRouter added in v0.6.1 

type FlowRouter interface {
	Msg() *snappipb.FlowRouter
	SetMsg(*snappipb.FlowRouter) FlowRouter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Mode() FlowRouterModeEnum
	SetMode(value FlowRouterModeEnum) FlowRouter
	HasMode() bool
	TxNames() []string
	SetTxNames(value []string) FlowRouter
	RxNames() []string
	SetRxNames(value []string) FlowRouter
	// contains filtered or unexported methods
}

func NewFlowRouter added in v0.6.5 

func NewFlowRouter() FlowRouter

type FlowRouterModeEnum added in v0.6.1 

type FlowRouterModeEnum string

type FlowSize 

type FlowSize interface {
	Msg() *snappipb.FlowSize
	SetMsg(*snappipb.FlowSize) FlowSize
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowSizeChoiceEnum
	SetChoice(value FlowSizeChoiceEnum) FlowSize
	HasChoice() bool
	Fixed() int32
	SetFixed(value int32) FlowSize
	HasFixed() bool
	Increment() FlowSizeIncrement
	SetIncrement(value FlowSizeIncrement) FlowSize
	HasIncrement() bool
	Random() FlowSizeRandom
	SetRandom(value FlowSizeRandom) FlowSize
	HasRandom() bool
	// contains filtered or unexported methods
}

func NewFlowSize added in v0.6.5 

func NewFlowSize() FlowSize

type FlowSizeChoiceEnum 

type FlowSizeChoiceEnum string

type FlowSizeIncrement 

type FlowSizeIncrement interface {
	Msg() *snappipb.FlowSizeIncrement
	SetMsg(*snappipb.FlowSizeIncrement) FlowSizeIncrement
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) FlowSizeIncrement
	HasStart() bool
	End() int32
	SetEnd(value int32) FlowSizeIncrement
	HasEnd() bool
	Step() int32
	SetStep(value int32) FlowSizeIncrement
	HasStep() bool
	// contains filtered or unexported methods
}

func NewFlowSizeIncrement added in v0.6.5 

func NewFlowSizeIncrement() FlowSizeIncrement

type FlowSizeRandom 

type FlowSizeRandom interface {
	Msg() *snappipb.FlowSizeRandom
	SetMsg(*snappipb.FlowSizeRandom) FlowSizeRandom
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Min() int32
	SetMin(value int32) FlowSizeRandom
	HasMin() bool
	Max() int32
	SetMax(value int32) FlowSizeRandom
	HasMax() bool
	// contains filtered or unexported methods
}

func NewFlowSizeRandom added in v0.6.5 

func NewFlowSizeRandom() FlowSizeRandom

type FlowState 

type FlowState interface {
	Msg() *snappipb.FlowState
	SetMsg(*snappipb.FlowState) FlowState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) FlowState
	HasName() bool
	Transmit() FlowStateTransmitEnum
	SetTransmit(value FlowStateTransmitEnum) FlowState
	HasTransmit() bool
	// contains filtered or unexported methods
}

func NewFlowState added in v0.6.5 

func NewFlowState() FlowState

type FlowStateTransmitEnum 

type FlowStateTransmitEnum string

type FlowTcp 

type FlowTcp interface {
	Msg() *snappipb.FlowTcp
	SetMsg(*snappipb.FlowTcp) FlowTcp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SrcPort() PatternFlowTcpSrcPort
	SetSrcPort(value PatternFlowTcpSrcPort) FlowTcp
	HasSrcPort() bool
	DstPort() PatternFlowTcpDstPort
	SetDstPort(value PatternFlowTcpDstPort) FlowTcp
	HasDstPort() bool
	SeqNum() PatternFlowTcpSeqNum
	SetSeqNum(value PatternFlowTcpSeqNum) FlowTcp
	HasSeqNum() bool
	AckNum() PatternFlowTcpAckNum
	SetAckNum(value PatternFlowTcpAckNum) FlowTcp
	HasAckNum() bool
	DataOffset() PatternFlowTcpDataOffset
	SetDataOffset(value PatternFlowTcpDataOffset) FlowTcp
	HasDataOffset() bool
	EcnNs() PatternFlowTcpEcnNs
	SetEcnNs(value PatternFlowTcpEcnNs) FlowTcp
	HasEcnNs() bool
	EcnCwr() PatternFlowTcpEcnCwr
	SetEcnCwr(value PatternFlowTcpEcnCwr) FlowTcp
	HasEcnCwr() bool
	EcnEcho() PatternFlowTcpEcnEcho
	SetEcnEcho(value PatternFlowTcpEcnEcho) FlowTcp
	HasEcnEcho() bool
	CtlUrg() PatternFlowTcpCtlUrg
	SetCtlUrg(value PatternFlowTcpCtlUrg) FlowTcp
	HasCtlUrg() bool
	CtlAck() PatternFlowTcpCtlAck
	SetCtlAck(value PatternFlowTcpCtlAck) FlowTcp
	HasCtlAck() bool
	CtlPsh() PatternFlowTcpCtlPsh
	SetCtlPsh(value PatternFlowTcpCtlPsh) FlowTcp
	HasCtlPsh() bool
	CtlRst() PatternFlowTcpCtlRst
	SetCtlRst(value PatternFlowTcpCtlRst) FlowTcp
	HasCtlRst() bool
	CtlSyn() PatternFlowTcpCtlSyn
	SetCtlSyn(value PatternFlowTcpCtlSyn) FlowTcp
	HasCtlSyn() bool
	CtlFin() PatternFlowTcpCtlFin
	SetCtlFin(value PatternFlowTcpCtlFin) FlowTcp
	HasCtlFin() bool
	Window() PatternFlowTcpWindow
	SetWindow(value PatternFlowTcpWindow) FlowTcp
	HasWindow() bool
	// contains filtered or unexported methods
}

func NewFlowTcp added in v0.6.5 

func NewFlowTcp() FlowTcp

type FlowTxRx 

type FlowTxRx interface {
	Msg() *snappipb.FlowTxRx
	SetMsg(*snappipb.FlowTxRx) FlowTxRx
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() FlowTxRxChoiceEnum
	SetChoice(value FlowTxRxChoiceEnum) FlowTxRx
	HasChoice() bool
	Port() FlowPort
	SetPort(value FlowPort) FlowTxRx
	HasPort() bool
	Device() FlowRouter
	SetDevice(value FlowRouter) FlowTxRx
	HasDevice() bool
	// contains filtered or unexported methods
}

func NewFlowTxRx added in v0.6.5 

func NewFlowTxRx() FlowTxRx

type FlowTxRxChoiceEnum 

type FlowTxRxChoiceEnum string

type FlowUdp 

type FlowUdp interface {
	Msg() *snappipb.FlowUdp
	SetMsg(*snappipb.FlowUdp) FlowUdp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SrcPort() PatternFlowUdpSrcPort
	SetSrcPort(value PatternFlowUdpSrcPort) FlowUdp
	HasSrcPort() bool
	DstPort() PatternFlowUdpDstPort
	SetDstPort(value PatternFlowUdpDstPort) FlowUdp
	HasDstPort() bool
	Length() PatternFlowUdpLength
	SetLength(value PatternFlowUdpLength) FlowUdp
	HasLength() bool
	Checksum() PatternFlowUdpChecksum
	SetChecksum(value PatternFlowUdpChecksum) FlowUdp
	HasChecksum() bool
	// contains filtered or unexported methods
}

func NewFlowUdp added in v0.6.5 

func NewFlowUdp() FlowUdp

type FlowVlan 

type FlowVlan interface {
	Msg() *snappipb.FlowVlan
	SetMsg(*snappipb.FlowVlan) FlowVlan
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Priority() PatternFlowVlanPriority
	SetPriority(value PatternFlowVlanPriority) FlowVlan
	HasPriority() bool
	Cfi() PatternFlowVlanCfi
	SetCfi(value PatternFlowVlanCfi) FlowVlan
	HasCfi() bool
	Id() PatternFlowVlanId
	SetId(value PatternFlowVlanId) FlowVlan
	HasId() bool
	Tpid() PatternFlowVlanTpid
	SetTpid(value PatternFlowVlanTpid) FlowVlan
	HasTpid() bool
	// contains filtered or unexported methods
}

func NewFlowVlan added in v0.6.5 

func NewFlowVlan() FlowVlan

type FlowVxlan 

type FlowVxlan interface {
	Msg() *snappipb.FlowVxlan
	SetMsg(*snappipb.FlowVxlan) FlowVxlan
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Flags() PatternFlowVxlanFlags
	SetFlags(value PatternFlowVxlanFlags) FlowVxlan
	HasFlags() bool
	Reserved0() PatternFlowVxlanReserved0
	SetReserved0(value PatternFlowVxlanReserved0) FlowVxlan
	HasReserved0() bool
	Vni() PatternFlowVxlanVni
	SetVni(value PatternFlowVxlanVni) FlowVxlan
	HasVni() bool
	Reserved1() PatternFlowVxlanReserved1
	SetReserved1(value PatternFlowVxlanReserved1) FlowVxlan
	HasReserved1() bool
	// contains filtered or unexported methods
}

func NewFlowVxlan added in v0.6.5 

func NewFlowVxlan() FlowVxlan

type FlowsUpdate 

type FlowsUpdate interface {
	Msg() *snappipb.FlowsUpdate
	SetMsg(*snappipb.FlowsUpdate) FlowsUpdate
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PropertyNames() []FlowsUpdatePropertyNamesEnum
	SetPropertyNames(value []FlowsUpdatePropertyNamesEnum) FlowsUpdate
	Flows() FlowsUpdateFlowIter
	// contains filtered or unexported methods
}

func NewFlowsUpdate added in v0.6.5 

func NewFlowsUpdate() FlowsUpdate

type FlowsUpdateFlowIter 

type FlowsUpdateFlowIter interface {
	Add() Flow
	Items() []Flow
}

type FlowsUpdatePropertyNamesEnum 

type FlowsUpdatePropertyNamesEnum string

type GetCaptureResponse 

type GetCaptureResponse interface {
	Msg() *snappipb.GetCaptureResponse
	SetMsg(*snappipb.GetCaptureResponse) GetCaptureResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() []byte
	SetStatusCode200(value []byte) GetCaptureResponse
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) GetCaptureResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) GetCaptureResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewGetCaptureResponse added in v0.6.5 

func NewGetCaptureResponse() GetCaptureResponse

type GetConfigResponse 

type GetConfigResponse interface {
	Msg() *snappipb.GetConfigResponse
	SetMsg(*snappipb.GetConfigResponse) GetConfigResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() Config
	SetStatusCode200(value Config) GetConfigResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) GetConfigResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) GetConfigResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewGetConfigResponse added in v0.6.5 

func NewGetConfigResponse() GetConfigResponse

type GetMetricsResponse 

type GetMetricsResponse interface {
	Msg() *snappipb.GetMetricsResponse
	SetMsg(*snappipb.GetMetricsResponse) GetMetricsResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() MetricsResponse
	SetStatusCode200(value MetricsResponse) GetMetricsResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) GetMetricsResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) GetMetricsResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewGetMetricsResponse added in v0.6.5 

func NewGetMetricsResponse() GetMetricsResponse

type GetStateMetricsResponse 

type GetStateMetricsResponse interface {
	Msg() *snappipb.GetStateMetricsResponse
	SetMsg(*snappipb.GetStateMetricsResponse) GetStateMetricsResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() StateMetrics
	SetStatusCode200(value StateMetrics) GetStateMetricsResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) GetStateMetricsResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) GetStateMetricsResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewGetStateMetricsResponse added in v0.6.5 

func NewGetStateMetricsResponse() GetStateMetricsResponse

type GosnappiApi 

type GosnappiApi interface {
	Api
	NewConfig() Config
	NewTransmitState() TransmitState
	NewLinkState() LinkState
	NewCaptureState() CaptureState
	NewFlowsUpdate() FlowsUpdate
	NewRouteState() RouteState
	NewPingRequest() PingRequest
	NewProtocolState() ProtocolState
	NewMetricsRequest() MetricsRequest
	NewCaptureRequest() CaptureRequest
	NewSetConfigResponse() SetConfigResponse
	NewGetConfigResponse() GetConfigResponse
	NewSetTransmitStateResponse() SetTransmitStateResponse
	NewSetLinkStateResponse() SetLinkStateResponse
	NewSetCaptureStateResponse() SetCaptureStateResponse
	NewUpdateFlowsResponse() UpdateFlowsResponse
	NewSetRouteStateResponse() SetRouteStateResponse
	NewSendPingResponse() SendPingResponse
	NewSetProtocolStateResponse() SetProtocolStateResponse
	NewGetMetricsResponse() GetMetricsResponse
	NewGetStateMetricsResponse() GetStateMetricsResponse
	NewGetCaptureResponse() GetCaptureResponse
	SetConfig(config Config) (ResponseWarning, error)
	GetConfig() (Config, error)
	SetTransmitState(transmitState TransmitState) (ResponseWarning, error)
	SetLinkState(linkState LinkState) (ResponseWarning, error)
	SetCaptureState(captureState CaptureState) (ResponseWarning, error)
	UpdateFlows(flowsUpdate FlowsUpdate) (Config, error)
	SetRouteState(routeState RouteState) (ResponseWarning, error)
	SendPing(pingRequest PingRequest) (PingResponse, error)
	SetProtocolState(protocolState ProtocolState) (ResponseWarning, error)
	GetMetrics(metricsRequest MetricsRequest) (MetricsResponse, error)
	GetStateMetrics() (StateMetrics, error)
	GetCapture(captureRequest CaptureRequest) ([]byte, error)
}

func NewApi 

func NewApi() GosnappiApi

NewApi returns a new instance of the top level interface hierarchy

type GrpcTransport 

type GrpcTransport interface {
	SetLocation(value string) GrpcTransport
	Location() string
	SetRequestTimeout(value int) GrpcTransport
	RequestTimeout() int
}

type HttpServer 

type HttpServer struct {
	Api    GosnappiApi
	Config Config
	// contains filtered or unexported fields
}

type HttpTransport 

type HttpTransport interface {
	SetLocation(value string) HttpTransport
	Location() string
	SetVerify(value bool) HttpTransport
	Verify() bool
}

type IsisAdvanced added in v0.6.1 

type IsisAdvanced interface {
	Msg() *snappipb.IsisAdvanced
	SetMsg(*snappipb.IsisAdvanced) IsisAdvanced
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	EnableHelloPadding() bool
	SetEnableHelloPadding(value bool) IsisAdvanced
	HasEnableHelloPadding() bool
	MaxAreaAddresses() int32
	SetMaxAreaAddresses(value int32) IsisAdvanced
	HasMaxAreaAddresses() bool
	AreaAddresses() []string
	SetAreaAddresses(value []string) IsisAdvanced
	LspRefreshRate() int32
	SetLspRefreshRate(value int32) IsisAdvanced
	HasLspRefreshRate() bool
	LspLifetime() int32
	SetLspLifetime(value int32) IsisAdvanced
	HasLspLifetime() bool
	PsnpInterval() int32
	SetPsnpInterval(value int32) IsisAdvanced
	HasPsnpInterval() bool
	CsnpInterval() int32
	SetCsnpInterval(value int32) IsisAdvanced
	HasCsnpInterval() bool
	MaxLspSize() int32
	SetMaxLspSize(value int32) IsisAdvanced
	HasMaxLspSize() bool
	LspMgroupMinTransInterval() int32
	SetLspMgroupMinTransInterval(value int32) IsisAdvanced
	HasLspMgroupMinTransInterval() bool
	// contains filtered or unexported methods
}

func NewIsisAdvanced added in v0.6.5 

func NewIsisAdvanced() IsisAdvanced

type IsisAuthentication added in v0.6.1 

type IsisAuthentication interface {
	Msg() *snappipb.IsisAuthentication
	SetMsg(*snappipb.IsisAuthentication) IsisAuthentication
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	IgnoreReceiveMd5() bool
	SetIgnoreReceiveMd5(value bool) IsisAuthentication
	HasIgnoreReceiveMd5() bool
	AreaAuthType() IsisAuthenticationBase
	SetAreaAuthType(value IsisAuthenticationBase) IsisAuthentication
	HasAreaAuthType() bool
	DomainAuthType() IsisAuthenticationBase
	SetDomainAuthType(value IsisAuthenticationBase) IsisAuthentication
	HasDomainAuthType() bool
	// contains filtered or unexported methods
}

func NewIsisAuthentication added in v0.6.5 

func NewIsisAuthentication() IsisAuthentication

type IsisAuthenticationBase added in v0.6.1 

type IsisAuthenticationBase interface {
	Msg() *snappipb.IsisAuthenticationBase
	SetMsg(*snappipb.IsisAuthenticationBase) IsisAuthenticationBase
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() IsisAuthenticationBaseChoiceEnum
	SetChoice(value IsisAuthenticationBaseChoiceEnum) IsisAuthenticationBase
	Md5() string
	SetMd5(value string) IsisAuthenticationBase
	HasMd5() bool
	Password() string
	SetPassword(value string) IsisAuthenticationBase
	HasPassword() bool
	// contains filtered or unexported methods
}

func NewIsisAuthenticationBase added in v0.6.5 

func NewIsisAuthenticationBase() IsisAuthenticationBase

type IsisAuthenticationBaseChoiceEnum added in v0.6.1 

type IsisAuthenticationBaseChoiceEnum string

type IsisBasic added in v0.6.1 

type IsisBasic interface {
	Msg() *snappipb.IsisBasic
	SetMsg(*snappipb.IsisBasic) IsisBasic
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ipv4TeRouterId() string
	SetIpv4TeRouterId(value string) IsisBasic
	HasIpv4TeRouterId() bool
	Hostname() string
	SetHostname(value string) IsisBasic
	HasHostname() bool
	// contains filtered or unexported methods
}

func NewIsisBasic added in v0.6.5 

func NewIsisBasic() IsisBasic

type IsisInterface added in v0.6.1 

type IsisInterface interface {
	Msg() *snappipb.IsisInterface
	SetMsg(*snappipb.IsisInterface) IsisInterface
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	EthName() string
	SetEthName(value string) IsisInterface
	Metric() int32
	SetMetric(value int32) IsisInterface
	HasMetric() bool
	NetworkType() IsisInterfaceNetworkTypeEnum
	SetNetworkType(value IsisInterfaceNetworkTypeEnum) IsisInterface
	HasNetworkType() bool
	LevelType() IsisInterfaceLevelTypeEnum
	SetLevelType(value IsisInterfaceLevelTypeEnum) IsisInterface
	HasLevelType() bool
	L1Settings() IsisInterfaceLevel
	SetL1Settings(value IsisInterfaceLevel) IsisInterface
	HasL1Settings() bool
	L2Settings() IsisInterfaceLevel
	SetL2Settings(value IsisInterfaceLevel) IsisInterface
	HasL2Settings() bool
	MultiTopologyIds() IsisInterfaceIsisMTIter
	TrafficEngineering() IsisInterfaceLinkStateTEIter
	Authentication() IsisInterfaceAuthentication
	SetAuthentication(value IsisInterfaceAuthentication) IsisInterface
	HasAuthentication() bool
	Advanced() IsisInterfaceAdvanced
	SetAdvanced(value IsisInterfaceAdvanced) IsisInterface
	HasAdvanced() bool
	LinkProtection() IsisInterfaceLinkProtection
	SetLinkProtection(value IsisInterfaceLinkProtection) IsisInterface
	HasLinkProtection() bool
	SrlgValues() []int32
	SetSrlgValues(value []int32) IsisInterface
	// contains filtered or unexported methods
}

func NewIsisInterface added in v0.6.5 

func NewIsisInterface() IsisInterface

type IsisInterfaceAdvanced added in v0.6.1 

type IsisInterfaceAdvanced interface {
	Msg() *snappipb.IsisInterfaceAdvanced
	SetMsg(*snappipb.IsisInterfaceAdvanced) IsisInterfaceAdvanced
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	AutoAdjustMtu() bool
	SetAutoAdjustMtu(value bool) IsisInterfaceAdvanced
	HasAutoAdjustMtu() bool
	AutoAdjustArea() bool
	SetAutoAdjustArea(value bool) IsisInterfaceAdvanced
	HasAutoAdjustArea() bool
	AutoAdjustSupportedProtocols() bool
	SetAutoAdjustSupportedProtocols(value bool) IsisInterfaceAdvanced
	HasAutoAdjustSupportedProtocols() bool
	// contains filtered or unexported methods
}

func NewIsisInterfaceAdvanced added in v0.6.5 

func NewIsisInterfaceAdvanced() IsisInterfaceAdvanced

type IsisInterfaceAuthentication added in v0.6.1 

type IsisInterfaceAuthentication interface {
	Msg() *snappipb.IsisInterfaceAuthentication
	SetMsg(*snappipb.IsisInterfaceAuthentication) IsisInterfaceAuthentication
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() IsisInterfaceAuthenticationChoiceEnum
	SetChoice(value IsisInterfaceAuthenticationChoiceEnum) IsisInterfaceAuthentication
	HasChoice() bool
	Md5() string
	SetMd5(value string) IsisInterfaceAuthentication
	HasMd5() bool
	Password() string
	SetPassword(value string) IsisInterfaceAuthentication
	HasPassword() bool
	// contains filtered or unexported methods
}

func NewIsisInterfaceAuthentication added in v0.6.5 

func NewIsisInterfaceAuthentication() IsisInterfaceAuthentication

type IsisInterfaceAuthenticationChoiceEnum added in v0.6.1 

type IsisInterfaceAuthenticationChoiceEnum string

type IsisInterfaceIsisMTIter added in v0.6.1 

type IsisInterfaceIsisMTIter interface {
	Add() IsisMT
	Items() []IsisMT
}

type IsisInterfaceLevel added in v0.6.1 

type IsisInterfaceLevel interface {
	Msg() *snappipb.IsisInterfaceLevel
	SetMsg(*snappipb.IsisInterfaceLevel) IsisInterfaceLevel
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Priority() int32
	SetPriority(value int32) IsisInterfaceLevel
	HasPriority() bool
	HelloInterval() int32
	SetHelloInterval(value int32) IsisInterfaceLevel
	HasHelloInterval() bool
	DeadInterval() int32
	SetDeadInterval(value int32) IsisInterfaceLevel
	HasDeadInterval() bool
	// contains filtered or unexported methods
}

func NewIsisInterfaceLevel added in v0.6.5 

func NewIsisInterfaceLevel() IsisInterfaceLevel

type IsisInterfaceLevelTypeEnum added in v0.6.1 

type IsisInterfaceLevelTypeEnum string

type IsisInterfaceLinkProtection added in v0.6.1 

type IsisInterfaceLinkProtection interface {
	Msg() *snappipb.IsisInterfaceLinkProtection
	SetMsg(*snappipb.IsisInterfaceLinkProtection) IsisInterfaceLinkProtection
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	ExtraTraffic() bool
	SetExtraTraffic(value bool) IsisInterfaceLinkProtection
	HasExtraTraffic() bool
	Unprotected() bool
	SetUnprotected(value bool) IsisInterfaceLinkProtection
	HasUnprotected() bool
	Shared() bool
	SetShared(value bool) IsisInterfaceLinkProtection
	HasShared() bool
	Dedicated1To1() bool
	SetDedicated1To1(value bool) IsisInterfaceLinkProtection
	HasDedicated1To1() bool
	Dedicated1Plus1() bool
	SetDedicated1Plus1(value bool) IsisInterfaceLinkProtection
	HasDedicated1Plus1() bool
	Enhanced() bool
	SetEnhanced(value bool) IsisInterfaceLinkProtection
	HasEnhanced() bool
	Reserved40() bool
	SetReserved40(value bool) IsisInterfaceLinkProtection
	HasReserved40() bool
	Reserved80() bool
	SetReserved80(value bool) IsisInterfaceLinkProtection
	HasReserved80() bool
	// contains filtered or unexported methods
}

func NewIsisInterfaceLinkProtection added in v0.6.5 

func NewIsisInterfaceLinkProtection() IsisInterfaceLinkProtection

type IsisInterfaceLinkStateTEIter added in v0.6.1 

type IsisInterfaceLinkStateTEIter interface {
	Add() LinkStateTE
	Items() []LinkStateTE
}

type IsisInterfaceNetworkTypeEnum added in v0.6.1 

type IsisInterfaceNetworkTypeEnum string

type IsisMT added in v0.6.1 

type IsisMT interface {
	Msg() *snappipb.IsisMT
	SetMsg(*snappipb.IsisMT) IsisMT
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	MtId() int32
	SetMtId(value int32) IsisMT
	HasMtId() bool
	LinkMetric() int32
	SetLinkMetric(value int32) IsisMT
	HasLinkMetric() bool
	// contains filtered or unexported methods
}

func NewIsisMT added in v0.6.5 

func NewIsisMT() IsisMT

type IsisV4RouteRange added in v0.6.1 

type IsisV4RouteRange interface {
	Msg() *snappipb.IsisV4RouteRange
	SetMsg(*snappipb.IsisV4RouteRange) IsisV4RouteRange
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Addresses() IsisV4RouteRangeV4RouteAddressIter
	LinkMetric() int32
	SetLinkMetric(value int32) IsisV4RouteRange
	HasLinkMetric() bool
	RouteOrigin() IsisV4RouteRangeRouteOriginEnum
	SetRouteOrigin(value IsisV4RouteRangeRouteOriginEnum) IsisV4RouteRange
	HasRouteOrigin() bool
	Redistribution() IsisV4RouteRangeRedistributionEnum
	SetRedistribution(value IsisV4RouteRangeRedistributionEnum) IsisV4RouteRange
	HasRedistribution() bool
	Name() string
	SetName(value string) IsisV4RouteRange
	XFlag() bool
	SetXFlag(value bool) IsisV4RouteRange
	HasXFlag() bool
	RFlag() bool
	SetRFlag(value bool) IsisV4RouteRange
	HasRFlag() bool
	NFlag() bool
	SetNFlag(value bool) IsisV4RouteRange
	HasNFlag() bool
	// contains filtered or unexported methods
}

func NewIsisV4RouteRange added in v0.6.5 

func NewIsisV4RouteRange() IsisV4RouteRange

type IsisV4RouteRangeRedistributionEnum added in v0.6.1 

type IsisV4RouteRangeRedistributionEnum string

type IsisV4RouteRangeRouteOriginEnum added in v0.6.1 

type IsisV4RouteRangeRouteOriginEnum string

type IsisV4RouteRangeV4RouteAddressIter added in v0.6.1 

type IsisV4RouteRangeV4RouteAddressIter interface {
	Add() V4RouteAddress
	Items() []V4RouteAddress
}

type IsisV6RouteRange added in v0.6.1 

type IsisV6RouteRange interface {
	Msg() *snappipb.IsisV6RouteRange
	SetMsg(*snappipb.IsisV6RouteRange) IsisV6RouteRange
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Addresses() IsisV6RouteRangeV6RouteAddressIter
	LinkMetric() int32
	SetLinkMetric(value int32) IsisV6RouteRange
	HasLinkMetric() bool
	RouteOrigin() IsisV6RouteRangeRouteOriginEnum
	SetRouteOrigin(value IsisV6RouteRangeRouteOriginEnum) IsisV6RouteRange
	HasRouteOrigin() bool
	Redistribution() IsisV6RouteRangeRedistributionEnum
	SetRedistribution(value IsisV6RouteRangeRedistributionEnum) IsisV6RouteRange
	HasRedistribution() bool
	Name() string
	SetName(value string) IsisV6RouteRange
	XFlag() bool
	SetXFlag(value bool) IsisV6RouteRange
	HasXFlag() bool
	RFlag() bool
	SetRFlag(value bool) IsisV6RouteRange
	HasRFlag() bool
	NFlag() bool
	SetNFlag(value bool) IsisV6RouteRange
	HasNFlag() bool
	// contains filtered or unexported methods
}

func NewIsisV6RouteRange added in v0.6.5 

func NewIsisV6RouteRange() IsisV6RouteRange

type IsisV6RouteRangeRedistributionEnum added in v0.6.1 

type IsisV6RouteRangeRedistributionEnum string

type IsisV6RouteRangeRouteOriginEnum added in v0.6.1 

type IsisV6RouteRangeRouteOriginEnum string

type IsisV6RouteRangeV6RouteAddressIter added in v0.6.1 

type IsisV6RouteRangeV6RouteAddressIter interface {
	Add() V6RouteAddress
	Items() []V6RouteAddress
}

type Lag 

type Lag interface {
	Msg() *snappipb.Lag
	SetMsg(*snappipb.Lag) Lag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Ports() LagLagPortIter
	Name() string
	SetName(value string) Lag
	// contains filtered or unexported methods
}

func NewLag added in v0.6.5 

func NewLag() Lag

type LagLacp 

type LagLacp interface {
	Msg() *snappipb.LagLacp
	SetMsg(*snappipb.LagLacp) LagLacp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	ActorKey() int32
	SetActorKey(value int32) LagLacp
	HasActorKey() bool
	ActorPortNumber() int32
	SetActorPortNumber(value int32) LagLacp
	HasActorPortNumber() bool
	ActorPortPriority() int32
	SetActorPortPriority(value int32) LagLacp
	HasActorPortPriority() bool
	ActorSystemId() string
	SetActorSystemId(value string) LagLacp
	HasActorSystemId() bool
	ActorSystemPriority() int32
	SetActorSystemPriority(value int32) LagLacp
	HasActorSystemPriority() bool
	LacpduPeriodicTimeInterval() int32
	SetLacpduPeriodicTimeInterval(value int32) LagLacp
	HasLacpduPeriodicTimeInterval() bool
	LacpduTimeout() int32
	SetLacpduTimeout(value int32) LagLacp
	HasLacpduTimeout() bool
	ActorActivity() LagLacpActorActivityEnum
	SetActorActivity(value LagLacpActorActivityEnum) LagLacp
	HasActorActivity() bool
	// contains filtered or unexported methods
}

func NewLagLacp added in v0.6.5 

func NewLagLacp() LagLacp

type LagLacpActorActivityEnum 

type LagLacpActorActivityEnum string

type LagLagPortIter 

type LagLagPortIter interface {
	Add() LagPort
	Items() []LagPort
}

type LagPort 

type LagPort interface {
	Msg() *snappipb.LagPort
	SetMsg(*snappipb.LagPort) LagPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortName() string
	SetPortName(value string) LagPort
	Protocol() LagProtocol
	SetProtocol(value LagProtocol) LagPort
	Ethernet() DeviceEthernetBase
	SetEthernet(value DeviceEthernetBase) LagPort
	// contains filtered or unexported methods
}

func NewLagPort added in v0.6.5 

func NewLagPort() LagPort

type LagProtocol 

type LagProtocol interface {
	Msg() *snappipb.LagProtocol
	SetMsg(*snappipb.LagProtocol) LagProtocol
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() LagProtocolChoiceEnum
	SetChoice(value LagProtocolChoiceEnum) LagProtocol
	HasChoice() bool
	Lacp() LagLacp
	SetLacp(value LagLacp) LagProtocol
	HasLacp() bool
	Static() LagStatic
	SetStatic(value LagStatic) LagProtocol
	HasStatic() bool
	// contains filtered or unexported methods
}

func NewLagProtocol added in v0.6.5 

func NewLagProtocol() LagProtocol

type LagProtocolChoiceEnum 

type LagProtocolChoiceEnum string

type LagStatic 

type LagStatic interface {
	Msg() *snappipb.LagStatic
	SetMsg(*snappipb.LagStatic) LagStatic
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	LagId() int32
	SetLagId(value int32) LagStatic
	HasLagId() bool
	// contains filtered or unexported methods
}

func NewLagStatic added in v0.6.5 

func NewLagStatic() LagStatic

type Layer1 

type Layer1 interface {
	Msg() *snappipb.Layer1
	SetMsg(*snappipb.Layer1) Layer1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortNames() []string
	SetPortNames(value []string) Layer1
	Speed() Layer1SpeedEnum
	SetSpeed(value Layer1SpeedEnum) Layer1
	HasSpeed() bool
	Media() Layer1MediaEnum
	SetMedia(value Layer1MediaEnum) Layer1
	HasMedia() bool
	Promiscuous() bool
	SetPromiscuous(value bool) Layer1
	HasPromiscuous() bool
	Mtu() int32
	SetMtu(value int32) Layer1
	HasMtu() bool
	IeeeMediaDefaults() bool
	SetIeeeMediaDefaults(value bool) Layer1
	HasIeeeMediaDefaults() bool
	AutoNegotiate() bool
	SetAutoNegotiate(value bool) Layer1
	HasAutoNegotiate() bool
	AutoNegotiation() Layer1AutoNegotiation
	SetAutoNegotiation(value Layer1AutoNegotiation) Layer1
	HasAutoNegotiation() bool
	FlowControl() Layer1FlowControl
	SetFlowControl(value Layer1FlowControl) Layer1
	HasFlowControl() bool
	Name() string
	SetName(value string) Layer1
	// contains filtered or unexported methods
}

func NewLayer1 added in v0.6.5 

func NewLayer1() Layer1

type Layer1AutoNegotiation 

type Layer1AutoNegotiation interface {
	Msg() *snappipb.Layer1AutoNegotiation
	SetMsg(*snappipb.Layer1AutoNegotiation) Layer1AutoNegotiation
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Advertise1000Mbps() bool
	SetAdvertise1000Mbps(value bool) Layer1AutoNegotiation
	HasAdvertise1000Mbps() bool
	Advertise100FdMbps() bool
	SetAdvertise100FdMbps(value bool) Layer1AutoNegotiation
	HasAdvertise100FdMbps() bool
	Advertise100HdMbps() bool
	SetAdvertise100HdMbps(value bool) Layer1AutoNegotiation
	HasAdvertise100HdMbps() bool
	Advertise10FdMbps() bool
	SetAdvertise10FdMbps(value bool) Layer1AutoNegotiation
	HasAdvertise10FdMbps() bool
	Advertise10HdMbps() bool
	SetAdvertise10HdMbps(value bool) Layer1AutoNegotiation
	HasAdvertise10HdMbps() bool
	LinkTraining() bool
	SetLinkTraining(value bool) Layer1AutoNegotiation
	HasLinkTraining() bool
	RsFec() bool
	SetRsFec(value bool) Layer1AutoNegotiation
	HasRsFec() bool
	// contains filtered or unexported methods
}

func NewLayer1AutoNegotiation added in v0.6.5 

func NewLayer1AutoNegotiation() Layer1AutoNegotiation

type Layer1FlowControl 

type Layer1FlowControl interface {
	Msg() *snappipb.Layer1FlowControl
	SetMsg(*snappipb.Layer1FlowControl) Layer1FlowControl
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	DirectedAddress() string
	SetDirectedAddress(value string) Layer1FlowControl
	HasDirectedAddress() bool
	Choice() Layer1FlowControlChoiceEnum
	SetChoice(value Layer1FlowControlChoiceEnum) Layer1FlowControl
	HasChoice() bool
	Ieee8021Qbb() Layer1Ieee8021Qbb
	SetIeee8021Qbb(value Layer1Ieee8021Qbb) Layer1FlowControl
	HasIeee8021Qbb() bool
	Ieee8023X() Layer1Ieee8023X
	SetIeee8023X(value Layer1Ieee8023X) Layer1FlowControl
	HasIeee8023X() bool
	// contains filtered or unexported methods
}

func NewLayer1FlowControl added in v0.6.5 

func NewLayer1FlowControl() Layer1FlowControl

type Layer1FlowControlChoiceEnum 

type Layer1FlowControlChoiceEnum string

type Layer1Ieee8021Qbb 

type Layer1Ieee8021Qbb interface {
	Msg() *snappipb.Layer1Ieee8021Qbb
	SetMsg(*snappipb.Layer1Ieee8021Qbb) Layer1Ieee8021Qbb
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PfcDelay() int32
	SetPfcDelay(value int32) Layer1Ieee8021Qbb
	HasPfcDelay() bool
	PfcClass0() int32
	SetPfcClass0(value int32) Layer1Ieee8021Qbb
	HasPfcClass0() bool
	PfcClass1() int32
	SetPfcClass1(value int32) Layer1Ieee8021Qbb
	HasPfcClass1() bool
	PfcClass2() int32
	SetPfcClass2(value int32) Layer1Ieee8021Qbb
	HasPfcClass2() bool
	PfcClass3() int32
	SetPfcClass3(value int32) Layer1Ieee8021Qbb
	HasPfcClass3() bool
	PfcClass4() int32
	SetPfcClass4(value int32) Layer1Ieee8021Qbb
	HasPfcClass4() bool
	PfcClass5() int32
	SetPfcClass5(value int32) Layer1Ieee8021Qbb
	HasPfcClass5() bool
	PfcClass6() int32
	SetPfcClass6(value int32) Layer1Ieee8021Qbb
	HasPfcClass6() bool
	PfcClass7() int32
	SetPfcClass7(value int32) Layer1Ieee8021Qbb
	HasPfcClass7() bool
	// contains filtered or unexported methods
}

func NewLayer1Ieee8021Qbb added in v0.6.5 

func NewLayer1Ieee8021Qbb() Layer1Ieee8021Qbb

type Layer1Ieee8023X 

type Layer1Ieee8023X interface {
	Msg() *snappipb.Layer1Ieee8023X
	SetMsg(*snappipb.Layer1Ieee8023X) Layer1Ieee8023X
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error
	// contains filtered or unexported methods
}

func NewLayer1Ieee8023X added in v0.6.5 

func NewLayer1Ieee8023X() Layer1Ieee8023X

type Layer1MediaEnum 

type Layer1MediaEnum string

type Layer1SpeedEnum 

type Layer1SpeedEnum string

type LinkState 

type LinkState interface {
	Msg() *snappipb.LinkState
	SetMsg(*snappipb.LinkState) LinkState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortNames() []string
	SetPortNames(value []string) LinkState
	State() LinkStateStateEnum
	SetState(value LinkStateStateEnum) LinkState
	// contains filtered or unexported methods
}

func NewLinkState added in v0.6.5 

func NewLinkState() LinkState

type LinkStateStateEnum 

type LinkStateStateEnum string

type LinkStateTE added in v0.6.1 

type LinkStateTE interface {
	Msg() *snappipb.LinkStateTE
	SetMsg(*snappipb.LinkStateTE) LinkStateTE
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	AdministrativeGroup() string
	SetAdministrativeGroup(value string) LinkStateTE
	HasAdministrativeGroup() bool
	MetricLevel() int64
	SetMetricLevel(value int64) LinkStateTE
	HasMetricLevel() bool
	MaxBandwith() int64
	SetMaxBandwith(value int64) LinkStateTE
	HasMaxBandwith() bool
	MaxReservableBandwidth() int64
	SetMaxReservableBandwidth(value int64) LinkStateTE
	HasMaxReservableBandwidth() bool
	PriorityBandwidths07() LinkStatepriorityBandwidths
	SetPriorityBandwidths07(value LinkStatepriorityBandwidths) LinkStateTE
	HasPriorityBandwidths07() bool
	// contains filtered or unexported methods
}

func NewLinkStateTE added in v0.6.5 

func NewLinkStateTE() LinkStateTE

type LinkStatepriorityBandwidths added in v0.6.1 

type LinkStatepriorityBandwidths interface {
	Msg() *snappipb.LinkStatepriorityBandwidths
	SetMsg(*snappipb.LinkStatepriorityBandwidths) LinkStatepriorityBandwidths
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Pb0() int64
	SetPb0(value int64) LinkStatepriorityBandwidths
	HasPb0() bool
	Pb1() int64
	SetPb1(value int64) LinkStatepriorityBandwidths
	HasPb1() bool
	Pb2() int64
	SetPb2(value int64) LinkStatepriorityBandwidths
	HasPb2() bool
	Pb3() int64
	SetPb3(value int64) LinkStatepriorityBandwidths
	HasPb3() bool
	Pb4() int64
	SetPb4(value int64) LinkStatepriorityBandwidths
	HasPb4() bool
	Pb5() int64
	SetPb5(value int64) LinkStatepriorityBandwidths
	HasPb5() bool
	Pb6() int64
	SetPb6(value int64) LinkStatepriorityBandwidths
	HasPb6() bool
	Pb7() int64
	SetPb7(value int64) LinkStatepriorityBandwidths
	HasPb7() bool
	// contains filtered or unexported methods
}

func NewLinkStatepriorityBandwidths added in v0.6.5 

func NewLinkStatepriorityBandwidths() LinkStatepriorityBandwidths

type MetricLatency 

type MetricLatency interface {
	Msg() *snappipb.MetricLatency
	SetMsg(*snappipb.MetricLatency) MetricLatency
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	MinimumNs() float64
	SetMinimumNs(value float64) MetricLatency
	HasMinimumNs() bool
	MaximumNs() float64
	SetMaximumNs(value float64) MetricLatency
	HasMaximumNs() bool
	AverageNs() float64
	SetAverageNs(value float64) MetricLatency
	HasAverageNs() bool
	// contains filtered or unexported methods
}

func NewMetricLatency added in v0.6.5 

func NewMetricLatency() MetricLatency

type MetricTimestamp 

type MetricTimestamp interface {
	Msg() *snappipb.MetricTimestamp
	SetMsg(*snappipb.MetricTimestamp) MetricTimestamp
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	FirstTimestampNs() float64
	SetFirstTimestampNs(value float64) MetricTimestamp
	HasFirstTimestampNs() bool
	LastTimestampNs() float64
	SetLastTimestampNs(value float64) MetricTimestamp
	HasLastTimestampNs() bool
	// contains filtered or unexported methods
}

func NewMetricTimestamp added in v0.6.5 

func NewMetricTimestamp() MetricTimestamp

type MetricsRequest 

type MetricsRequest interface {
	Msg() *snappipb.MetricsRequest
	SetMsg(*snappipb.MetricsRequest) MetricsRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() MetricsRequestChoiceEnum
	SetChoice(value MetricsRequestChoiceEnum) MetricsRequest
	HasChoice() bool
	Port() PortMetricsRequest
	SetPort(value PortMetricsRequest) MetricsRequest
	HasPort() bool
	Flow() FlowMetricsRequest
	SetFlow(value FlowMetricsRequest) MetricsRequest
	HasFlow() bool
	Bgpv4() Bgpv4MetricsRequest
	SetBgpv4(value Bgpv4MetricsRequest) MetricsRequest
	HasBgpv4() bool
	Bgpv6() Bgpv6MetricsRequest
	SetBgpv6(value Bgpv6MetricsRequest) MetricsRequest
	HasBgpv6() bool
	// contains filtered or unexported methods
}

func NewMetricsRequest added in v0.6.5 

func NewMetricsRequest() MetricsRequest

type MetricsRequestChoiceEnum 

type MetricsRequestChoiceEnum string

type MetricsResponse 

type MetricsResponse interface {
	Msg() *snappipb.MetricsResponse
	SetMsg(*snappipb.MetricsResponse) MetricsResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() MetricsResponseChoiceEnum
	SetChoice(value MetricsResponseChoiceEnum) MetricsResponse
	HasChoice() bool
	PortMetrics() MetricsResponsePortMetricIter
	FlowMetrics() MetricsResponseFlowMetricIter
	Bgpv4Metrics() MetricsResponseBgpv4MetricIter
	Bgpv6Metrics() MetricsResponseBgpv6MetricIter
	// contains filtered or unexported methods
}

func NewMetricsResponse added in v0.6.5 

func NewMetricsResponse() MetricsResponse

type MetricsResponseBgpv4MetricIter 

type MetricsResponseBgpv4MetricIter interface {
	Add() Bgpv4Metric
	Items() []Bgpv4Metric
}

type MetricsResponseBgpv6MetricIter 

type MetricsResponseBgpv6MetricIter interface {
	Add() Bgpv6Metric
	Items() []Bgpv6Metric
}

type MetricsResponseChoiceEnum 

type MetricsResponseChoiceEnum string

type MetricsResponseFlowMetricIter 

type MetricsResponseFlowMetricIter interface {
	Add() FlowMetric
	Items() []FlowMetric
}

type MetricsResponsePortMetricIter 

type MetricsResponsePortMetricIter interface {
	Add() PortMetric
	Items() []PortMetric
}

type PatternFlowArpHardwareLength 

type PatternFlowArpHardwareLength interface {
	Msg() *snappipb.PatternFlowArpHardwareLength
	SetMsg(*snappipb.PatternFlowArpHardwareLength) PatternFlowArpHardwareLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpHardwareLengthChoiceEnum
	SetChoice(value PatternFlowArpHardwareLengthChoiceEnum) PatternFlowArpHardwareLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowArpHardwareLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowArpHardwareLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpHardwareLength
	HasMetricGroup() bool
	Increment() PatternFlowArpHardwareLengthCounter
	SetIncrement(value PatternFlowArpHardwareLengthCounter) PatternFlowArpHardwareLength
	HasIncrement() bool
	Decrement() PatternFlowArpHardwareLengthCounter
	SetDecrement(value PatternFlowArpHardwareLengthCounter) PatternFlowArpHardwareLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpHardwareLength added in v0.6.5 

func NewPatternFlowArpHardwareLength() PatternFlowArpHardwareLength

type PatternFlowArpHardwareLengthChoiceEnum 

type PatternFlowArpHardwareLengthChoiceEnum string

type PatternFlowArpHardwareLengthCounter 

type PatternFlowArpHardwareLengthCounter interface {
	Msg() *snappipb.PatternFlowArpHardwareLengthCounter
	SetMsg(*snappipb.PatternFlowArpHardwareLengthCounter) PatternFlowArpHardwareLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowArpHardwareLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowArpHardwareLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpHardwareLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpHardwareLengthCounter added in v0.6.5 

func NewPatternFlowArpHardwareLengthCounter() PatternFlowArpHardwareLengthCounter

type PatternFlowArpHardwareType 

type PatternFlowArpHardwareType interface {
	Msg() *snappipb.PatternFlowArpHardwareType
	SetMsg(*snappipb.PatternFlowArpHardwareType) PatternFlowArpHardwareType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpHardwareTypeChoiceEnum
	SetChoice(value PatternFlowArpHardwareTypeChoiceEnum) PatternFlowArpHardwareType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowArpHardwareType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowArpHardwareType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpHardwareType
	HasMetricGroup() bool
	Increment() PatternFlowArpHardwareTypeCounter
	SetIncrement(value PatternFlowArpHardwareTypeCounter) PatternFlowArpHardwareType
	HasIncrement() bool
	Decrement() PatternFlowArpHardwareTypeCounter
	SetDecrement(value PatternFlowArpHardwareTypeCounter) PatternFlowArpHardwareType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpHardwareType added in v0.6.5 

func NewPatternFlowArpHardwareType() PatternFlowArpHardwareType

type PatternFlowArpHardwareTypeChoiceEnum 

type PatternFlowArpHardwareTypeChoiceEnum string

type PatternFlowArpHardwareTypeCounter 

type PatternFlowArpHardwareTypeCounter interface {
	Msg() *snappipb.PatternFlowArpHardwareTypeCounter
	SetMsg(*snappipb.PatternFlowArpHardwareTypeCounter) PatternFlowArpHardwareTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowArpHardwareTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowArpHardwareTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpHardwareTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpHardwareTypeCounter added in v0.6.5 

func NewPatternFlowArpHardwareTypeCounter() PatternFlowArpHardwareTypeCounter

type PatternFlowArpOperation 

type PatternFlowArpOperation interface {
	Msg() *snappipb.PatternFlowArpOperation
	SetMsg(*snappipb.PatternFlowArpOperation) PatternFlowArpOperation
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpOperationChoiceEnum
	SetChoice(value PatternFlowArpOperationChoiceEnum) PatternFlowArpOperation
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowArpOperation
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowArpOperation
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpOperation
	HasMetricGroup() bool
	Increment() PatternFlowArpOperationCounter
	SetIncrement(value PatternFlowArpOperationCounter) PatternFlowArpOperation
	HasIncrement() bool
	Decrement() PatternFlowArpOperationCounter
	SetDecrement(value PatternFlowArpOperationCounter) PatternFlowArpOperation
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpOperation added in v0.6.5 

func NewPatternFlowArpOperation() PatternFlowArpOperation

type PatternFlowArpOperationChoiceEnum 

type PatternFlowArpOperationChoiceEnum string

type PatternFlowArpOperationCounter 

type PatternFlowArpOperationCounter interface {
	Msg() *snappipb.PatternFlowArpOperationCounter
	SetMsg(*snappipb.PatternFlowArpOperationCounter) PatternFlowArpOperationCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowArpOperationCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowArpOperationCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpOperationCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpOperationCounter added in v0.6.5 

func NewPatternFlowArpOperationCounter() PatternFlowArpOperationCounter

type PatternFlowArpProtocolLength 

type PatternFlowArpProtocolLength interface {
	Msg() *snappipb.PatternFlowArpProtocolLength
	SetMsg(*snappipb.PatternFlowArpProtocolLength) PatternFlowArpProtocolLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpProtocolLengthChoiceEnum
	SetChoice(value PatternFlowArpProtocolLengthChoiceEnum) PatternFlowArpProtocolLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowArpProtocolLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowArpProtocolLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpProtocolLength
	HasMetricGroup() bool
	Increment() PatternFlowArpProtocolLengthCounter
	SetIncrement(value PatternFlowArpProtocolLengthCounter) PatternFlowArpProtocolLength
	HasIncrement() bool
	Decrement() PatternFlowArpProtocolLengthCounter
	SetDecrement(value PatternFlowArpProtocolLengthCounter) PatternFlowArpProtocolLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpProtocolLength added in v0.6.5 

func NewPatternFlowArpProtocolLength() PatternFlowArpProtocolLength

type PatternFlowArpProtocolLengthChoiceEnum 

type PatternFlowArpProtocolLengthChoiceEnum string

type PatternFlowArpProtocolLengthCounter 

type PatternFlowArpProtocolLengthCounter interface {
	Msg() *snappipb.PatternFlowArpProtocolLengthCounter
	SetMsg(*snappipb.PatternFlowArpProtocolLengthCounter) PatternFlowArpProtocolLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowArpProtocolLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowArpProtocolLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpProtocolLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpProtocolLengthCounter added in v0.6.5 

func NewPatternFlowArpProtocolLengthCounter() PatternFlowArpProtocolLengthCounter

type PatternFlowArpProtocolType 

type PatternFlowArpProtocolType interface {
	Msg() *snappipb.PatternFlowArpProtocolType
	SetMsg(*snappipb.PatternFlowArpProtocolType) PatternFlowArpProtocolType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpProtocolTypeChoiceEnum
	SetChoice(value PatternFlowArpProtocolTypeChoiceEnum) PatternFlowArpProtocolType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowArpProtocolType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowArpProtocolType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpProtocolType
	HasMetricGroup() bool
	Increment() PatternFlowArpProtocolTypeCounter
	SetIncrement(value PatternFlowArpProtocolTypeCounter) PatternFlowArpProtocolType
	HasIncrement() bool
	Decrement() PatternFlowArpProtocolTypeCounter
	SetDecrement(value PatternFlowArpProtocolTypeCounter) PatternFlowArpProtocolType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpProtocolType added in v0.6.5 

func NewPatternFlowArpProtocolType() PatternFlowArpProtocolType

type PatternFlowArpProtocolTypeChoiceEnum 

type PatternFlowArpProtocolTypeChoiceEnum string

type PatternFlowArpProtocolTypeCounter 

type PatternFlowArpProtocolTypeCounter interface {
	Msg() *snappipb.PatternFlowArpProtocolTypeCounter
	SetMsg(*snappipb.PatternFlowArpProtocolTypeCounter) PatternFlowArpProtocolTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowArpProtocolTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowArpProtocolTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpProtocolTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpProtocolTypeCounter added in v0.6.5 

func NewPatternFlowArpProtocolTypeCounter() PatternFlowArpProtocolTypeCounter

type PatternFlowArpSenderHardwareAddr 

type PatternFlowArpSenderHardwareAddr interface {
	Msg() *snappipb.PatternFlowArpSenderHardwareAddr
	SetMsg(*snappipb.PatternFlowArpSenderHardwareAddr) PatternFlowArpSenderHardwareAddr
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpSenderHardwareAddrChoiceEnum
	SetChoice(value PatternFlowArpSenderHardwareAddrChoiceEnum) PatternFlowArpSenderHardwareAddr
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowArpSenderHardwareAddr
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowArpSenderHardwareAddr
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpSenderHardwareAddr
	HasMetricGroup() bool
	Increment() PatternFlowArpSenderHardwareAddrCounter
	SetIncrement(value PatternFlowArpSenderHardwareAddrCounter) PatternFlowArpSenderHardwareAddr
	HasIncrement() bool
	Decrement() PatternFlowArpSenderHardwareAddrCounter
	SetDecrement(value PatternFlowArpSenderHardwareAddrCounter) PatternFlowArpSenderHardwareAddr
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpSenderHardwareAddr added in v0.6.5 

func NewPatternFlowArpSenderHardwareAddr() PatternFlowArpSenderHardwareAddr

type PatternFlowArpSenderHardwareAddrChoiceEnum 

type PatternFlowArpSenderHardwareAddrChoiceEnum string

type PatternFlowArpSenderHardwareAddrCounter 

type PatternFlowArpSenderHardwareAddrCounter interface {
	Msg() *snappipb.PatternFlowArpSenderHardwareAddrCounter
	SetMsg(*snappipb.PatternFlowArpSenderHardwareAddrCounter) PatternFlowArpSenderHardwareAddrCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowArpSenderHardwareAddrCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowArpSenderHardwareAddrCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpSenderHardwareAddrCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpSenderHardwareAddrCounter added in v0.6.5 

func NewPatternFlowArpSenderHardwareAddrCounter() PatternFlowArpSenderHardwareAddrCounter

type PatternFlowArpSenderProtocolAddr 

type PatternFlowArpSenderProtocolAddr interface {
	Msg() *snappipb.PatternFlowArpSenderProtocolAddr
	SetMsg(*snappipb.PatternFlowArpSenderProtocolAddr) PatternFlowArpSenderProtocolAddr
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpSenderProtocolAddrChoiceEnum
	SetChoice(value PatternFlowArpSenderProtocolAddrChoiceEnum) PatternFlowArpSenderProtocolAddr
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowArpSenderProtocolAddr
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowArpSenderProtocolAddr
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpSenderProtocolAddr
	HasMetricGroup() bool
	Increment() PatternFlowArpSenderProtocolAddrCounter
	SetIncrement(value PatternFlowArpSenderProtocolAddrCounter) PatternFlowArpSenderProtocolAddr
	HasIncrement() bool
	Decrement() PatternFlowArpSenderProtocolAddrCounter
	SetDecrement(value PatternFlowArpSenderProtocolAddrCounter) PatternFlowArpSenderProtocolAddr
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpSenderProtocolAddr added in v0.6.5 

func NewPatternFlowArpSenderProtocolAddr() PatternFlowArpSenderProtocolAddr

type PatternFlowArpSenderProtocolAddrChoiceEnum 

type PatternFlowArpSenderProtocolAddrChoiceEnum string

type PatternFlowArpSenderProtocolAddrCounter 

type PatternFlowArpSenderProtocolAddrCounter interface {
	Msg() *snappipb.PatternFlowArpSenderProtocolAddrCounter
	SetMsg(*snappipb.PatternFlowArpSenderProtocolAddrCounter) PatternFlowArpSenderProtocolAddrCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowArpSenderProtocolAddrCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowArpSenderProtocolAddrCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpSenderProtocolAddrCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpSenderProtocolAddrCounter added in v0.6.5 

func NewPatternFlowArpSenderProtocolAddrCounter() PatternFlowArpSenderProtocolAddrCounter

type PatternFlowArpTargetHardwareAddr 

type PatternFlowArpTargetHardwareAddr interface {
	Msg() *snappipb.PatternFlowArpTargetHardwareAddr
	SetMsg(*snappipb.PatternFlowArpTargetHardwareAddr) PatternFlowArpTargetHardwareAddr
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpTargetHardwareAddrChoiceEnum
	SetChoice(value PatternFlowArpTargetHardwareAddrChoiceEnum) PatternFlowArpTargetHardwareAddr
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowArpTargetHardwareAddr
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowArpTargetHardwareAddr
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpTargetHardwareAddr
	HasMetricGroup() bool
	Increment() PatternFlowArpTargetHardwareAddrCounter
	SetIncrement(value PatternFlowArpTargetHardwareAddrCounter) PatternFlowArpTargetHardwareAddr
	HasIncrement() bool
	Decrement() PatternFlowArpTargetHardwareAddrCounter
	SetDecrement(value PatternFlowArpTargetHardwareAddrCounter) PatternFlowArpTargetHardwareAddr
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpTargetHardwareAddr added in v0.6.5 

func NewPatternFlowArpTargetHardwareAddr() PatternFlowArpTargetHardwareAddr

type PatternFlowArpTargetHardwareAddrChoiceEnum 

type PatternFlowArpTargetHardwareAddrChoiceEnum string

type PatternFlowArpTargetHardwareAddrCounter 

type PatternFlowArpTargetHardwareAddrCounter interface {
	Msg() *snappipb.PatternFlowArpTargetHardwareAddrCounter
	SetMsg(*snappipb.PatternFlowArpTargetHardwareAddrCounter) PatternFlowArpTargetHardwareAddrCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowArpTargetHardwareAddrCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowArpTargetHardwareAddrCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpTargetHardwareAddrCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpTargetHardwareAddrCounter added in v0.6.5 

func NewPatternFlowArpTargetHardwareAddrCounter() PatternFlowArpTargetHardwareAddrCounter

type PatternFlowArpTargetProtocolAddr 

type PatternFlowArpTargetProtocolAddr interface {
	Msg() *snappipb.PatternFlowArpTargetProtocolAddr
	SetMsg(*snappipb.PatternFlowArpTargetProtocolAddr) PatternFlowArpTargetProtocolAddr
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowArpTargetProtocolAddrChoiceEnum
	SetChoice(value PatternFlowArpTargetProtocolAddrChoiceEnum) PatternFlowArpTargetProtocolAddr
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowArpTargetProtocolAddr
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowArpTargetProtocolAddr
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowArpTargetProtocolAddr
	HasMetricGroup() bool
	Increment() PatternFlowArpTargetProtocolAddrCounter
	SetIncrement(value PatternFlowArpTargetProtocolAddrCounter) PatternFlowArpTargetProtocolAddr
	HasIncrement() bool
	Decrement() PatternFlowArpTargetProtocolAddrCounter
	SetDecrement(value PatternFlowArpTargetProtocolAddrCounter) PatternFlowArpTargetProtocolAddr
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpTargetProtocolAddr added in v0.6.5 

func NewPatternFlowArpTargetProtocolAddr() PatternFlowArpTargetProtocolAddr

type PatternFlowArpTargetProtocolAddrChoiceEnum 

type PatternFlowArpTargetProtocolAddrChoiceEnum string

type PatternFlowArpTargetProtocolAddrCounter 

type PatternFlowArpTargetProtocolAddrCounter interface {
	Msg() *snappipb.PatternFlowArpTargetProtocolAddrCounter
	SetMsg(*snappipb.PatternFlowArpTargetProtocolAddrCounter) PatternFlowArpTargetProtocolAddrCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowArpTargetProtocolAddrCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowArpTargetProtocolAddrCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowArpTargetProtocolAddrCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowArpTargetProtocolAddrCounter added in v0.6.5 

func NewPatternFlowArpTargetProtocolAddrCounter() PatternFlowArpTargetProtocolAddrCounter

type PatternFlowEthernetDst 

type PatternFlowEthernetDst interface {
	Msg() *snappipb.PatternFlowEthernetDst
	SetMsg(*snappipb.PatternFlowEthernetDst) PatternFlowEthernetDst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetDstChoiceEnum
	SetChoice(value PatternFlowEthernetDstChoiceEnum) PatternFlowEthernetDst
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowEthernetDst
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowEthernetDst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetDst
	HasMetricGroup() bool
	Increment() PatternFlowEthernetDstCounter
	SetIncrement(value PatternFlowEthernetDstCounter) PatternFlowEthernetDst
	HasIncrement() bool
	Decrement() PatternFlowEthernetDstCounter
	SetDecrement(value PatternFlowEthernetDstCounter) PatternFlowEthernetDst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetDst added in v0.6.5 

func NewPatternFlowEthernetDst() PatternFlowEthernetDst

type PatternFlowEthernetDstChoiceEnum 

type PatternFlowEthernetDstChoiceEnum string

type PatternFlowEthernetDstCounter 

type PatternFlowEthernetDstCounter interface {
	Msg() *snappipb.PatternFlowEthernetDstCounter
	SetMsg(*snappipb.PatternFlowEthernetDstCounter) PatternFlowEthernetDstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowEthernetDstCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowEthernetDstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetDstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetDstCounter added in v0.6.5 

func NewPatternFlowEthernetDstCounter() PatternFlowEthernetDstCounter

type PatternFlowEthernetEtherType 

type PatternFlowEthernetEtherType interface {
	Msg() *snappipb.PatternFlowEthernetEtherType
	SetMsg(*snappipb.PatternFlowEthernetEtherType) PatternFlowEthernetEtherType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetEtherTypeChoiceEnum
	SetChoice(value PatternFlowEthernetEtherTypeChoiceEnum) PatternFlowEthernetEtherType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowEthernetEtherType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowEthernetEtherType
	Auto() PatternFlowEthernetEtherTypeAutoEnum
	SetAuto(value PatternFlowEthernetEtherTypeAutoEnum) PatternFlowEthernetEtherType
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetEtherType
	HasMetricGroup() bool
	Increment() PatternFlowEthernetEtherTypeCounter
	SetIncrement(value PatternFlowEthernetEtherTypeCounter) PatternFlowEthernetEtherType
	HasIncrement() bool
	Decrement() PatternFlowEthernetEtherTypeCounter
	SetDecrement(value PatternFlowEthernetEtherTypeCounter) PatternFlowEthernetEtherType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetEtherType added in v0.6.5 

func NewPatternFlowEthernetEtherType() PatternFlowEthernetEtherType

type PatternFlowEthernetEtherTypeAutoEnum 

type PatternFlowEthernetEtherTypeAutoEnum string

type PatternFlowEthernetEtherTypeChoiceEnum 

type PatternFlowEthernetEtherTypeChoiceEnum string

type PatternFlowEthernetEtherTypeCounter 

type PatternFlowEthernetEtherTypeCounter interface {
	Msg() *snappipb.PatternFlowEthernetEtherTypeCounter
	SetMsg(*snappipb.PatternFlowEthernetEtherTypeCounter) PatternFlowEthernetEtherTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowEthernetEtherTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowEthernetEtherTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetEtherTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetEtherTypeCounter added in v0.6.5 

func NewPatternFlowEthernetEtherTypeCounter() PatternFlowEthernetEtherTypeCounter

type PatternFlowEthernetPauseControlOpCode 

type PatternFlowEthernetPauseControlOpCode interface {
	Msg() *snappipb.PatternFlowEthernetPauseControlOpCode
	SetMsg(*snappipb.PatternFlowEthernetPauseControlOpCode) PatternFlowEthernetPauseControlOpCode
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPauseControlOpCodeChoiceEnum
	SetChoice(value PatternFlowEthernetPauseControlOpCodeChoiceEnum) PatternFlowEthernetPauseControlOpCode
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowEthernetPauseControlOpCode
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowEthernetPauseControlOpCode
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPauseControlOpCode
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPauseControlOpCodeCounter
	SetIncrement(value PatternFlowEthernetPauseControlOpCodeCounter) PatternFlowEthernetPauseControlOpCode
	HasIncrement() bool
	Decrement() PatternFlowEthernetPauseControlOpCodeCounter
	SetDecrement(value PatternFlowEthernetPauseControlOpCodeCounter) PatternFlowEthernetPauseControlOpCode
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseControlOpCode added in v0.6.5 

func NewPatternFlowEthernetPauseControlOpCode() PatternFlowEthernetPauseControlOpCode

type PatternFlowEthernetPauseControlOpCodeChoiceEnum 

type PatternFlowEthernetPauseControlOpCodeChoiceEnum string

type PatternFlowEthernetPauseControlOpCodeCounter 

type PatternFlowEthernetPauseControlOpCodeCounter interface {
	Msg() *snappipb.PatternFlowEthernetPauseControlOpCodeCounter
	SetMsg(*snappipb.PatternFlowEthernetPauseControlOpCodeCounter) PatternFlowEthernetPauseControlOpCodeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowEthernetPauseControlOpCodeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowEthernetPauseControlOpCodeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPauseControlOpCodeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseControlOpCodeCounter added in v0.6.5 

func NewPatternFlowEthernetPauseControlOpCodeCounter() PatternFlowEthernetPauseControlOpCodeCounter

type PatternFlowEthernetPauseDst 

type PatternFlowEthernetPauseDst interface {
	Msg() *snappipb.PatternFlowEthernetPauseDst
	SetMsg(*snappipb.PatternFlowEthernetPauseDst) PatternFlowEthernetPauseDst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPauseDstChoiceEnum
	SetChoice(value PatternFlowEthernetPauseDstChoiceEnum) PatternFlowEthernetPauseDst
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowEthernetPauseDst
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowEthernetPauseDst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPauseDst
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPauseDstCounter
	SetIncrement(value PatternFlowEthernetPauseDstCounter) PatternFlowEthernetPauseDst
	HasIncrement() bool
	Decrement() PatternFlowEthernetPauseDstCounter
	SetDecrement(value PatternFlowEthernetPauseDstCounter) PatternFlowEthernetPauseDst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseDst added in v0.6.5 

func NewPatternFlowEthernetPauseDst() PatternFlowEthernetPauseDst

type PatternFlowEthernetPauseDstChoiceEnum 

type PatternFlowEthernetPauseDstChoiceEnum string

type PatternFlowEthernetPauseDstCounter 

type PatternFlowEthernetPauseDstCounter interface {
	Msg() *snappipb.PatternFlowEthernetPauseDstCounter
	SetMsg(*snappipb.PatternFlowEthernetPauseDstCounter) PatternFlowEthernetPauseDstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowEthernetPauseDstCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowEthernetPauseDstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPauseDstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseDstCounter added in v0.6.5 

func NewPatternFlowEthernetPauseDstCounter() PatternFlowEthernetPauseDstCounter

type PatternFlowEthernetPauseEtherType 

type PatternFlowEthernetPauseEtherType interface {
	Msg() *snappipb.PatternFlowEthernetPauseEtherType
	SetMsg(*snappipb.PatternFlowEthernetPauseEtherType) PatternFlowEthernetPauseEtherType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPauseEtherTypeChoiceEnum
	SetChoice(value PatternFlowEthernetPauseEtherTypeChoiceEnum) PatternFlowEthernetPauseEtherType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowEthernetPauseEtherType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowEthernetPauseEtherType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPauseEtherType
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPauseEtherTypeCounter
	SetIncrement(value PatternFlowEthernetPauseEtherTypeCounter) PatternFlowEthernetPauseEtherType
	HasIncrement() bool
	Decrement() PatternFlowEthernetPauseEtherTypeCounter
	SetDecrement(value PatternFlowEthernetPauseEtherTypeCounter) PatternFlowEthernetPauseEtherType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseEtherType added in v0.6.5 

func NewPatternFlowEthernetPauseEtherType() PatternFlowEthernetPauseEtherType

type PatternFlowEthernetPauseEtherTypeChoiceEnum 

type PatternFlowEthernetPauseEtherTypeChoiceEnum string

type PatternFlowEthernetPauseEtherTypeCounter 

type PatternFlowEthernetPauseEtherTypeCounter interface {
	Msg() *snappipb.PatternFlowEthernetPauseEtherTypeCounter
	SetMsg(*snappipb.PatternFlowEthernetPauseEtherTypeCounter) PatternFlowEthernetPauseEtherTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowEthernetPauseEtherTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowEthernetPauseEtherTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPauseEtherTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseEtherTypeCounter added in v0.6.5 

func NewPatternFlowEthernetPauseEtherTypeCounter() PatternFlowEthernetPauseEtherTypeCounter

type PatternFlowEthernetPauseSrc 

type PatternFlowEthernetPauseSrc interface {
	Msg() *snappipb.PatternFlowEthernetPauseSrc
	SetMsg(*snappipb.PatternFlowEthernetPauseSrc) PatternFlowEthernetPauseSrc
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPauseSrcChoiceEnum
	SetChoice(value PatternFlowEthernetPauseSrcChoiceEnum) PatternFlowEthernetPauseSrc
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowEthernetPauseSrc
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowEthernetPauseSrc
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPauseSrc
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPauseSrcCounter
	SetIncrement(value PatternFlowEthernetPauseSrcCounter) PatternFlowEthernetPauseSrc
	HasIncrement() bool
	Decrement() PatternFlowEthernetPauseSrcCounter
	SetDecrement(value PatternFlowEthernetPauseSrcCounter) PatternFlowEthernetPauseSrc
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseSrc added in v0.6.5 

func NewPatternFlowEthernetPauseSrc() PatternFlowEthernetPauseSrc

type PatternFlowEthernetPauseSrcChoiceEnum 

type PatternFlowEthernetPauseSrcChoiceEnum string

type PatternFlowEthernetPauseSrcCounter 

type PatternFlowEthernetPauseSrcCounter interface {
	Msg() *snappipb.PatternFlowEthernetPauseSrcCounter
	SetMsg(*snappipb.PatternFlowEthernetPauseSrcCounter) PatternFlowEthernetPauseSrcCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowEthernetPauseSrcCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowEthernetPauseSrcCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPauseSrcCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseSrcCounter added in v0.6.5 

func NewPatternFlowEthernetPauseSrcCounter() PatternFlowEthernetPauseSrcCounter

type PatternFlowEthernetPauseTime 

type PatternFlowEthernetPauseTime interface {
	Msg() *snappipb.PatternFlowEthernetPauseTime
	SetMsg(*snappipb.PatternFlowEthernetPauseTime) PatternFlowEthernetPauseTime
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPauseTimeChoiceEnum
	SetChoice(value PatternFlowEthernetPauseTimeChoiceEnum) PatternFlowEthernetPauseTime
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowEthernetPauseTime
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowEthernetPauseTime
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPauseTime
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPauseTimeCounter
	SetIncrement(value PatternFlowEthernetPauseTimeCounter) PatternFlowEthernetPauseTime
	HasIncrement() bool
	Decrement() PatternFlowEthernetPauseTimeCounter
	SetDecrement(value PatternFlowEthernetPauseTimeCounter) PatternFlowEthernetPauseTime
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseTime added in v0.6.5 

func NewPatternFlowEthernetPauseTime() PatternFlowEthernetPauseTime

type PatternFlowEthernetPauseTimeChoiceEnum 

type PatternFlowEthernetPauseTimeChoiceEnum string

type PatternFlowEthernetPauseTimeCounter 

type PatternFlowEthernetPauseTimeCounter interface {
	Msg() *snappipb.PatternFlowEthernetPauseTimeCounter
	SetMsg(*snappipb.PatternFlowEthernetPauseTimeCounter) PatternFlowEthernetPauseTimeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowEthernetPauseTimeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowEthernetPauseTimeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPauseTimeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPauseTimeCounter added in v0.6.5 

func NewPatternFlowEthernetPauseTimeCounter() PatternFlowEthernetPauseTimeCounter

type PatternFlowEthernetPfcQueue 

type PatternFlowEthernetPfcQueue interface {
	Msg() *snappipb.PatternFlowEthernetPfcQueue
	SetMsg(*snappipb.PatternFlowEthernetPfcQueue) PatternFlowEthernetPfcQueue
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetPfcQueueChoiceEnum
	SetChoice(value PatternFlowEthernetPfcQueueChoiceEnum) PatternFlowEthernetPfcQueue
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowEthernetPfcQueue
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowEthernetPfcQueue
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetPfcQueue
	HasMetricGroup() bool
	Increment() PatternFlowEthernetPfcQueueCounter
	SetIncrement(value PatternFlowEthernetPfcQueueCounter) PatternFlowEthernetPfcQueue
	HasIncrement() bool
	Decrement() PatternFlowEthernetPfcQueueCounter
	SetDecrement(value PatternFlowEthernetPfcQueueCounter) PatternFlowEthernetPfcQueue
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPfcQueue added in v0.6.5 

func NewPatternFlowEthernetPfcQueue() PatternFlowEthernetPfcQueue

type PatternFlowEthernetPfcQueueChoiceEnum 

type PatternFlowEthernetPfcQueueChoiceEnum string

type PatternFlowEthernetPfcQueueCounter 

type PatternFlowEthernetPfcQueueCounter interface {
	Msg() *snappipb.PatternFlowEthernetPfcQueueCounter
	SetMsg(*snappipb.PatternFlowEthernetPfcQueueCounter) PatternFlowEthernetPfcQueueCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowEthernetPfcQueueCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowEthernetPfcQueueCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetPfcQueueCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetPfcQueueCounter added in v0.6.5 

func NewPatternFlowEthernetPfcQueueCounter() PatternFlowEthernetPfcQueueCounter

type PatternFlowEthernetSrc 

type PatternFlowEthernetSrc interface {
	Msg() *snappipb.PatternFlowEthernetSrc
	SetMsg(*snappipb.PatternFlowEthernetSrc) PatternFlowEthernetSrc
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowEthernetSrcChoiceEnum
	SetChoice(value PatternFlowEthernetSrcChoiceEnum) PatternFlowEthernetSrc
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowEthernetSrc
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowEthernetSrc
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowEthernetSrc
	HasMetricGroup() bool
	Increment() PatternFlowEthernetSrcCounter
	SetIncrement(value PatternFlowEthernetSrcCounter) PatternFlowEthernetSrc
	HasIncrement() bool
	Decrement() PatternFlowEthernetSrcCounter
	SetDecrement(value PatternFlowEthernetSrcCounter) PatternFlowEthernetSrc
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetSrc added in v0.6.5 

func NewPatternFlowEthernetSrc() PatternFlowEthernetSrc

type PatternFlowEthernetSrcChoiceEnum 

type PatternFlowEthernetSrcChoiceEnum string

type PatternFlowEthernetSrcCounter 

type PatternFlowEthernetSrcCounter interface {
	Msg() *snappipb.PatternFlowEthernetSrcCounter
	SetMsg(*snappipb.PatternFlowEthernetSrcCounter) PatternFlowEthernetSrcCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowEthernetSrcCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowEthernetSrcCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowEthernetSrcCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowEthernetSrcCounter added in v0.6.5 

func NewPatternFlowEthernetSrcCounter() PatternFlowEthernetSrcCounter

type PatternFlowGreChecksum 

type PatternFlowGreChecksum interface {
	Msg() *snappipb.PatternFlowGreChecksum
	SetMsg(*snappipb.PatternFlowGreChecksum) PatternFlowGreChecksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreChecksumChoiceEnum
	SetChoice(value PatternFlowGreChecksumChoiceEnum) PatternFlowGreChecksum
	Generated() PatternFlowGreChecksumGeneratedEnum
	SetGenerated(value PatternFlowGreChecksumGeneratedEnum) PatternFlowGreChecksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowGreChecksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreChecksum added in v0.6.5 

func NewPatternFlowGreChecksum() PatternFlowGreChecksum

type PatternFlowGreChecksumChoiceEnum 

type PatternFlowGreChecksumChoiceEnum string

type PatternFlowGreChecksumGeneratedEnum 

type PatternFlowGreChecksumGeneratedEnum string

type PatternFlowGreChecksumPresent 

type PatternFlowGreChecksumPresent interface {
	Msg() *snappipb.PatternFlowGreChecksumPresent
	SetMsg(*snappipb.PatternFlowGreChecksumPresent) PatternFlowGreChecksumPresent
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreChecksumPresentChoiceEnum
	SetChoice(value PatternFlowGreChecksumPresentChoiceEnum) PatternFlowGreChecksumPresent
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGreChecksumPresent
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGreChecksumPresent
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGreChecksumPresent
	HasMetricGroup() bool
	Increment() PatternFlowGreChecksumPresentCounter
	SetIncrement(value PatternFlowGreChecksumPresentCounter) PatternFlowGreChecksumPresent
	HasIncrement() bool
	Decrement() PatternFlowGreChecksumPresentCounter
	SetDecrement(value PatternFlowGreChecksumPresentCounter) PatternFlowGreChecksumPresent
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreChecksumPresent added in v0.6.5 

func NewPatternFlowGreChecksumPresent() PatternFlowGreChecksumPresent

type PatternFlowGreChecksumPresentChoiceEnum 

type PatternFlowGreChecksumPresentChoiceEnum string

type PatternFlowGreChecksumPresentCounter 

type PatternFlowGreChecksumPresentCounter interface {
	Msg() *snappipb.PatternFlowGreChecksumPresentCounter
	SetMsg(*snappipb.PatternFlowGreChecksumPresentCounter) PatternFlowGreChecksumPresentCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGreChecksumPresentCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGreChecksumPresentCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGreChecksumPresentCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreChecksumPresentCounter added in v0.6.5 

func NewPatternFlowGreChecksumPresentCounter() PatternFlowGreChecksumPresentCounter

type PatternFlowGreProtocol 

type PatternFlowGreProtocol interface {
	Msg() *snappipb.PatternFlowGreProtocol
	SetMsg(*snappipb.PatternFlowGreProtocol) PatternFlowGreProtocol
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreProtocolChoiceEnum
	SetChoice(value PatternFlowGreProtocolChoiceEnum) PatternFlowGreProtocol
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGreProtocol
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGreProtocol
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGreProtocol
	HasMetricGroup() bool
	Increment() PatternFlowGreProtocolCounter
	SetIncrement(value PatternFlowGreProtocolCounter) PatternFlowGreProtocol
	HasIncrement() bool
	Decrement() PatternFlowGreProtocolCounter
	SetDecrement(value PatternFlowGreProtocolCounter) PatternFlowGreProtocol
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreProtocol added in v0.6.5 

func NewPatternFlowGreProtocol() PatternFlowGreProtocol

type PatternFlowGreProtocolChoiceEnum 

type PatternFlowGreProtocolChoiceEnum string

type PatternFlowGreProtocolCounter 

type PatternFlowGreProtocolCounter interface {
	Msg() *snappipb.PatternFlowGreProtocolCounter
	SetMsg(*snappipb.PatternFlowGreProtocolCounter) PatternFlowGreProtocolCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGreProtocolCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGreProtocolCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGreProtocolCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreProtocolCounter added in v0.6.5 

func NewPatternFlowGreProtocolCounter() PatternFlowGreProtocolCounter

type PatternFlowGreReserved0 

type PatternFlowGreReserved0 interface {
	Msg() *snappipb.PatternFlowGreReserved0
	SetMsg(*snappipb.PatternFlowGreReserved0) PatternFlowGreReserved0
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreReserved0ChoiceEnum
	SetChoice(value PatternFlowGreReserved0ChoiceEnum) PatternFlowGreReserved0
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGreReserved0
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGreReserved0
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGreReserved0
	HasMetricGroup() bool
	Increment() PatternFlowGreReserved0Counter
	SetIncrement(value PatternFlowGreReserved0Counter) PatternFlowGreReserved0
	HasIncrement() bool
	Decrement() PatternFlowGreReserved0Counter
	SetDecrement(value PatternFlowGreReserved0Counter) PatternFlowGreReserved0
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreReserved0 added in v0.6.5 

func NewPatternFlowGreReserved0() PatternFlowGreReserved0

type PatternFlowGreReserved0ChoiceEnum 

type PatternFlowGreReserved0ChoiceEnum string

type PatternFlowGreReserved0Counter 

type PatternFlowGreReserved0Counter interface {
	Msg() *snappipb.PatternFlowGreReserved0Counter
	SetMsg(*snappipb.PatternFlowGreReserved0Counter) PatternFlowGreReserved0Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGreReserved0Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGreReserved0Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGreReserved0Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreReserved0Counter added in v0.6.5 

func NewPatternFlowGreReserved0Counter() PatternFlowGreReserved0Counter

type PatternFlowGreReserved1 

type PatternFlowGreReserved1 interface {
	Msg() *snappipb.PatternFlowGreReserved1
	SetMsg(*snappipb.PatternFlowGreReserved1) PatternFlowGreReserved1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreReserved1ChoiceEnum
	SetChoice(value PatternFlowGreReserved1ChoiceEnum) PatternFlowGreReserved1
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGreReserved1
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGreReserved1
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGreReserved1
	HasMetricGroup() bool
	Increment() PatternFlowGreReserved1Counter
	SetIncrement(value PatternFlowGreReserved1Counter) PatternFlowGreReserved1
	HasIncrement() bool
	Decrement() PatternFlowGreReserved1Counter
	SetDecrement(value PatternFlowGreReserved1Counter) PatternFlowGreReserved1
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreReserved1 added in v0.6.5 

func NewPatternFlowGreReserved1() PatternFlowGreReserved1

type PatternFlowGreReserved1ChoiceEnum 

type PatternFlowGreReserved1ChoiceEnum string

type PatternFlowGreReserved1Counter 

type PatternFlowGreReserved1Counter interface {
	Msg() *snappipb.PatternFlowGreReserved1Counter
	SetMsg(*snappipb.PatternFlowGreReserved1Counter) PatternFlowGreReserved1Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGreReserved1Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGreReserved1Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGreReserved1Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreReserved1Counter added in v0.6.5 

func NewPatternFlowGreReserved1Counter() PatternFlowGreReserved1Counter

type PatternFlowGreVersion 

type PatternFlowGreVersion interface {
	Msg() *snappipb.PatternFlowGreVersion
	SetMsg(*snappipb.PatternFlowGreVersion) PatternFlowGreVersion
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGreVersionChoiceEnum
	SetChoice(value PatternFlowGreVersionChoiceEnum) PatternFlowGreVersion
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGreVersion
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGreVersion
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGreVersion
	HasMetricGroup() bool
	Increment() PatternFlowGreVersionCounter
	SetIncrement(value PatternFlowGreVersionCounter) PatternFlowGreVersion
	HasIncrement() bool
	Decrement() PatternFlowGreVersionCounter
	SetDecrement(value PatternFlowGreVersionCounter) PatternFlowGreVersion
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreVersion added in v0.6.5 

func NewPatternFlowGreVersion() PatternFlowGreVersion

type PatternFlowGreVersionChoiceEnum 

type PatternFlowGreVersionChoiceEnum string

type PatternFlowGreVersionCounter 

type PatternFlowGreVersionCounter interface {
	Msg() *snappipb.PatternFlowGreVersionCounter
	SetMsg(*snappipb.PatternFlowGreVersionCounter) PatternFlowGreVersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGreVersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGreVersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGreVersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGreVersionCounter added in v0.6.5 

func NewPatternFlowGreVersionCounter() PatternFlowGreVersionCounter

type PatternFlowGtpExtensionContents 

type PatternFlowGtpExtensionContents interface {
	Msg() *snappipb.PatternFlowGtpExtensionContents
	SetMsg(*snappipb.PatternFlowGtpExtensionContents) PatternFlowGtpExtensionContents
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpExtensionContentsChoiceEnum
	SetChoice(value PatternFlowGtpExtensionContentsChoiceEnum) PatternFlowGtpExtensionContents
	HasChoice() bool
	Value() int64
	SetValue(value int64) PatternFlowGtpExtensionContents
	HasValue() bool
	Values() []int64
	SetValues(value []int64) PatternFlowGtpExtensionContents
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpExtensionContents
	HasMetricGroup() bool
	Increment() PatternFlowGtpExtensionContentsCounter
	SetIncrement(value PatternFlowGtpExtensionContentsCounter) PatternFlowGtpExtensionContents
	HasIncrement() bool
	Decrement() PatternFlowGtpExtensionContentsCounter
	SetDecrement(value PatternFlowGtpExtensionContentsCounter) PatternFlowGtpExtensionContents
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionContents added in v0.6.5 

func NewPatternFlowGtpExtensionContents() PatternFlowGtpExtensionContents

type PatternFlowGtpExtensionContentsChoiceEnum 

type PatternFlowGtpExtensionContentsChoiceEnum string

type PatternFlowGtpExtensionContentsCounter 

type PatternFlowGtpExtensionContentsCounter interface {
	Msg() *snappipb.PatternFlowGtpExtensionContentsCounter
	SetMsg(*snappipb.PatternFlowGtpExtensionContentsCounter) PatternFlowGtpExtensionContentsCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int64
	SetStart(value int64) PatternFlowGtpExtensionContentsCounter
	HasStart() bool
	Step() int64
	SetStep(value int64) PatternFlowGtpExtensionContentsCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpExtensionContentsCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionContentsCounter added in v0.6.5 

func NewPatternFlowGtpExtensionContentsCounter() PatternFlowGtpExtensionContentsCounter

type PatternFlowGtpExtensionExtensionLength 

type PatternFlowGtpExtensionExtensionLength interface {
	Msg() *snappipb.PatternFlowGtpExtensionExtensionLength
	SetMsg(*snappipb.PatternFlowGtpExtensionExtensionLength) PatternFlowGtpExtensionExtensionLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpExtensionExtensionLengthChoiceEnum
	SetChoice(value PatternFlowGtpExtensionExtensionLengthChoiceEnum) PatternFlowGtpExtensionExtensionLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpExtensionExtensionLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpExtensionExtensionLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpExtensionExtensionLength
	HasMetricGroup() bool
	Increment() PatternFlowGtpExtensionExtensionLengthCounter
	SetIncrement(value PatternFlowGtpExtensionExtensionLengthCounter) PatternFlowGtpExtensionExtensionLength
	HasIncrement() bool
	Decrement() PatternFlowGtpExtensionExtensionLengthCounter
	SetDecrement(value PatternFlowGtpExtensionExtensionLengthCounter) PatternFlowGtpExtensionExtensionLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionExtensionLength added in v0.6.5 

func NewPatternFlowGtpExtensionExtensionLength() PatternFlowGtpExtensionExtensionLength

type PatternFlowGtpExtensionExtensionLengthChoiceEnum 

type PatternFlowGtpExtensionExtensionLengthChoiceEnum string

type PatternFlowGtpExtensionExtensionLengthCounter 

type PatternFlowGtpExtensionExtensionLengthCounter interface {
	Msg() *snappipb.PatternFlowGtpExtensionExtensionLengthCounter
	SetMsg(*snappipb.PatternFlowGtpExtensionExtensionLengthCounter) PatternFlowGtpExtensionExtensionLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpExtensionExtensionLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpExtensionExtensionLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpExtensionExtensionLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionExtensionLengthCounter added in v0.6.5 

func NewPatternFlowGtpExtensionExtensionLengthCounter() PatternFlowGtpExtensionExtensionLengthCounter

type PatternFlowGtpExtensionNextExtensionHeader 

type PatternFlowGtpExtensionNextExtensionHeader interface {
	Msg() *snappipb.PatternFlowGtpExtensionNextExtensionHeader
	SetMsg(*snappipb.PatternFlowGtpExtensionNextExtensionHeader) PatternFlowGtpExtensionNextExtensionHeader
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum
	SetChoice(value PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum) PatternFlowGtpExtensionNextExtensionHeader
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpExtensionNextExtensionHeader
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpExtensionNextExtensionHeader
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpExtensionNextExtensionHeader
	HasMetricGroup() bool
	Increment() PatternFlowGtpExtensionNextExtensionHeaderCounter
	SetIncrement(value PatternFlowGtpExtensionNextExtensionHeaderCounter) PatternFlowGtpExtensionNextExtensionHeader
	HasIncrement() bool
	Decrement() PatternFlowGtpExtensionNextExtensionHeaderCounter
	SetDecrement(value PatternFlowGtpExtensionNextExtensionHeaderCounter) PatternFlowGtpExtensionNextExtensionHeader
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionNextExtensionHeader added in v0.6.5 

func NewPatternFlowGtpExtensionNextExtensionHeader() PatternFlowGtpExtensionNextExtensionHeader

type PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum 

type PatternFlowGtpExtensionNextExtensionHeaderChoiceEnum string

type PatternFlowGtpExtensionNextExtensionHeaderCounter 

type PatternFlowGtpExtensionNextExtensionHeaderCounter interface {
	Msg() *snappipb.PatternFlowGtpExtensionNextExtensionHeaderCounter
	SetMsg(*snappipb.PatternFlowGtpExtensionNextExtensionHeaderCounter) PatternFlowGtpExtensionNextExtensionHeaderCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpExtensionNextExtensionHeaderCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpExtensionNextExtensionHeaderCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpExtensionNextExtensionHeaderCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpExtensionNextExtensionHeaderCounter added in v0.6.5 

func NewPatternFlowGtpExtensionNextExtensionHeaderCounter() PatternFlowGtpExtensionNextExtensionHeaderCounter

type PatternFlowGtpv1EFlag 

type PatternFlowGtpv1EFlag interface {
	Msg() *snappipb.PatternFlowGtpv1EFlag
	SetMsg(*snappipb.PatternFlowGtpv1EFlag) PatternFlowGtpv1EFlag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1EFlagChoiceEnum
	SetChoice(value PatternFlowGtpv1EFlagChoiceEnum) PatternFlowGtpv1EFlag
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1EFlag
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1EFlag
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1EFlag
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1EFlagCounter
	SetIncrement(value PatternFlowGtpv1EFlagCounter) PatternFlowGtpv1EFlag
	HasIncrement() bool
	Decrement() PatternFlowGtpv1EFlagCounter
	SetDecrement(value PatternFlowGtpv1EFlagCounter) PatternFlowGtpv1EFlag
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1EFlag added in v0.6.5 

func NewPatternFlowGtpv1EFlag() PatternFlowGtpv1EFlag

type PatternFlowGtpv1EFlagChoiceEnum 

type PatternFlowGtpv1EFlagChoiceEnum string

type PatternFlowGtpv1EFlagCounter 

type PatternFlowGtpv1EFlagCounter interface {
	Msg() *snappipb.PatternFlowGtpv1EFlagCounter
	SetMsg(*snappipb.PatternFlowGtpv1EFlagCounter) PatternFlowGtpv1EFlagCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1EFlagCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1EFlagCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1EFlagCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1EFlagCounter added in v0.6.5 

func NewPatternFlowGtpv1EFlagCounter() PatternFlowGtpv1EFlagCounter

type PatternFlowGtpv1MessageLength 

type PatternFlowGtpv1MessageLength interface {
	Msg() *snappipb.PatternFlowGtpv1MessageLength
	SetMsg(*snappipb.PatternFlowGtpv1MessageLength) PatternFlowGtpv1MessageLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1MessageLengthChoiceEnum
	SetChoice(value PatternFlowGtpv1MessageLengthChoiceEnum) PatternFlowGtpv1MessageLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1MessageLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1MessageLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1MessageLength
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1MessageLengthCounter
	SetIncrement(value PatternFlowGtpv1MessageLengthCounter) PatternFlowGtpv1MessageLength
	HasIncrement() bool
	Decrement() PatternFlowGtpv1MessageLengthCounter
	SetDecrement(value PatternFlowGtpv1MessageLengthCounter) PatternFlowGtpv1MessageLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1MessageLength added in v0.6.5 

func NewPatternFlowGtpv1MessageLength() PatternFlowGtpv1MessageLength

type PatternFlowGtpv1MessageLengthChoiceEnum 

type PatternFlowGtpv1MessageLengthChoiceEnum string

type PatternFlowGtpv1MessageLengthCounter 

type PatternFlowGtpv1MessageLengthCounter interface {
	Msg() *snappipb.PatternFlowGtpv1MessageLengthCounter
	SetMsg(*snappipb.PatternFlowGtpv1MessageLengthCounter) PatternFlowGtpv1MessageLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1MessageLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1MessageLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1MessageLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1MessageLengthCounter added in v0.6.5 

func NewPatternFlowGtpv1MessageLengthCounter() PatternFlowGtpv1MessageLengthCounter

type PatternFlowGtpv1MessageType 

type PatternFlowGtpv1MessageType interface {
	Msg() *snappipb.PatternFlowGtpv1MessageType
	SetMsg(*snappipb.PatternFlowGtpv1MessageType) PatternFlowGtpv1MessageType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1MessageTypeChoiceEnum
	SetChoice(value PatternFlowGtpv1MessageTypeChoiceEnum) PatternFlowGtpv1MessageType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1MessageType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1MessageType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1MessageType
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1MessageTypeCounter
	SetIncrement(value PatternFlowGtpv1MessageTypeCounter) PatternFlowGtpv1MessageType
	HasIncrement() bool
	Decrement() PatternFlowGtpv1MessageTypeCounter
	SetDecrement(value PatternFlowGtpv1MessageTypeCounter) PatternFlowGtpv1MessageType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1MessageType added in v0.6.5 

func NewPatternFlowGtpv1MessageType() PatternFlowGtpv1MessageType

type PatternFlowGtpv1MessageTypeChoiceEnum 

type PatternFlowGtpv1MessageTypeChoiceEnum string

type PatternFlowGtpv1MessageTypeCounter 

type PatternFlowGtpv1MessageTypeCounter interface {
	Msg() *snappipb.PatternFlowGtpv1MessageTypeCounter
	SetMsg(*snappipb.PatternFlowGtpv1MessageTypeCounter) PatternFlowGtpv1MessageTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1MessageTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1MessageTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1MessageTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1MessageTypeCounter added in v0.6.5 

func NewPatternFlowGtpv1MessageTypeCounter() PatternFlowGtpv1MessageTypeCounter

type PatternFlowGtpv1NPduNumber 

type PatternFlowGtpv1NPduNumber interface {
	Msg() *snappipb.PatternFlowGtpv1NPduNumber
	SetMsg(*snappipb.PatternFlowGtpv1NPduNumber) PatternFlowGtpv1NPduNumber
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1NPduNumberChoiceEnum
	SetChoice(value PatternFlowGtpv1NPduNumberChoiceEnum) PatternFlowGtpv1NPduNumber
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1NPduNumber
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1NPduNumber
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1NPduNumber
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1NPduNumberCounter
	SetIncrement(value PatternFlowGtpv1NPduNumberCounter) PatternFlowGtpv1NPduNumber
	HasIncrement() bool
	Decrement() PatternFlowGtpv1NPduNumberCounter
	SetDecrement(value PatternFlowGtpv1NPduNumberCounter) PatternFlowGtpv1NPduNumber
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1NPduNumber added in v0.6.5 

func NewPatternFlowGtpv1NPduNumber() PatternFlowGtpv1NPduNumber

type PatternFlowGtpv1NPduNumberChoiceEnum 

type PatternFlowGtpv1NPduNumberChoiceEnum string

type PatternFlowGtpv1NPduNumberCounter 

type PatternFlowGtpv1NPduNumberCounter interface {
	Msg() *snappipb.PatternFlowGtpv1NPduNumberCounter
	SetMsg(*snappipb.PatternFlowGtpv1NPduNumberCounter) PatternFlowGtpv1NPduNumberCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1NPduNumberCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1NPduNumberCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1NPduNumberCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1NPduNumberCounter added in v0.6.5 

func NewPatternFlowGtpv1NPduNumberCounter() PatternFlowGtpv1NPduNumberCounter

type PatternFlowGtpv1NextExtensionHeaderType 

type PatternFlowGtpv1NextExtensionHeaderType interface {
	Msg() *snappipb.PatternFlowGtpv1NextExtensionHeaderType
	SetMsg(*snappipb.PatternFlowGtpv1NextExtensionHeaderType) PatternFlowGtpv1NextExtensionHeaderType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum
	SetChoice(value PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum) PatternFlowGtpv1NextExtensionHeaderType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1NextExtensionHeaderType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1NextExtensionHeaderType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1NextExtensionHeaderType
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1NextExtensionHeaderTypeCounter
	SetIncrement(value PatternFlowGtpv1NextExtensionHeaderTypeCounter) PatternFlowGtpv1NextExtensionHeaderType
	HasIncrement() bool
	Decrement() PatternFlowGtpv1NextExtensionHeaderTypeCounter
	SetDecrement(value PatternFlowGtpv1NextExtensionHeaderTypeCounter) PatternFlowGtpv1NextExtensionHeaderType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1NextExtensionHeaderType added in v0.6.5 

func NewPatternFlowGtpv1NextExtensionHeaderType() PatternFlowGtpv1NextExtensionHeaderType

type PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum 

type PatternFlowGtpv1NextExtensionHeaderTypeChoiceEnum string

type PatternFlowGtpv1NextExtensionHeaderTypeCounter 

type PatternFlowGtpv1NextExtensionHeaderTypeCounter interface {
	Msg() *snappipb.PatternFlowGtpv1NextExtensionHeaderTypeCounter
	SetMsg(*snappipb.PatternFlowGtpv1NextExtensionHeaderTypeCounter) PatternFlowGtpv1NextExtensionHeaderTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1NextExtensionHeaderTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1NextExtensionHeaderTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1NextExtensionHeaderTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1NextExtensionHeaderTypeCounter added in v0.6.5 

func NewPatternFlowGtpv1NextExtensionHeaderTypeCounter() PatternFlowGtpv1NextExtensionHeaderTypeCounter

type PatternFlowGtpv1PnFlag 

type PatternFlowGtpv1PnFlag interface {
	Msg() *snappipb.PatternFlowGtpv1PnFlag
	SetMsg(*snappipb.PatternFlowGtpv1PnFlag) PatternFlowGtpv1PnFlag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1PnFlagChoiceEnum
	SetChoice(value PatternFlowGtpv1PnFlagChoiceEnum) PatternFlowGtpv1PnFlag
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1PnFlag
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1PnFlag
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1PnFlag
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1PnFlagCounter
	SetIncrement(value PatternFlowGtpv1PnFlagCounter) PatternFlowGtpv1PnFlag
	HasIncrement() bool
	Decrement() PatternFlowGtpv1PnFlagCounter
	SetDecrement(value PatternFlowGtpv1PnFlagCounter) PatternFlowGtpv1PnFlag
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1PnFlag added in v0.6.5 

func NewPatternFlowGtpv1PnFlag() PatternFlowGtpv1PnFlag

type PatternFlowGtpv1PnFlagChoiceEnum 

type PatternFlowGtpv1PnFlagChoiceEnum string

type PatternFlowGtpv1PnFlagCounter 

type PatternFlowGtpv1PnFlagCounter interface {
	Msg() *snappipb.PatternFlowGtpv1PnFlagCounter
	SetMsg(*snappipb.PatternFlowGtpv1PnFlagCounter) PatternFlowGtpv1PnFlagCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1PnFlagCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1PnFlagCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1PnFlagCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1PnFlagCounter added in v0.6.5 

func NewPatternFlowGtpv1PnFlagCounter() PatternFlowGtpv1PnFlagCounter

type PatternFlowGtpv1ProtocolType 

type PatternFlowGtpv1ProtocolType interface {
	Msg() *snappipb.PatternFlowGtpv1ProtocolType
	SetMsg(*snappipb.PatternFlowGtpv1ProtocolType) PatternFlowGtpv1ProtocolType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1ProtocolTypeChoiceEnum
	SetChoice(value PatternFlowGtpv1ProtocolTypeChoiceEnum) PatternFlowGtpv1ProtocolType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1ProtocolType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1ProtocolType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1ProtocolType
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1ProtocolTypeCounter
	SetIncrement(value PatternFlowGtpv1ProtocolTypeCounter) PatternFlowGtpv1ProtocolType
	HasIncrement() bool
	Decrement() PatternFlowGtpv1ProtocolTypeCounter
	SetDecrement(value PatternFlowGtpv1ProtocolTypeCounter) PatternFlowGtpv1ProtocolType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1ProtocolType added in v0.6.5 

func NewPatternFlowGtpv1ProtocolType() PatternFlowGtpv1ProtocolType

type PatternFlowGtpv1ProtocolTypeChoiceEnum 

type PatternFlowGtpv1ProtocolTypeChoiceEnum string

type PatternFlowGtpv1ProtocolTypeCounter 

type PatternFlowGtpv1ProtocolTypeCounter interface {
	Msg() *snappipb.PatternFlowGtpv1ProtocolTypeCounter
	SetMsg(*snappipb.PatternFlowGtpv1ProtocolTypeCounter) PatternFlowGtpv1ProtocolTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1ProtocolTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1ProtocolTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1ProtocolTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1ProtocolTypeCounter added in v0.6.5 

func NewPatternFlowGtpv1ProtocolTypeCounter() PatternFlowGtpv1ProtocolTypeCounter

type PatternFlowGtpv1Reserved 

type PatternFlowGtpv1Reserved interface {
	Msg() *snappipb.PatternFlowGtpv1Reserved
	SetMsg(*snappipb.PatternFlowGtpv1Reserved) PatternFlowGtpv1Reserved
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1ReservedChoiceEnum
	SetChoice(value PatternFlowGtpv1ReservedChoiceEnum) PatternFlowGtpv1Reserved
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1Reserved
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1Reserved
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1Reserved
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1ReservedCounter
	SetIncrement(value PatternFlowGtpv1ReservedCounter) PatternFlowGtpv1Reserved
	HasIncrement() bool
	Decrement() PatternFlowGtpv1ReservedCounter
	SetDecrement(value PatternFlowGtpv1ReservedCounter) PatternFlowGtpv1Reserved
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1Reserved added in v0.6.5 

func NewPatternFlowGtpv1Reserved() PatternFlowGtpv1Reserved

type PatternFlowGtpv1ReservedChoiceEnum 

type PatternFlowGtpv1ReservedChoiceEnum string

type PatternFlowGtpv1ReservedCounter 

type PatternFlowGtpv1ReservedCounter interface {
	Msg() *snappipb.PatternFlowGtpv1ReservedCounter
	SetMsg(*snappipb.PatternFlowGtpv1ReservedCounter) PatternFlowGtpv1ReservedCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1ReservedCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1ReservedCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1ReservedCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1ReservedCounter added in v0.6.5 

func NewPatternFlowGtpv1ReservedCounter() PatternFlowGtpv1ReservedCounter

type PatternFlowGtpv1SFlag 

type PatternFlowGtpv1SFlag interface {
	Msg() *snappipb.PatternFlowGtpv1SFlag
	SetMsg(*snappipb.PatternFlowGtpv1SFlag) PatternFlowGtpv1SFlag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1SFlagChoiceEnum
	SetChoice(value PatternFlowGtpv1SFlagChoiceEnum) PatternFlowGtpv1SFlag
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1SFlag
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1SFlag
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1SFlag
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1SFlagCounter
	SetIncrement(value PatternFlowGtpv1SFlagCounter) PatternFlowGtpv1SFlag
	HasIncrement() bool
	Decrement() PatternFlowGtpv1SFlagCounter
	SetDecrement(value PatternFlowGtpv1SFlagCounter) PatternFlowGtpv1SFlag
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1SFlag added in v0.6.5 

func NewPatternFlowGtpv1SFlag() PatternFlowGtpv1SFlag

type PatternFlowGtpv1SFlagChoiceEnum 

type PatternFlowGtpv1SFlagChoiceEnum string

type PatternFlowGtpv1SFlagCounter 

type PatternFlowGtpv1SFlagCounter interface {
	Msg() *snappipb.PatternFlowGtpv1SFlagCounter
	SetMsg(*snappipb.PatternFlowGtpv1SFlagCounter) PatternFlowGtpv1SFlagCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1SFlagCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1SFlagCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1SFlagCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1SFlagCounter added in v0.6.5 

func NewPatternFlowGtpv1SFlagCounter() PatternFlowGtpv1SFlagCounter

type PatternFlowGtpv1SquenceNumber 

type PatternFlowGtpv1SquenceNumber interface {
	Msg() *snappipb.PatternFlowGtpv1SquenceNumber
	SetMsg(*snappipb.PatternFlowGtpv1SquenceNumber) PatternFlowGtpv1SquenceNumber
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1SquenceNumberChoiceEnum
	SetChoice(value PatternFlowGtpv1SquenceNumberChoiceEnum) PatternFlowGtpv1SquenceNumber
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1SquenceNumber
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1SquenceNumber
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1SquenceNumber
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1SquenceNumberCounter
	SetIncrement(value PatternFlowGtpv1SquenceNumberCounter) PatternFlowGtpv1SquenceNumber
	HasIncrement() bool
	Decrement() PatternFlowGtpv1SquenceNumberCounter
	SetDecrement(value PatternFlowGtpv1SquenceNumberCounter) PatternFlowGtpv1SquenceNumber
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1SquenceNumber added in v0.6.5 

func NewPatternFlowGtpv1SquenceNumber() PatternFlowGtpv1SquenceNumber

type PatternFlowGtpv1SquenceNumberChoiceEnum 

type PatternFlowGtpv1SquenceNumberChoiceEnum string

type PatternFlowGtpv1SquenceNumberCounter 

type PatternFlowGtpv1SquenceNumberCounter interface {
	Msg() *snappipb.PatternFlowGtpv1SquenceNumberCounter
	SetMsg(*snappipb.PatternFlowGtpv1SquenceNumberCounter) PatternFlowGtpv1SquenceNumberCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1SquenceNumberCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1SquenceNumberCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1SquenceNumberCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1SquenceNumberCounter added in v0.6.5 

func NewPatternFlowGtpv1SquenceNumberCounter() PatternFlowGtpv1SquenceNumberCounter

type PatternFlowGtpv1Teid 

type PatternFlowGtpv1Teid interface {
	Msg() *snappipb.PatternFlowGtpv1Teid
	SetMsg(*snappipb.PatternFlowGtpv1Teid) PatternFlowGtpv1Teid
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1TeidChoiceEnum
	SetChoice(value PatternFlowGtpv1TeidChoiceEnum) PatternFlowGtpv1Teid
	HasChoice() bool
	Value() int64
	SetValue(value int64) PatternFlowGtpv1Teid
	HasValue() bool
	Values() []int64
	SetValues(value []int64) PatternFlowGtpv1Teid
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1Teid
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1TeidCounter
	SetIncrement(value PatternFlowGtpv1TeidCounter) PatternFlowGtpv1Teid
	HasIncrement() bool
	Decrement() PatternFlowGtpv1TeidCounter
	SetDecrement(value PatternFlowGtpv1TeidCounter) PatternFlowGtpv1Teid
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1Teid added in v0.6.5 

func NewPatternFlowGtpv1Teid() PatternFlowGtpv1Teid

type PatternFlowGtpv1TeidChoiceEnum 

type PatternFlowGtpv1TeidChoiceEnum string

type PatternFlowGtpv1TeidCounter 

type PatternFlowGtpv1TeidCounter interface {
	Msg() *snappipb.PatternFlowGtpv1TeidCounter
	SetMsg(*snappipb.PatternFlowGtpv1TeidCounter) PatternFlowGtpv1TeidCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int64
	SetStart(value int64) PatternFlowGtpv1TeidCounter
	HasStart() bool
	Step() int64
	SetStep(value int64) PatternFlowGtpv1TeidCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1TeidCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1TeidCounter added in v0.6.5 

func NewPatternFlowGtpv1TeidCounter() PatternFlowGtpv1TeidCounter

type PatternFlowGtpv1Version 

type PatternFlowGtpv1Version interface {
	Msg() *snappipb.PatternFlowGtpv1Version
	SetMsg(*snappipb.PatternFlowGtpv1Version) PatternFlowGtpv1Version
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv1VersionChoiceEnum
	SetChoice(value PatternFlowGtpv1VersionChoiceEnum) PatternFlowGtpv1Version
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv1Version
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv1Version
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv1Version
	HasMetricGroup() bool
	Increment() PatternFlowGtpv1VersionCounter
	SetIncrement(value PatternFlowGtpv1VersionCounter) PatternFlowGtpv1Version
	HasIncrement() bool
	Decrement() PatternFlowGtpv1VersionCounter
	SetDecrement(value PatternFlowGtpv1VersionCounter) PatternFlowGtpv1Version
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1Version added in v0.6.5 

func NewPatternFlowGtpv1Version() PatternFlowGtpv1Version

type PatternFlowGtpv1VersionChoiceEnum 

type PatternFlowGtpv1VersionChoiceEnum string

type PatternFlowGtpv1VersionCounter 

type PatternFlowGtpv1VersionCounter interface {
	Msg() *snappipb.PatternFlowGtpv1VersionCounter
	SetMsg(*snappipb.PatternFlowGtpv1VersionCounter) PatternFlowGtpv1VersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv1VersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv1VersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv1VersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv1VersionCounter added in v0.6.5 

func NewPatternFlowGtpv1VersionCounter() PatternFlowGtpv1VersionCounter

type PatternFlowGtpv2MessageLength 

type PatternFlowGtpv2MessageLength interface {
	Msg() *snappipb.PatternFlowGtpv2MessageLength
	SetMsg(*snappipb.PatternFlowGtpv2MessageLength) PatternFlowGtpv2MessageLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2MessageLengthChoiceEnum
	SetChoice(value PatternFlowGtpv2MessageLengthChoiceEnum) PatternFlowGtpv2MessageLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2MessageLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2MessageLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2MessageLength
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2MessageLengthCounter
	SetIncrement(value PatternFlowGtpv2MessageLengthCounter) PatternFlowGtpv2MessageLength
	HasIncrement() bool
	Decrement() PatternFlowGtpv2MessageLengthCounter
	SetDecrement(value PatternFlowGtpv2MessageLengthCounter) PatternFlowGtpv2MessageLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2MessageLength added in v0.6.5 

func NewPatternFlowGtpv2MessageLength() PatternFlowGtpv2MessageLength

type PatternFlowGtpv2MessageLengthChoiceEnum 

type PatternFlowGtpv2MessageLengthChoiceEnum string

type PatternFlowGtpv2MessageLengthCounter 

type PatternFlowGtpv2MessageLengthCounter interface {
	Msg() *snappipb.PatternFlowGtpv2MessageLengthCounter
	SetMsg(*snappipb.PatternFlowGtpv2MessageLengthCounter) PatternFlowGtpv2MessageLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2MessageLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2MessageLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2MessageLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2MessageLengthCounter added in v0.6.5 

func NewPatternFlowGtpv2MessageLengthCounter() PatternFlowGtpv2MessageLengthCounter

type PatternFlowGtpv2MessageType 

type PatternFlowGtpv2MessageType interface {
	Msg() *snappipb.PatternFlowGtpv2MessageType
	SetMsg(*snappipb.PatternFlowGtpv2MessageType) PatternFlowGtpv2MessageType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2MessageTypeChoiceEnum
	SetChoice(value PatternFlowGtpv2MessageTypeChoiceEnum) PatternFlowGtpv2MessageType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2MessageType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2MessageType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2MessageType
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2MessageTypeCounter
	SetIncrement(value PatternFlowGtpv2MessageTypeCounter) PatternFlowGtpv2MessageType
	HasIncrement() bool
	Decrement() PatternFlowGtpv2MessageTypeCounter
	SetDecrement(value PatternFlowGtpv2MessageTypeCounter) PatternFlowGtpv2MessageType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2MessageType added in v0.6.5 

func NewPatternFlowGtpv2MessageType() PatternFlowGtpv2MessageType

type PatternFlowGtpv2MessageTypeChoiceEnum 

type PatternFlowGtpv2MessageTypeChoiceEnum string

type PatternFlowGtpv2MessageTypeCounter 

type PatternFlowGtpv2MessageTypeCounter interface {
	Msg() *snappipb.PatternFlowGtpv2MessageTypeCounter
	SetMsg(*snappipb.PatternFlowGtpv2MessageTypeCounter) PatternFlowGtpv2MessageTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2MessageTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2MessageTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2MessageTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2MessageTypeCounter added in v0.6.5 

func NewPatternFlowGtpv2MessageTypeCounter() PatternFlowGtpv2MessageTypeCounter

type PatternFlowGtpv2PiggybackingFlag 

type PatternFlowGtpv2PiggybackingFlag interface {
	Msg() *snappipb.PatternFlowGtpv2PiggybackingFlag
	SetMsg(*snappipb.PatternFlowGtpv2PiggybackingFlag) PatternFlowGtpv2PiggybackingFlag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2PiggybackingFlagChoiceEnum
	SetChoice(value PatternFlowGtpv2PiggybackingFlagChoiceEnum) PatternFlowGtpv2PiggybackingFlag
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2PiggybackingFlag
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2PiggybackingFlag
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2PiggybackingFlag
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2PiggybackingFlagCounter
	SetIncrement(value PatternFlowGtpv2PiggybackingFlagCounter) PatternFlowGtpv2PiggybackingFlag
	HasIncrement() bool
	Decrement() PatternFlowGtpv2PiggybackingFlagCounter
	SetDecrement(value PatternFlowGtpv2PiggybackingFlagCounter) PatternFlowGtpv2PiggybackingFlag
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2PiggybackingFlag added in v0.6.5 

func NewPatternFlowGtpv2PiggybackingFlag() PatternFlowGtpv2PiggybackingFlag

type PatternFlowGtpv2PiggybackingFlagChoiceEnum 

type PatternFlowGtpv2PiggybackingFlagChoiceEnum string

type PatternFlowGtpv2PiggybackingFlagCounter 

type PatternFlowGtpv2PiggybackingFlagCounter interface {
	Msg() *snappipb.PatternFlowGtpv2PiggybackingFlagCounter
	SetMsg(*snappipb.PatternFlowGtpv2PiggybackingFlagCounter) PatternFlowGtpv2PiggybackingFlagCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2PiggybackingFlagCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2PiggybackingFlagCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2PiggybackingFlagCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2PiggybackingFlagCounter added in v0.6.5 

func NewPatternFlowGtpv2PiggybackingFlagCounter() PatternFlowGtpv2PiggybackingFlagCounter

type PatternFlowGtpv2SequenceNumber 

type PatternFlowGtpv2SequenceNumber interface {
	Msg() *snappipb.PatternFlowGtpv2SequenceNumber
	SetMsg(*snappipb.PatternFlowGtpv2SequenceNumber) PatternFlowGtpv2SequenceNumber
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2SequenceNumberChoiceEnum
	SetChoice(value PatternFlowGtpv2SequenceNumberChoiceEnum) PatternFlowGtpv2SequenceNumber
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2SequenceNumber
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2SequenceNumber
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2SequenceNumber
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2SequenceNumberCounter
	SetIncrement(value PatternFlowGtpv2SequenceNumberCounter) PatternFlowGtpv2SequenceNumber
	HasIncrement() bool
	Decrement() PatternFlowGtpv2SequenceNumberCounter
	SetDecrement(value PatternFlowGtpv2SequenceNumberCounter) PatternFlowGtpv2SequenceNumber
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2SequenceNumber added in v0.6.5 

func NewPatternFlowGtpv2SequenceNumber() PatternFlowGtpv2SequenceNumber

type PatternFlowGtpv2SequenceNumberChoiceEnum 

type PatternFlowGtpv2SequenceNumberChoiceEnum string

type PatternFlowGtpv2SequenceNumberCounter 

type PatternFlowGtpv2SequenceNumberCounter interface {
	Msg() *snappipb.PatternFlowGtpv2SequenceNumberCounter
	SetMsg(*snappipb.PatternFlowGtpv2SequenceNumberCounter) PatternFlowGtpv2SequenceNumberCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2SequenceNumberCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2SequenceNumberCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2SequenceNumberCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2SequenceNumberCounter added in v0.6.5 

func NewPatternFlowGtpv2SequenceNumberCounter() PatternFlowGtpv2SequenceNumberCounter

type PatternFlowGtpv2Spare1 

type PatternFlowGtpv2Spare1 interface {
	Msg() *snappipb.PatternFlowGtpv2Spare1
	SetMsg(*snappipb.PatternFlowGtpv2Spare1) PatternFlowGtpv2Spare1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2Spare1ChoiceEnum
	SetChoice(value PatternFlowGtpv2Spare1ChoiceEnum) PatternFlowGtpv2Spare1
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2Spare1
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2Spare1
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2Spare1
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2Spare1Counter
	SetIncrement(value PatternFlowGtpv2Spare1Counter) PatternFlowGtpv2Spare1
	HasIncrement() bool
	Decrement() PatternFlowGtpv2Spare1Counter
	SetDecrement(value PatternFlowGtpv2Spare1Counter) PatternFlowGtpv2Spare1
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Spare1 added in v0.6.5 

func NewPatternFlowGtpv2Spare1() PatternFlowGtpv2Spare1

type PatternFlowGtpv2Spare1ChoiceEnum 

type PatternFlowGtpv2Spare1ChoiceEnum string

type PatternFlowGtpv2Spare1Counter 

type PatternFlowGtpv2Spare1Counter interface {
	Msg() *snappipb.PatternFlowGtpv2Spare1Counter
	SetMsg(*snappipb.PatternFlowGtpv2Spare1Counter) PatternFlowGtpv2Spare1Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2Spare1Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2Spare1Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2Spare1Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Spare1Counter added in v0.6.5 

func NewPatternFlowGtpv2Spare1Counter() PatternFlowGtpv2Spare1Counter

type PatternFlowGtpv2Spare2 

type PatternFlowGtpv2Spare2 interface {
	Msg() *snappipb.PatternFlowGtpv2Spare2
	SetMsg(*snappipb.PatternFlowGtpv2Spare2) PatternFlowGtpv2Spare2
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2Spare2ChoiceEnum
	SetChoice(value PatternFlowGtpv2Spare2ChoiceEnum) PatternFlowGtpv2Spare2
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2Spare2
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2Spare2
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2Spare2
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2Spare2Counter
	SetIncrement(value PatternFlowGtpv2Spare2Counter) PatternFlowGtpv2Spare2
	HasIncrement() bool
	Decrement() PatternFlowGtpv2Spare2Counter
	SetDecrement(value PatternFlowGtpv2Spare2Counter) PatternFlowGtpv2Spare2
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Spare2 added in v0.6.5 

func NewPatternFlowGtpv2Spare2() PatternFlowGtpv2Spare2

type PatternFlowGtpv2Spare2ChoiceEnum 

type PatternFlowGtpv2Spare2ChoiceEnum string

type PatternFlowGtpv2Spare2Counter 

type PatternFlowGtpv2Spare2Counter interface {
	Msg() *snappipb.PatternFlowGtpv2Spare2Counter
	SetMsg(*snappipb.PatternFlowGtpv2Spare2Counter) PatternFlowGtpv2Spare2Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2Spare2Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2Spare2Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2Spare2Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Spare2Counter added in v0.6.5 

func NewPatternFlowGtpv2Spare2Counter() PatternFlowGtpv2Spare2Counter

type PatternFlowGtpv2Teid 

type PatternFlowGtpv2Teid interface {
	Msg() *snappipb.PatternFlowGtpv2Teid
	SetMsg(*snappipb.PatternFlowGtpv2Teid) PatternFlowGtpv2Teid
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2TeidChoiceEnum
	SetChoice(value PatternFlowGtpv2TeidChoiceEnum) PatternFlowGtpv2Teid
	HasChoice() bool
	Value() int64
	SetValue(value int64) PatternFlowGtpv2Teid
	HasValue() bool
	Values() []int64
	SetValues(value []int64) PatternFlowGtpv2Teid
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2Teid
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2TeidCounter
	SetIncrement(value PatternFlowGtpv2TeidCounter) PatternFlowGtpv2Teid
	HasIncrement() bool
	Decrement() PatternFlowGtpv2TeidCounter
	SetDecrement(value PatternFlowGtpv2TeidCounter) PatternFlowGtpv2Teid
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Teid added in v0.6.5 

func NewPatternFlowGtpv2Teid() PatternFlowGtpv2Teid

type PatternFlowGtpv2TeidChoiceEnum 

type PatternFlowGtpv2TeidChoiceEnum string

type PatternFlowGtpv2TeidCounter 

type PatternFlowGtpv2TeidCounter interface {
	Msg() *snappipb.PatternFlowGtpv2TeidCounter
	SetMsg(*snappipb.PatternFlowGtpv2TeidCounter) PatternFlowGtpv2TeidCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int64
	SetStart(value int64) PatternFlowGtpv2TeidCounter
	HasStart() bool
	Step() int64
	SetStep(value int64) PatternFlowGtpv2TeidCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2TeidCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2TeidCounter added in v0.6.5 

func NewPatternFlowGtpv2TeidCounter() PatternFlowGtpv2TeidCounter

type PatternFlowGtpv2TeidFlag 

type PatternFlowGtpv2TeidFlag interface {
	Msg() *snappipb.PatternFlowGtpv2TeidFlag
	SetMsg(*snappipb.PatternFlowGtpv2TeidFlag) PatternFlowGtpv2TeidFlag
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2TeidFlagChoiceEnum
	SetChoice(value PatternFlowGtpv2TeidFlagChoiceEnum) PatternFlowGtpv2TeidFlag
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2TeidFlag
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2TeidFlag
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2TeidFlag
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2TeidFlagCounter
	SetIncrement(value PatternFlowGtpv2TeidFlagCounter) PatternFlowGtpv2TeidFlag
	HasIncrement() bool
	Decrement() PatternFlowGtpv2TeidFlagCounter
	SetDecrement(value PatternFlowGtpv2TeidFlagCounter) PatternFlowGtpv2TeidFlag
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2TeidFlag added in v0.6.5 

func NewPatternFlowGtpv2TeidFlag() PatternFlowGtpv2TeidFlag

type PatternFlowGtpv2TeidFlagChoiceEnum 

type PatternFlowGtpv2TeidFlagChoiceEnum string

type PatternFlowGtpv2TeidFlagCounter 

type PatternFlowGtpv2TeidFlagCounter interface {
	Msg() *snappipb.PatternFlowGtpv2TeidFlagCounter
	SetMsg(*snappipb.PatternFlowGtpv2TeidFlagCounter) PatternFlowGtpv2TeidFlagCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2TeidFlagCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2TeidFlagCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2TeidFlagCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2TeidFlagCounter added in v0.6.5 

func NewPatternFlowGtpv2TeidFlagCounter() PatternFlowGtpv2TeidFlagCounter

type PatternFlowGtpv2Version 

type PatternFlowGtpv2Version interface {
	Msg() *snappipb.PatternFlowGtpv2Version
	SetMsg(*snappipb.PatternFlowGtpv2Version) PatternFlowGtpv2Version
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowGtpv2VersionChoiceEnum
	SetChoice(value PatternFlowGtpv2VersionChoiceEnum) PatternFlowGtpv2Version
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowGtpv2Version
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowGtpv2Version
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowGtpv2Version
	HasMetricGroup() bool
	Increment() PatternFlowGtpv2VersionCounter
	SetIncrement(value PatternFlowGtpv2VersionCounter) PatternFlowGtpv2Version
	HasIncrement() bool
	Decrement() PatternFlowGtpv2VersionCounter
	SetDecrement(value PatternFlowGtpv2VersionCounter) PatternFlowGtpv2Version
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2Version added in v0.6.5 

func NewPatternFlowGtpv2Version() PatternFlowGtpv2Version

type PatternFlowGtpv2VersionChoiceEnum 

type PatternFlowGtpv2VersionChoiceEnum string

type PatternFlowGtpv2VersionCounter 

type PatternFlowGtpv2VersionCounter interface {
	Msg() *snappipb.PatternFlowGtpv2VersionCounter
	SetMsg(*snappipb.PatternFlowGtpv2VersionCounter) PatternFlowGtpv2VersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowGtpv2VersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowGtpv2VersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowGtpv2VersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowGtpv2VersionCounter added in v0.6.5 

func NewPatternFlowGtpv2VersionCounter() PatternFlowGtpv2VersionCounter

type PatternFlowIcmpEchoChecksum 

type PatternFlowIcmpEchoChecksum interface {
	Msg() *snappipb.PatternFlowIcmpEchoChecksum
	SetMsg(*snappipb.PatternFlowIcmpEchoChecksum) PatternFlowIcmpEchoChecksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpEchoChecksumChoiceEnum
	SetChoice(value PatternFlowIcmpEchoChecksumChoiceEnum) PatternFlowIcmpEchoChecksum
	Generated() PatternFlowIcmpEchoChecksumGeneratedEnum
	SetGenerated(value PatternFlowIcmpEchoChecksumGeneratedEnum) PatternFlowIcmpEchoChecksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowIcmpEchoChecksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoChecksum added in v0.6.5 

func NewPatternFlowIcmpEchoChecksum() PatternFlowIcmpEchoChecksum

type PatternFlowIcmpEchoChecksumChoiceEnum 

type PatternFlowIcmpEchoChecksumChoiceEnum string

type PatternFlowIcmpEchoChecksumGeneratedEnum 

type PatternFlowIcmpEchoChecksumGeneratedEnum string

type PatternFlowIcmpEchoCode 

type PatternFlowIcmpEchoCode interface {
	Msg() *snappipb.PatternFlowIcmpEchoCode
	SetMsg(*snappipb.PatternFlowIcmpEchoCode) PatternFlowIcmpEchoCode
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpEchoCodeChoiceEnum
	SetChoice(value PatternFlowIcmpEchoCodeChoiceEnum) PatternFlowIcmpEchoCode
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpEchoCode
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpEchoCode
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpEchoCode
	HasMetricGroup() bool
	Increment() PatternFlowIcmpEchoCodeCounter
	SetIncrement(value PatternFlowIcmpEchoCodeCounter) PatternFlowIcmpEchoCode
	HasIncrement() bool
	Decrement() PatternFlowIcmpEchoCodeCounter
	SetDecrement(value PatternFlowIcmpEchoCodeCounter) PatternFlowIcmpEchoCode
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoCode added in v0.6.5 

func NewPatternFlowIcmpEchoCode() PatternFlowIcmpEchoCode

type PatternFlowIcmpEchoCodeChoiceEnum 

type PatternFlowIcmpEchoCodeChoiceEnum string

type PatternFlowIcmpEchoCodeCounter 

type PatternFlowIcmpEchoCodeCounter interface {
	Msg() *snappipb.PatternFlowIcmpEchoCodeCounter
	SetMsg(*snappipb.PatternFlowIcmpEchoCodeCounter) PatternFlowIcmpEchoCodeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpEchoCodeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpEchoCodeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpEchoCodeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoCodeCounter added in v0.6.5 

func NewPatternFlowIcmpEchoCodeCounter() PatternFlowIcmpEchoCodeCounter

type PatternFlowIcmpEchoIdentifier 

type PatternFlowIcmpEchoIdentifier interface {
	Msg() *snappipb.PatternFlowIcmpEchoIdentifier
	SetMsg(*snappipb.PatternFlowIcmpEchoIdentifier) PatternFlowIcmpEchoIdentifier
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpEchoIdentifierChoiceEnum
	SetChoice(value PatternFlowIcmpEchoIdentifierChoiceEnum) PatternFlowIcmpEchoIdentifier
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpEchoIdentifier
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpEchoIdentifier
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpEchoIdentifier
	HasMetricGroup() bool
	Increment() PatternFlowIcmpEchoIdentifierCounter
	SetIncrement(value PatternFlowIcmpEchoIdentifierCounter) PatternFlowIcmpEchoIdentifier
	HasIncrement() bool
	Decrement() PatternFlowIcmpEchoIdentifierCounter
	SetDecrement(value PatternFlowIcmpEchoIdentifierCounter) PatternFlowIcmpEchoIdentifier
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoIdentifier added in v0.6.5 

func NewPatternFlowIcmpEchoIdentifier() PatternFlowIcmpEchoIdentifier

type PatternFlowIcmpEchoIdentifierChoiceEnum 

type PatternFlowIcmpEchoIdentifierChoiceEnum string

type PatternFlowIcmpEchoIdentifierCounter 

type PatternFlowIcmpEchoIdentifierCounter interface {
	Msg() *snappipb.PatternFlowIcmpEchoIdentifierCounter
	SetMsg(*snappipb.PatternFlowIcmpEchoIdentifierCounter) PatternFlowIcmpEchoIdentifierCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpEchoIdentifierCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpEchoIdentifierCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpEchoIdentifierCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoIdentifierCounter added in v0.6.5 

func NewPatternFlowIcmpEchoIdentifierCounter() PatternFlowIcmpEchoIdentifierCounter

type PatternFlowIcmpEchoSequenceNumber 

type PatternFlowIcmpEchoSequenceNumber interface {
	Msg() *snappipb.PatternFlowIcmpEchoSequenceNumber
	SetMsg(*snappipb.PatternFlowIcmpEchoSequenceNumber) PatternFlowIcmpEchoSequenceNumber
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpEchoSequenceNumberChoiceEnum
	SetChoice(value PatternFlowIcmpEchoSequenceNumberChoiceEnum) PatternFlowIcmpEchoSequenceNumber
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpEchoSequenceNumber
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpEchoSequenceNumber
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpEchoSequenceNumber
	HasMetricGroup() bool
	Increment() PatternFlowIcmpEchoSequenceNumberCounter
	SetIncrement(value PatternFlowIcmpEchoSequenceNumberCounter) PatternFlowIcmpEchoSequenceNumber
	HasIncrement() bool
	Decrement() PatternFlowIcmpEchoSequenceNumberCounter
	SetDecrement(value PatternFlowIcmpEchoSequenceNumberCounter) PatternFlowIcmpEchoSequenceNumber
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoSequenceNumber added in v0.6.5 

func NewPatternFlowIcmpEchoSequenceNumber() PatternFlowIcmpEchoSequenceNumber

type PatternFlowIcmpEchoSequenceNumberChoiceEnum 

type PatternFlowIcmpEchoSequenceNumberChoiceEnum string

type PatternFlowIcmpEchoSequenceNumberCounter 

type PatternFlowIcmpEchoSequenceNumberCounter interface {
	Msg() *snappipb.PatternFlowIcmpEchoSequenceNumberCounter
	SetMsg(*snappipb.PatternFlowIcmpEchoSequenceNumberCounter) PatternFlowIcmpEchoSequenceNumberCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpEchoSequenceNumberCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpEchoSequenceNumberCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpEchoSequenceNumberCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoSequenceNumberCounter added in v0.6.5 

func NewPatternFlowIcmpEchoSequenceNumberCounter() PatternFlowIcmpEchoSequenceNumberCounter

type PatternFlowIcmpEchoType 

type PatternFlowIcmpEchoType interface {
	Msg() *snappipb.PatternFlowIcmpEchoType
	SetMsg(*snappipb.PatternFlowIcmpEchoType) PatternFlowIcmpEchoType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpEchoTypeChoiceEnum
	SetChoice(value PatternFlowIcmpEchoTypeChoiceEnum) PatternFlowIcmpEchoType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpEchoType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpEchoType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpEchoType
	HasMetricGroup() bool
	Increment() PatternFlowIcmpEchoTypeCounter
	SetIncrement(value PatternFlowIcmpEchoTypeCounter) PatternFlowIcmpEchoType
	HasIncrement() bool
	Decrement() PatternFlowIcmpEchoTypeCounter
	SetDecrement(value PatternFlowIcmpEchoTypeCounter) PatternFlowIcmpEchoType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoType added in v0.6.5 

func NewPatternFlowIcmpEchoType() PatternFlowIcmpEchoType

type PatternFlowIcmpEchoTypeChoiceEnum 

type PatternFlowIcmpEchoTypeChoiceEnum string

type PatternFlowIcmpEchoTypeCounter 

type PatternFlowIcmpEchoTypeCounter interface {
	Msg() *snappipb.PatternFlowIcmpEchoTypeCounter
	SetMsg(*snappipb.PatternFlowIcmpEchoTypeCounter) PatternFlowIcmpEchoTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpEchoTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpEchoTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpEchoTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpEchoTypeCounter added in v0.6.5 

func NewPatternFlowIcmpEchoTypeCounter() PatternFlowIcmpEchoTypeCounter

type PatternFlowIcmpv6EchoChecksum 

type PatternFlowIcmpv6EchoChecksum interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoChecksum
	SetMsg(*snappipb.PatternFlowIcmpv6EchoChecksum) PatternFlowIcmpv6EchoChecksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpv6EchoChecksumChoiceEnum
	SetChoice(value PatternFlowIcmpv6EchoChecksumChoiceEnum) PatternFlowIcmpv6EchoChecksum
	Generated() PatternFlowIcmpv6EchoChecksumGeneratedEnum
	SetGenerated(value PatternFlowIcmpv6EchoChecksumGeneratedEnum) PatternFlowIcmpv6EchoChecksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowIcmpv6EchoChecksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoChecksum added in v0.6.5 

func NewPatternFlowIcmpv6EchoChecksum() PatternFlowIcmpv6EchoChecksum

type PatternFlowIcmpv6EchoChecksumChoiceEnum 

type PatternFlowIcmpv6EchoChecksumChoiceEnum string

type PatternFlowIcmpv6EchoChecksumGeneratedEnum 

type PatternFlowIcmpv6EchoChecksumGeneratedEnum string

type PatternFlowIcmpv6EchoCode 

type PatternFlowIcmpv6EchoCode interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoCode
	SetMsg(*snappipb.PatternFlowIcmpv6EchoCode) PatternFlowIcmpv6EchoCode
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpv6EchoCodeChoiceEnum
	SetChoice(value PatternFlowIcmpv6EchoCodeChoiceEnum) PatternFlowIcmpv6EchoCode
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpv6EchoCode
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpv6EchoCode
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpv6EchoCode
	HasMetricGroup() bool
	Increment() PatternFlowIcmpv6EchoCodeCounter
	SetIncrement(value PatternFlowIcmpv6EchoCodeCounter) PatternFlowIcmpv6EchoCode
	HasIncrement() bool
	Decrement() PatternFlowIcmpv6EchoCodeCounter
	SetDecrement(value PatternFlowIcmpv6EchoCodeCounter) PatternFlowIcmpv6EchoCode
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoCode added in v0.6.5 

func NewPatternFlowIcmpv6EchoCode() PatternFlowIcmpv6EchoCode

type PatternFlowIcmpv6EchoCodeChoiceEnum 

type PatternFlowIcmpv6EchoCodeChoiceEnum string

type PatternFlowIcmpv6EchoCodeCounter 

type PatternFlowIcmpv6EchoCodeCounter interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoCodeCounter
	SetMsg(*snappipb.PatternFlowIcmpv6EchoCodeCounter) PatternFlowIcmpv6EchoCodeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpv6EchoCodeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpv6EchoCodeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpv6EchoCodeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoCodeCounter added in v0.6.5 

func NewPatternFlowIcmpv6EchoCodeCounter() PatternFlowIcmpv6EchoCodeCounter

type PatternFlowIcmpv6EchoIdentifier 

type PatternFlowIcmpv6EchoIdentifier interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoIdentifier
	SetMsg(*snappipb.PatternFlowIcmpv6EchoIdentifier) PatternFlowIcmpv6EchoIdentifier
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpv6EchoIdentifierChoiceEnum
	SetChoice(value PatternFlowIcmpv6EchoIdentifierChoiceEnum) PatternFlowIcmpv6EchoIdentifier
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpv6EchoIdentifier
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpv6EchoIdentifier
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpv6EchoIdentifier
	HasMetricGroup() bool
	Increment() PatternFlowIcmpv6EchoIdentifierCounter
	SetIncrement(value PatternFlowIcmpv6EchoIdentifierCounter) PatternFlowIcmpv6EchoIdentifier
	HasIncrement() bool
	Decrement() PatternFlowIcmpv6EchoIdentifierCounter
	SetDecrement(value PatternFlowIcmpv6EchoIdentifierCounter) PatternFlowIcmpv6EchoIdentifier
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoIdentifier added in v0.6.5 

func NewPatternFlowIcmpv6EchoIdentifier() PatternFlowIcmpv6EchoIdentifier

type PatternFlowIcmpv6EchoIdentifierChoiceEnum 

type PatternFlowIcmpv6EchoIdentifierChoiceEnum string

type PatternFlowIcmpv6EchoIdentifierCounter 

type PatternFlowIcmpv6EchoIdentifierCounter interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoIdentifierCounter
	SetMsg(*snappipb.PatternFlowIcmpv6EchoIdentifierCounter) PatternFlowIcmpv6EchoIdentifierCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpv6EchoIdentifierCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpv6EchoIdentifierCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpv6EchoIdentifierCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoIdentifierCounter added in v0.6.5 

func NewPatternFlowIcmpv6EchoIdentifierCounter() PatternFlowIcmpv6EchoIdentifierCounter

type PatternFlowIcmpv6EchoSequenceNumber 

type PatternFlowIcmpv6EchoSequenceNumber interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoSequenceNumber
	SetMsg(*snappipb.PatternFlowIcmpv6EchoSequenceNumber) PatternFlowIcmpv6EchoSequenceNumber
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpv6EchoSequenceNumberChoiceEnum
	SetChoice(value PatternFlowIcmpv6EchoSequenceNumberChoiceEnum) PatternFlowIcmpv6EchoSequenceNumber
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpv6EchoSequenceNumber
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpv6EchoSequenceNumber
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpv6EchoSequenceNumber
	HasMetricGroup() bool
	Increment() PatternFlowIcmpv6EchoSequenceNumberCounter
	SetIncrement(value PatternFlowIcmpv6EchoSequenceNumberCounter) PatternFlowIcmpv6EchoSequenceNumber
	HasIncrement() bool
	Decrement() PatternFlowIcmpv6EchoSequenceNumberCounter
	SetDecrement(value PatternFlowIcmpv6EchoSequenceNumberCounter) PatternFlowIcmpv6EchoSequenceNumber
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoSequenceNumber added in v0.6.5 

func NewPatternFlowIcmpv6EchoSequenceNumber() PatternFlowIcmpv6EchoSequenceNumber

type PatternFlowIcmpv6EchoSequenceNumberChoiceEnum 

type PatternFlowIcmpv6EchoSequenceNumberChoiceEnum string

type PatternFlowIcmpv6EchoSequenceNumberCounter 

type PatternFlowIcmpv6EchoSequenceNumberCounter interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoSequenceNumberCounter
	SetMsg(*snappipb.PatternFlowIcmpv6EchoSequenceNumberCounter) PatternFlowIcmpv6EchoSequenceNumberCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpv6EchoSequenceNumberCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpv6EchoSequenceNumberCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpv6EchoSequenceNumberCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoSequenceNumberCounter added in v0.6.5 

func NewPatternFlowIcmpv6EchoSequenceNumberCounter() PatternFlowIcmpv6EchoSequenceNumberCounter

type PatternFlowIcmpv6EchoType 

type PatternFlowIcmpv6EchoType interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoType
	SetMsg(*snappipb.PatternFlowIcmpv6EchoType) PatternFlowIcmpv6EchoType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIcmpv6EchoTypeChoiceEnum
	SetChoice(value PatternFlowIcmpv6EchoTypeChoiceEnum) PatternFlowIcmpv6EchoType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIcmpv6EchoType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIcmpv6EchoType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIcmpv6EchoType
	HasMetricGroup() bool
	Increment() PatternFlowIcmpv6EchoTypeCounter
	SetIncrement(value PatternFlowIcmpv6EchoTypeCounter) PatternFlowIcmpv6EchoType
	HasIncrement() bool
	Decrement() PatternFlowIcmpv6EchoTypeCounter
	SetDecrement(value PatternFlowIcmpv6EchoTypeCounter) PatternFlowIcmpv6EchoType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoType added in v0.6.5 

func NewPatternFlowIcmpv6EchoType() PatternFlowIcmpv6EchoType

type PatternFlowIcmpv6EchoTypeChoiceEnum 

type PatternFlowIcmpv6EchoTypeChoiceEnum string

type PatternFlowIcmpv6EchoTypeCounter 

type PatternFlowIcmpv6EchoTypeCounter interface {
	Msg() *snappipb.PatternFlowIcmpv6EchoTypeCounter
	SetMsg(*snappipb.PatternFlowIcmpv6EchoTypeCounter) PatternFlowIcmpv6EchoTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIcmpv6EchoTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIcmpv6EchoTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIcmpv6EchoTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIcmpv6EchoTypeCounter added in v0.6.5 

func NewPatternFlowIcmpv6EchoTypeCounter() PatternFlowIcmpv6EchoTypeCounter

type PatternFlowIgmpv1Checksum 

type PatternFlowIgmpv1Checksum interface {
	Msg() *snappipb.PatternFlowIgmpv1Checksum
	SetMsg(*snappipb.PatternFlowIgmpv1Checksum) PatternFlowIgmpv1Checksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIgmpv1ChecksumChoiceEnum
	SetChoice(value PatternFlowIgmpv1ChecksumChoiceEnum) PatternFlowIgmpv1Checksum
	Generated() PatternFlowIgmpv1ChecksumGeneratedEnum
	SetGenerated(value PatternFlowIgmpv1ChecksumGeneratedEnum) PatternFlowIgmpv1Checksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowIgmpv1Checksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1Checksum added in v0.6.5 

func NewPatternFlowIgmpv1Checksum() PatternFlowIgmpv1Checksum

type PatternFlowIgmpv1ChecksumChoiceEnum 

type PatternFlowIgmpv1ChecksumChoiceEnum string

type PatternFlowIgmpv1ChecksumGeneratedEnum 

type PatternFlowIgmpv1ChecksumGeneratedEnum string

type PatternFlowIgmpv1GroupAddress 

type PatternFlowIgmpv1GroupAddress interface {
	Msg() *snappipb.PatternFlowIgmpv1GroupAddress
	SetMsg(*snappipb.PatternFlowIgmpv1GroupAddress) PatternFlowIgmpv1GroupAddress
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIgmpv1GroupAddressChoiceEnum
	SetChoice(value PatternFlowIgmpv1GroupAddressChoiceEnum) PatternFlowIgmpv1GroupAddress
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowIgmpv1GroupAddress
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowIgmpv1GroupAddress
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIgmpv1GroupAddress
	HasMetricGroup() bool
	Increment() PatternFlowIgmpv1GroupAddressCounter
	SetIncrement(value PatternFlowIgmpv1GroupAddressCounter) PatternFlowIgmpv1GroupAddress
	HasIncrement() bool
	Decrement() PatternFlowIgmpv1GroupAddressCounter
	SetDecrement(value PatternFlowIgmpv1GroupAddressCounter) PatternFlowIgmpv1GroupAddress
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1GroupAddress added in v0.6.5 

func NewPatternFlowIgmpv1GroupAddress() PatternFlowIgmpv1GroupAddress

type PatternFlowIgmpv1GroupAddressChoiceEnum 

type PatternFlowIgmpv1GroupAddressChoiceEnum string

type PatternFlowIgmpv1GroupAddressCounter 

type PatternFlowIgmpv1GroupAddressCounter interface {
	Msg() *snappipb.PatternFlowIgmpv1GroupAddressCounter
	SetMsg(*snappipb.PatternFlowIgmpv1GroupAddressCounter) PatternFlowIgmpv1GroupAddressCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowIgmpv1GroupAddressCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowIgmpv1GroupAddressCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIgmpv1GroupAddressCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1GroupAddressCounter added in v0.6.5 

func NewPatternFlowIgmpv1GroupAddressCounter() PatternFlowIgmpv1GroupAddressCounter

type PatternFlowIgmpv1Type 

type PatternFlowIgmpv1Type interface {
	Msg() *snappipb.PatternFlowIgmpv1Type
	SetMsg(*snappipb.PatternFlowIgmpv1Type) PatternFlowIgmpv1Type
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIgmpv1TypeChoiceEnum
	SetChoice(value PatternFlowIgmpv1TypeChoiceEnum) PatternFlowIgmpv1Type
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIgmpv1Type
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIgmpv1Type
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIgmpv1Type
	HasMetricGroup() bool
	Increment() PatternFlowIgmpv1TypeCounter
	SetIncrement(value PatternFlowIgmpv1TypeCounter) PatternFlowIgmpv1Type
	HasIncrement() bool
	Decrement() PatternFlowIgmpv1TypeCounter
	SetDecrement(value PatternFlowIgmpv1TypeCounter) PatternFlowIgmpv1Type
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1Type added in v0.6.5 

func NewPatternFlowIgmpv1Type() PatternFlowIgmpv1Type

type PatternFlowIgmpv1TypeChoiceEnum 

type PatternFlowIgmpv1TypeChoiceEnum string

type PatternFlowIgmpv1TypeCounter 

type PatternFlowIgmpv1TypeCounter interface {
	Msg() *snappipb.PatternFlowIgmpv1TypeCounter
	SetMsg(*snappipb.PatternFlowIgmpv1TypeCounter) PatternFlowIgmpv1TypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIgmpv1TypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIgmpv1TypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIgmpv1TypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1TypeCounter added in v0.6.5 

func NewPatternFlowIgmpv1TypeCounter() PatternFlowIgmpv1TypeCounter

type PatternFlowIgmpv1Unused 

type PatternFlowIgmpv1Unused interface {
	Msg() *snappipb.PatternFlowIgmpv1Unused
	SetMsg(*snappipb.PatternFlowIgmpv1Unused) PatternFlowIgmpv1Unused
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIgmpv1UnusedChoiceEnum
	SetChoice(value PatternFlowIgmpv1UnusedChoiceEnum) PatternFlowIgmpv1Unused
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIgmpv1Unused
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIgmpv1Unused
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIgmpv1Unused
	HasMetricGroup() bool
	Increment() PatternFlowIgmpv1UnusedCounter
	SetIncrement(value PatternFlowIgmpv1UnusedCounter) PatternFlowIgmpv1Unused
	HasIncrement() bool
	Decrement() PatternFlowIgmpv1UnusedCounter
	SetDecrement(value PatternFlowIgmpv1UnusedCounter) PatternFlowIgmpv1Unused
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1Unused added in v0.6.5 

func NewPatternFlowIgmpv1Unused() PatternFlowIgmpv1Unused

type PatternFlowIgmpv1UnusedChoiceEnum 

type PatternFlowIgmpv1UnusedChoiceEnum string

type PatternFlowIgmpv1UnusedCounter 

type PatternFlowIgmpv1UnusedCounter interface {
	Msg() *snappipb.PatternFlowIgmpv1UnusedCounter
	SetMsg(*snappipb.PatternFlowIgmpv1UnusedCounter) PatternFlowIgmpv1UnusedCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIgmpv1UnusedCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIgmpv1UnusedCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIgmpv1UnusedCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1UnusedCounter added in v0.6.5 

func NewPatternFlowIgmpv1UnusedCounter() PatternFlowIgmpv1UnusedCounter

type PatternFlowIgmpv1Version 

type PatternFlowIgmpv1Version interface {
	Msg() *snappipb.PatternFlowIgmpv1Version
	SetMsg(*snappipb.PatternFlowIgmpv1Version) PatternFlowIgmpv1Version
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIgmpv1VersionChoiceEnum
	SetChoice(value PatternFlowIgmpv1VersionChoiceEnum) PatternFlowIgmpv1Version
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIgmpv1Version
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIgmpv1Version
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIgmpv1Version
	HasMetricGroup() bool
	Increment() PatternFlowIgmpv1VersionCounter
	SetIncrement(value PatternFlowIgmpv1VersionCounter) PatternFlowIgmpv1Version
	HasIncrement() bool
	Decrement() PatternFlowIgmpv1VersionCounter
	SetDecrement(value PatternFlowIgmpv1VersionCounter) PatternFlowIgmpv1Version
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1Version added in v0.6.5 

func NewPatternFlowIgmpv1Version() PatternFlowIgmpv1Version

type PatternFlowIgmpv1VersionChoiceEnum 

type PatternFlowIgmpv1VersionChoiceEnum string

type PatternFlowIgmpv1VersionCounter 

type PatternFlowIgmpv1VersionCounter interface {
	Msg() *snappipb.PatternFlowIgmpv1VersionCounter
	SetMsg(*snappipb.PatternFlowIgmpv1VersionCounter) PatternFlowIgmpv1VersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIgmpv1VersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIgmpv1VersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIgmpv1VersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIgmpv1VersionCounter added in v0.6.5 

func NewPatternFlowIgmpv1VersionCounter() PatternFlowIgmpv1VersionCounter

type PatternFlowIpv4DontFragment 

type PatternFlowIpv4DontFragment interface {
	Msg() *snappipb.PatternFlowIpv4DontFragment
	SetMsg(*snappipb.PatternFlowIpv4DontFragment) PatternFlowIpv4DontFragment
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4DontFragmentChoiceEnum
	SetChoice(value PatternFlowIpv4DontFragmentChoiceEnum) PatternFlowIpv4DontFragment
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4DontFragment
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4DontFragment
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4DontFragment
	HasMetricGroup() bool
	Increment() PatternFlowIpv4DontFragmentCounter
	SetIncrement(value PatternFlowIpv4DontFragmentCounter) PatternFlowIpv4DontFragment
	HasIncrement() bool
	Decrement() PatternFlowIpv4DontFragmentCounter
	SetDecrement(value PatternFlowIpv4DontFragmentCounter) PatternFlowIpv4DontFragment
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DontFragment added in v0.6.5 

func NewPatternFlowIpv4DontFragment() PatternFlowIpv4DontFragment

type PatternFlowIpv4DontFragmentChoiceEnum 

type PatternFlowIpv4DontFragmentChoiceEnum string

type PatternFlowIpv4DontFragmentCounter 

type PatternFlowIpv4DontFragmentCounter interface {
	Msg() *snappipb.PatternFlowIpv4DontFragmentCounter
	SetMsg(*snappipb.PatternFlowIpv4DontFragmentCounter) PatternFlowIpv4DontFragmentCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4DontFragmentCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4DontFragmentCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4DontFragmentCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DontFragmentCounter added in v0.6.5 

func NewPatternFlowIpv4DontFragmentCounter() PatternFlowIpv4DontFragmentCounter

type PatternFlowIpv4DscpEcn 

type PatternFlowIpv4DscpEcn interface {
	Msg() *snappipb.PatternFlowIpv4DscpEcn
	SetMsg(*snappipb.PatternFlowIpv4DscpEcn) PatternFlowIpv4DscpEcn
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4DscpEcnChoiceEnum
	SetChoice(value PatternFlowIpv4DscpEcnChoiceEnum) PatternFlowIpv4DscpEcn
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4DscpEcn
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4DscpEcn
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4DscpEcn
	HasMetricGroup() bool
	Increment() PatternFlowIpv4DscpEcnCounter
	SetIncrement(value PatternFlowIpv4DscpEcnCounter) PatternFlowIpv4DscpEcn
	HasIncrement() bool
	Decrement() PatternFlowIpv4DscpEcnCounter
	SetDecrement(value PatternFlowIpv4DscpEcnCounter) PatternFlowIpv4DscpEcn
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DscpEcn added in v0.6.5 

func NewPatternFlowIpv4DscpEcn() PatternFlowIpv4DscpEcn

type PatternFlowIpv4DscpEcnChoiceEnum 

type PatternFlowIpv4DscpEcnChoiceEnum string

type PatternFlowIpv4DscpEcnCounter 

type PatternFlowIpv4DscpEcnCounter interface {
	Msg() *snappipb.PatternFlowIpv4DscpEcnCounter
	SetMsg(*snappipb.PatternFlowIpv4DscpEcnCounter) PatternFlowIpv4DscpEcnCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4DscpEcnCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4DscpEcnCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4DscpEcnCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DscpEcnCounter added in v0.6.5 

func NewPatternFlowIpv4DscpEcnCounter() PatternFlowIpv4DscpEcnCounter

type PatternFlowIpv4DscpPhb 

type PatternFlowIpv4DscpPhb interface {
	Msg() *snappipb.PatternFlowIpv4DscpPhb
	SetMsg(*snappipb.PatternFlowIpv4DscpPhb) PatternFlowIpv4DscpPhb
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4DscpPhbChoiceEnum
	SetChoice(value PatternFlowIpv4DscpPhbChoiceEnum) PatternFlowIpv4DscpPhb
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4DscpPhb
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4DscpPhb
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4DscpPhb
	HasMetricGroup() bool
	Increment() PatternFlowIpv4DscpPhbCounter
	SetIncrement(value PatternFlowIpv4DscpPhbCounter) PatternFlowIpv4DscpPhb
	HasIncrement() bool
	Decrement() PatternFlowIpv4DscpPhbCounter
	SetDecrement(value PatternFlowIpv4DscpPhbCounter) PatternFlowIpv4DscpPhb
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DscpPhb added in v0.6.5 

func NewPatternFlowIpv4DscpPhb() PatternFlowIpv4DscpPhb

type PatternFlowIpv4DscpPhbChoiceEnum 

type PatternFlowIpv4DscpPhbChoiceEnum string

type PatternFlowIpv4DscpPhbCounter 

type PatternFlowIpv4DscpPhbCounter interface {
	Msg() *snappipb.PatternFlowIpv4DscpPhbCounter
	SetMsg(*snappipb.PatternFlowIpv4DscpPhbCounter) PatternFlowIpv4DscpPhbCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4DscpPhbCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4DscpPhbCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4DscpPhbCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DscpPhbCounter added in v0.6.5 

func NewPatternFlowIpv4DscpPhbCounter() PatternFlowIpv4DscpPhbCounter

type PatternFlowIpv4Dst 

type PatternFlowIpv4Dst interface {
	Msg() *snappipb.PatternFlowIpv4Dst
	SetMsg(*snappipb.PatternFlowIpv4Dst) PatternFlowIpv4Dst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4DstChoiceEnum
	SetChoice(value PatternFlowIpv4DstChoiceEnum) PatternFlowIpv4Dst
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowIpv4Dst
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowIpv4Dst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Dst
	HasMetricGroup() bool
	Increment() PatternFlowIpv4DstCounter
	SetIncrement(value PatternFlowIpv4DstCounter) PatternFlowIpv4Dst
	HasIncrement() bool
	Decrement() PatternFlowIpv4DstCounter
	SetDecrement(value PatternFlowIpv4DstCounter) PatternFlowIpv4Dst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Dst added in v0.6.5 

func NewPatternFlowIpv4Dst() PatternFlowIpv4Dst

type PatternFlowIpv4DstChoiceEnum 

type PatternFlowIpv4DstChoiceEnum string

type PatternFlowIpv4DstCounter 

type PatternFlowIpv4DstCounter interface {
	Msg() *snappipb.PatternFlowIpv4DstCounter
	SetMsg(*snappipb.PatternFlowIpv4DstCounter) PatternFlowIpv4DstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowIpv4DstCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowIpv4DstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4DstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4DstCounter added in v0.6.5 

func NewPatternFlowIpv4DstCounter() PatternFlowIpv4DstCounter

type PatternFlowIpv4FragmentOffset 

type PatternFlowIpv4FragmentOffset interface {
	Msg() *snappipb.PatternFlowIpv4FragmentOffset
	SetMsg(*snappipb.PatternFlowIpv4FragmentOffset) PatternFlowIpv4FragmentOffset
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4FragmentOffsetChoiceEnum
	SetChoice(value PatternFlowIpv4FragmentOffsetChoiceEnum) PatternFlowIpv4FragmentOffset
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4FragmentOffset
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4FragmentOffset
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4FragmentOffset
	HasMetricGroup() bool
	Increment() PatternFlowIpv4FragmentOffsetCounter
	SetIncrement(value PatternFlowIpv4FragmentOffsetCounter) PatternFlowIpv4FragmentOffset
	HasIncrement() bool
	Decrement() PatternFlowIpv4FragmentOffsetCounter
	SetDecrement(value PatternFlowIpv4FragmentOffsetCounter) PatternFlowIpv4FragmentOffset
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4FragmentOffset added in v0.6.5 

func NewPatternFlowIpv4FragmentOffset() PatternFlowIpv4FragmentOffset

type PatternFlowIpv4FragmentOffsetChoiceEnum 

type PatternFlowIpv4FragmentOffsetChoiceEnum string

type PatternFlowIpv4FragmentOffsetCounter 

type PatternFlowIpv4FragmentOffsetCounter interface {
	Msg() *snappipb.PatternFlowIpv4FragmentOffsetCounter
	SetMsg(*snappipb.PatternFlowIpv4FragmentOffsetCounter) PatternFlowIpv4FragmentOffsetCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4FragmentOffsetCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4FragmentOffsetCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4FragmentOffsetCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4FragmentOffsetCounter added in v0.6.5 

func NewPatternFlowIpv4FragmentOffsetCounter() PatternFlowIpv4FragmentOffsetCounter

type PatternFlowIpv4HeaderChecksum 

type PatternFlowIpv4HeaderChecksum interface {
	Msg() *snappipb.PatternFlowIpv4HeaderChecksum
	SetMsg(*snappipb.PatternFlowIpv4HeaderChecksum) PatternFlowIpv4HeaderChecksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4HeaderChecksumChoiceEnum
	SetChoice(value PatternFlowIpv4HeaderChecksumChoiceEnum) PatternFlowIpv4HeaderChecksum
	Generated() PatternFlowIpv4HeaderChecksumGeneratedEnum
	SetGenerated(value PatternFlowIpv4HeaderChecksumGeneratedEnum) PatternFlowIpv4HeaderChecksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowIpv4HeaderChecksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4HeaderChecksum added in v0.6.5 

func NewPatternFlowIpv4HeaderChecksum() PatternFlowIpv4HeaderChecksum

type PatternFlowIpv4HeaderChecksumChoiceEnum 

type PatternFlowIpv4HeaderChecksumChoiceEnum string

type PatternFlowIpv4HeaderChecksumGeneratedEnum 

type PatternFlowIpv4HeaderChecksumGeneratedEnum string

type PatternFlowIpv4HeaderLength 

type PatternFlowIpv4HeaderLength interface {
	Msg() *snappipb.PatternFlowIpv4HeaderLength
	SetMsg(*snappipb.PatternFlowIpv4HeaderLength) PatternFlowIpv4HeaderLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4HeaderLengthChoiceEnum
	SetChoice(value PatternFlowIpv4HeaderLengthChoiceEnum) PatternFlowIpv4HeaderLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4HeaderLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4HeaderLength
	Auto() PatternFlowIpv4HeaderLengthAutoEnum
	SetAuto(value PatternFlowIpv4HeaderLengthAutoEnum) PatternFlowIpv4HeaderLength
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4HeaderLength
	HasMetricGroup() bool
	Increment() PatternFlowIpv4HeaderLengthCounter
	SetIncrement(value PatternFlowIpv4HeaderLengthCounter) PatternFlowIpv4HeaderLength
	HasIncrement() bool
	Decrement() PatternFlowIpv4HeaderLengthCounter
	SetDecrement(value PatternFlowIpv4HeaderLengthCounter) PatternFlowIpv4HeaderLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4HeaderLength added in v0.6.5 

func NewPatternFlowIpv4HeaderLength() PatternFlowIpv4HeaderLength

type PatternFlowIpv4HeaderLengthAutoEnum 

type PatternFlowIpv4HeaderLengthAutoEnum string

type PatternFlowIpv4HeaderLengthChoiceEnum 

type PatternFlowIpv4HeaderLengthChoiceEnum string

type PatternFlowIpv4HeaderLengthCounter 

type PatternFlowIpv4HeaderLengthCounter interface {
	Msg() *snappipb.PatternFlowIpv4HeaderLengthCounter
	SetMsg(*snappipb.PatternFlowIpv4HeaderLengthCounter) PatternFlowIpv4HeaderLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4HeaderLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4HeaderLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4HeaderLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4HeaderLengthCounter added in v0.6.5 

func NewPatternFlowIpv4HeaderLengthCounter() PatternFlowIpv4HeaderLengthCounter

type PatternFlowIpv4Identification 

type PatternFlowIpv4Identification interface {
	Msg() *snappipb.PatternFlowIpv4Identification
	SetMsg(*snappipb.PatternFlowIpv4Identification) PatternFlowIpv4Identification
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4IdentificationChoiceEnum
	SetChoice(value PatternFlowIpv4IdentificationChoiceEnum) PatternFlowIpv4Identification
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4Identification
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4Identification
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Identification
	HasMetricGroup() bool
	Increment() PatternFlowIpv4IdentificationCounter
	SetIncrement(value PatternFlowIpv4IdentificationCounter) PatternFlowIpv4Identification
	HasIncrement() bool
	Decrement() PatternFlowIpv4IdentificationCounter
	SetDecrement(value PatternFlowIpv4IdentificationCounter) PatternFlowIpv4Identification
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Identification added in v0.6.5 

func NewPatternFlowIpv4Identification() PatternFlowIpv4Identification

type PatternFlowIpv4IdentificationChoiceEnum 

type PatternFlowIpv4IdentificationChoiceEnum string

type PatternFlowIpv4IdentificationCounter 

type PatternFlowIpv4IdentificationCounter interface {
	Msg() *snappipb.PatternFlowIpv4IdentificationCounter
	SetMsg(*snappipb.PatternFlowIpv4IdentificationCounter) PatternFlowIpv4IdentificationCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4IdentificationCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4IdentificationCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4IdentificationCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4IdentificationCounter added in v0.6.5 

func NewPatternFlowIpv4IdentificationCounter() PatternFlowIpv4IdentificationCounter

type PatternFlowIpv4MoreFragments 

type PatternFlowIpv4MoreFragments interface {
	Msg() *snappipb.PatternFlowIpv4MoreFragments
	SetMsg(*snappipb.PatternFlowIpv4MoreFragments) PatternFlowIpv4MoreFragments
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4MoreFragmentsChoiceEnum
	SetChoice(value PatternFlowIpv4MoreFragmentsChoiceEnum) PatternFlowIpv4MoreFragments
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4MoreFragments
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4MoreFragments
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4MoreFragments
	HasMetricGroup() bool
	Increment() PatternFlowIpv4MoreFragmentsCounter
	SetIncrement(value PatternFlowIpv4MoreFragmentsCounter) PatternFlowIpv4MoreFragments
	HasIncrement() bool
	Decrement() PatternFlowIpv4MoreFragmentsCounter
	SetDecrement(value PatternFlowIpv4MoreFragmentsCounter) PatternFlowIpv4MoreFragments
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4MoreFragments added in v0.6.5 

func NewPatternFlowIpv4MoreFragments() PatternFlowIpv4MoreFragments

type PatternFlowIpv4MoreFragmentsChoiceEnum 

type PatternFlowIpv4MoreFragmentsChoiceEnum string

type PatternFlowIpv4MoreFragmentsCounter 

type PatternFlowIpv4MoreFragmentsCounter interface {
	Msg() *snappipb.PatternFlowIpv4MoreFragmentsCounter
	SetMsg(*snappipb.PatternFlowIpv4MoreFragmentsCounter) PatternFlowIpv4MoreFragmentsCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4MoreFragmentsCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4MoreFragmentsCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4MoreFragmentsCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4MoreFragmentsCounter added in v0.6.5 

func NewPatternFlowIpv4MoreFragmentsCounter() PatternFlowIpv4MoreFragmentsCounter

type PatternFlowIpv4PriorityRaw 

type PatternFlowIpv4PriorityRaw interface {
	Msg() *snappipb.PatternFlowIpv4PriorityRaw
	SetMsg(*snappipb.PatternFlowIpv4PriorityRaw) PatternFlowIpv4PriorityRaw
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4PriorityRawChoiceEnum
	SetChoice(value PatternFlowIpv4PriorityRawChoiceEnum) PatternFlowIpv4PriorityRaw
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4PriorityRaw
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4PriorityRaw
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4PriorityRaw
	HasMetricGroup() bool
	Increment() PatternFlowIpv4PriorityRawCounter
	SetIncrement(value PatternFlowIpv4PriorityRawCounter) PatternFlowIpv4PriorityRaw
	HasIncrement() bool
	Decrement() PatternFlowIpv4PriorityRawCounter
	SetDecrement(value PatternFlowIpv4PriorityRawCounter) PatternFlowIpv4PriorityRaw
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4PriorityRaw added in v0.6.5 

func NewPatternFlowIpv4PriorityRaw() PatternFlowIpv4PriorityRaw

type PatternFlowIpv4PriorityRawChoiceEnum 

type PatternFlowIpv4PriorityRawChoiceEnum string

type PatternFlowIpv4PriorityRawCounter 

type PatternFlowIpv4PriorityRawCounter interface {
	Msg() *snappipb.PatternFlowIpv4PriorityRawCounter
	SetMsg(*snappipb.PatternFlowIpv4PriorityRawCounter) PatternFlowIpv4PriorityRawCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4PriorityRawCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4PriorityRawCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4PriorityRawCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4PriorityRawCounter added in v0.6.5 

func NewPatternFlowIpv4PriorityRawCounter() PatternFlowIpv4PriorityRawCounter

type PatternFlowIpv4Protocol 

type PatternFlowIpv4Protocol interface {
	Msg() *snappipb.PatternFlowIpv4Protocol
	SetMsg(*snappipb.PatternFlowIpv4Protocol) PatternFlowIpv4Protocol
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4ProtocolChoiceEnum
	SetChoice(value PatternFlowIpv4ProtocolChoiceEnum) PatternFlowIpv4Protocol
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4Protocol
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4Protocol
	Auto() PatternFlowIpv4ProtocolAutoEnum
	SetAuto(value PatternFlowIpv4ProtocolAutoEnum) PatternFlowIpv4Protocol
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Protocol
	HasMetricGroup() bool
	Increment() PatternFlowIpv4ProtocolCounter
	SetIncrement(value PatternFlowIpv4ProtocolCounter) PatternFlowIpv4Protocol
	HasIncrement() bool
	Decrement() PatternFlowIpv4ProtocolCounter
	SetDecrement(value PatternFlowIpv4ProtocolCounter) PatternFlowIpv4Protocol
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Protocol added in v0.6.5 

func NewPatternFlowIpv4Protocol() PatternFlowIpv4Protocol

type PatternFlowIpv4ProtocolAutoEnum added in v0.6.2 

type PatternFlowIpv4ProtocolAutoEnum string

type PatternFlowIpv4ProtocolChoiceEnum 

type PatternFlowIpv4ProtocolChoiceEnum string

type PatternFlowIpv4ProtocolCounter 

type PatternFlowIpv4ProtocolCounter interface {
	Msg() *snappipb.PatternFlowIpv4ProtocolCounter
	SetMsg(*snappipb.PatternFlowIpv4ProtocolCounter) PatternFlowIpv4ProtocolCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4ProtocolCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4ProtocolCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4ProtocolCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4ProtocolCounter added in v0.6.5 

func NewPatternFlowIpv4ProtocolCounter() PatternFlowIpv4ProtocolCounter

type PatternFlowIpv4Reserved 

type PatternFlowIpv4Reserved interface {
	Msg() *snappipb.PatternFlowIpv4Reserved
	SetMsg(*snappipb.PatternFlowIpv4Reserved) PatternFlowIpv4Reserved
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4ReservedChoiceEnum
	SetChoice(value PatternFlowIpv4ReservedChoiceEnum) PatternFlowIpv4Reserved
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4Reserved
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4Reserved
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Reserved
	HasMetricGroup() bool
	Increment() PatternFlowIpv4ReservedCounter
	SetIncrement(value PatternFlowIpv4ReservedCounter) PatternFlowIpv4Reserved
	HasIncrement() bool
	Decrement() PatternFlowIpv4ReservedCounter
	SetDecrement(value PatternFlowIpv4ReservedCounter) PatternFlowIpv4Reserved
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Reserved added in v0.6.5 

func NewPatternFlowIpv4Reserved() PatternFlowIpv4Reserved

type PatternFlowIpv4ReservedChoiceEnum 

type PatternFlowIpv4ReservedChoiceEnum string

type PatternFlowIpv4ReservedCounter 

type PatternFlowIpv4ReservedCounter interface {
	Msg() *snappipb.PatternFlowIpv4ReservedCounter
	SetMsg(*snappipb.PatternFlowIpv4ReservedCounter) PatternFlowIpv4ReservedCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4ReservedCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4ReservedCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4ReservedCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4ReservedCounter added in v0.6.5 

func NewPatternFlowIpv4ReservedCounter() PatternFlowIpv4ReservedCounter

type PatternFlowIpv4Src 

type PatternFlowIpv4Src interface {
	Msg() *snappipb.PatternFlowIpv4Src
	SetMsg(*snappipb.PatternFlowIpv4Src) PatternFlowIpv4Src
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4SrcChoiceEnum
	SetChoice(value PatternFlowIpv4SrcChoiceEnum) PatternFlowIpv4Src
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowIpv4Src
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowIpv4Src
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Src
	HasMetricGroup() bool
	Increment() PatternFlowIpv4SrcCounter
	SetIncrement(value PatternFlowIpv4SrcCounter) PatternFlowIpv4Src
	HasIncrement() bool
	Decrement() PatternFlowIpv4SrcCounter
	SetDecrement(value PatternFlowIpv4SrcCounter) PatternFlowIpv4Src
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Src added in v0.6.5 

func NewPatternFlowIpv4Src() PatternFlowIpv4Src

type PatternFlowIpv4SrcChoiceEnum 

type PatternFlowIpv4SrcChoiceEnum string

type PatternFlowIpv4SrcCounter 

type PatternFlowIpv4SrcCounter interface {
	Msg() *snappipb.PatternFlowIpv4SrcCounter
	SetMsg(*snappipb.PatternFlowIpv4SrcCounter) PatternFlowIpv4SrcCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowIpv4SrcCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowIpv4SrcCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4SrcCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4SrcCounter added in v0.6.5 

func NewPatternFlowIpv4SrcCounter() PatternFlowIpv4SrcCounter

type PatternFlowIpv4TimeToLive 

type PatternFlowIpv4TimeToLive interface {
	Msg() *snappipb.PatternFlowIpv4TimeToLive
	SetMsg(*snappipb.PatternFlowIpv4TimeToLive) PatternFlowIpv4TimeToLive
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TimeToLiveChoiceEnum
	SetChoice(value PatternFlowIpv4TimeToLiveChoiceEnum) PatternFlowIpv4TimeToLive
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TimeToLive
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TimeToLive
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TimeToLive
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TimeToLiveCounter
	SetIncrement(value PatternFlowIpv4TimeToLiveCounter) PatternFlowIpv4TimeToLive
	HasIncrement() bool
	Decrement() PatternFlowIpv4TimeToLiveCounter
	SetDecrement(value PatternFlowIpv4TimeToLiveCounter) PatternFlowIpv4TimeToLive
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TimeToLive added in v0.6.5 

func NewPatternFlowIpv4TimeToLive() PatternFlowIpv4TimeToLive

type PatternFlowIpv4TimeToLiveChoiceEnum 

type PatternFlowIpv4TimeToLiveChoiceEnum string

type PatternFlowIpv4TimeToLiveCounter 

type PatternFlowIpv4TimeToLiveCounter interface {
	Msg() *snappipb.PatternFlowIpv4TimeToLiveCounter
	SetMsg(*snappipb.PatternFlowIpv4TimeToLiveCounter) PatternFlowIpv4TimeToLiveCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TimeToLiveCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TimeToLiveCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TimeToLiveCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TimeToLiveCounter added in v0.6.5 

func NewPatternFlowIpv4TimeToLiveCounter() PatternFlowIpv4TimeToLiveCounter

type PatternFlowIpv4TosDelay 

type PatternFlowIpv4TosDelay interface {
	Msg() *snappipb.PatternFlowIpv4TosDelay
	SetMsg(*snappipb.PatternFlowIpv4TosDelay) PatternFlowIpv4TosDelay
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosDelayChoiceEnum
	SetChoice(value PatternFlowIpv4TosDelayChoiceEnum) PatternFlowIpv4TosDelay
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosDelay
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosDelay
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosDelay
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosDelayCounter
	SetIncrement(value PatternFlowIpv4TosDelayCounter) PatternFlowIpv4TosDelay
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosDelayCounter
	SetDecrement(value PatternFlowIpv4TosDelayCounter) PatternFlowIpv4TosDelay
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosDelay added in v0.6.5 

func NewPatternFlowIpv4TosDelay() PatternFlowIpv4TosDelay

type PatternFlowIpv4TosDelayChoiceEnum 

type PatternFlowIpv4TosDelayChoiceEnum string

type PatternFlowIpv4TosDelayCounter 

type PatternFlowIpv4TosDelayCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosDelayCounter
	SetMsg(*snappipb.PatternFlowIpv4TosDelayCounter) PatternFlowIpv4TosDelayCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosDelayCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosDelayCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosDelayCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosDelayCounter added in v0.6.5 

func NewPatternFlowIpv4TosDelayCounter() PatternFlowIpv4TosDelayCounter

type PatternFlowIpv4TosMonetary 

type PatternFlowIpv4TosMonetary interface {
	Msg() *snappipb.PatternFlowIpv4TosMonetary
	SetMsg(*snappipb.PatternFlowIpv4TosMonetary) PatternFlowIpv4TosMonetary
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosMonetaryChoiceEnum
	SetChoice(value PatternFlowIpv4TosMonetaryChoiceEnum) PatternFlowIpv4TosMonetary
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosMonetary
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosMonetary
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosMonetary
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosMonetaryCounter
	SetIncrement(value PatternFlowIpv4TosMonetaryCounter) PatternFlowIpv4TosMonetary
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosMonetaryCounter
	SetDecrement(value PatternFlowIpv4TosMonetaryCounter) PatternFlowIpv4TosMonetary
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosMonetary added in v0.6.5 

func NewPatternFlowIpv4TosMonetary() PatternFlowIpv4TosMonetary

type PatternFlowIpv4TosMonetaryChoiceEnum 

type PatternFlowIpv4TosMonetaryChoiceEnum string

type PatternFlowIpv4TosMonetaryCounter 

type PatternFlowIpv4TosMonetaryCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosMonetaryCounter
	SetMsg(*snappipb.PatternFlowIpv4TosMonetaryCounter) PatternFlowIpv4TosMonetaryCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosMonetaryCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosMonetaryCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosMonetaryCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosMonetaryCounter added in v0.6.5 

func NewPatternFlowIpv4TosMonetaryCounter() PatternFlowIpv4TosMonetaryCounter

type PatternFlowIpv4TosPrecedence 

type PatternFlowIpv4TosPrecedence interface {
	Msg() *snappipb.PatternFlowIpv4TosPrecedence
	SetMsg(*snappipb.PatternFlowIpv4TosPrecedence) PatternFlowIpv4TosPrecedence
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosPrecedenceChoiceEnum
	SetChoice(value PatternFlowIpv4TosPrecedenceChoiceEnum) PatternFlowIpv4TosPrecedence
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosPrecedence
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosPrecedence
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosPrecedence
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosPrecedenceCounter
	SetIncrement(value PatternFlowIpv4TosPrecedenceCounter) PatternFlowIpv4TosPrecedence
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosPrecedenceCounter
	SetDecrement(value PatternFlowIpv4TosPrecedenceCounter) PatternFlowIpv4TosPrecedence
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosPrecedence added in v0.6.5 

func NewPatternFlowIpv4TosPrecedence() PatternFlowIpv4TosPrecedence

type PatternFlowIpv4TosPrecedenceChoiceEnum 

type PatternFlowIpv4TosPrecedenceChoiceEnum string

type PatternFlowIpv4TosPrecedenceCounter 

type PatternFlowIpv4TosPrecedenceCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosPrecedenceCounter
	SetMsg(*snappipb.PatternFlowIpv4TosPrecedenceCounter) PatternFlowIpv4TosPrecedenceCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosPrecedenceCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosPrecedenceCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosPrecedenceCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosPrecedenceCounter added in v0.6.5 

func NewPatternFlowIpv4TosPrecedenceCounter() PatternFlowIpv4TosPrecedenceCounter

type PatternFlowIpv4TosReliability 

type PatternFlowIpv4TosReliability interface {
	Msg() *snappipb.PatternFlowIpv4TosReliability
	SetMsg(*snappipb.PatternFlowIpv4TosReliability) PatternFlowIpv4TosReliability
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosReliabilityChoiceEnum
	SetChoice(value PatternFlowIpv4TosReliabilityChoiceEnum) PatternFlowIpv4TosReliability
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosReliability
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosReliability
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosReliability
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosReliabilityCounter
	SetIncrement(value PatternFlowIpv4TosReliabilityCounter) PatternFlowIpv4TosReliability
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosReliabilityCounter
	SetDecrement(value PatternFlowIpv4TosReliabilityCounter) PatternFlowIpv4TosReliability
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosReliability added in v0.6.5 

func NewPatternFlowIpv4TosReliability() PatternFlowIpv4TosReliability

type PatternFlowIpv4TosReliabilityChoiceEnum 

type PatternFlowIpv4TosReliabilityChoiceEnum string

type PatternFlowIpv4TosReliabilityCounter 

type PatternFlowIpv4TosReliabilityCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosReliabilityCounter
	SetMsg(*snappipb.PatternFlowIpv4TosReliabilityCounter) PatternFlowIpv4TosReliabilityCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosReliabilityCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosReliabilityCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosReliabilityCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosReliabilityCounter added in v0.6.5 

func NewPatternFlowIpv4TosReliabilityCounter() PatternFlowIpv4TosReliabilityCounter

type PatternFlowIpv4TosThroughput 

type PatternFlowIpv4TosThroughput interface {
	Msg() *snappipb.PatternFlowIpv4TosThroughput
	SetMsg(*snappipb.PatternFlowIpv4TosThroughput) PatternFlowIpv4TosThroughput
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosThroughputChoiceEnum
	SetChoice(value PatternFlowIpv4TosThroughputChoiceEnum) PatternFlowIpv4TosThroughput
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosThroughput
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosThroughput
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosThroughput
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosThroughputCounter
	SetIncrement(value PatternFlowIpv4TosThroughputCounter) PatternFlowIpv4TosThroughput
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosThroughputCounter
	SetDecrement(value PatternFlowIpv4TosThroughputCounter) PatternFlowIpv4TosThroughput
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosThroughput added in v0.6.5 

func NewPatternFlowIpv4TosThroughput() PatternFlowIpv4TosThroughput

type PatternFlowIpv4TosThroughputChoiceEnum 

type PatternFlowIpv4TosThroughputChoiceEnum string

type PatternFlowIpv4TosThroughputCounter 

type PatternFlowIpv4TosThroughputCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosThroughputCounter
	SetMsg(*snappipb.PatternFlowIpv4TosThroughputCounter) PatternFlowIpv4TosThroughputCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosThroughputCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosThroughputCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosThroughputCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosThroughputCounter added in v0.6.5 

func NewPatternFlowIpv4TosThroughputCounter() PatternFlowIpv4TosThroughputCounter

type PatternFlowIpv4TosUnused 

type PatternFlowIpv4TosUnused interface {
	Msg() *snappipb.PatternFlowIpv4TosUnused
	SetMsg(*snappipb.PatternFlowIpv4TosUnused) PatternFlowIpv4TosUnused
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TosUnusedChoiceEnum
	SetChoice(value PatternFlowIpv4TosUnusedChoiceEnum) PatternFlowIpv4TosUnused
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TosUnused
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TosUnused
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TosUnused
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TosUnusedCounter
	SetIncrement(value PatternFlowIpv4TosUnusedCounter) PatternFlowIpv4TosUnused
	HasIncrement() bool
	Decrement() PatternFlowIpv4TosUnusedCounter
	SetDecrement(value PatternFlowIpv4TosUnusedCounter) PatternFlowIpv4TosUnused
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosUnused added in v0.6.5 

func NewPatternFlowIpv4TosUnused() PatternFlowIpv4TosUnused

type PatternFlowIpv4TosUnusedChoiceEnum 

type PatternFlowIpv4TosUnusedChoiceEnum string

type PatternFlowIpv4TosUnusedCounter 

type PatternFlowIpv4TosUnusedCounter interface {
	Msg() *snappipb.PatternFlowIpv4TosUnusedCounter
	SetMsg(*snappipb.PatternFlowIpv4TosUnusedCounter) PatternFlowIpv4TosUnusedCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TosUnusedCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TosUnusedCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TosUnusedCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TosUnusedCounter added in v0.6.5 

func NewPatternFlowIpv4TosUnusedCounter() PatternFlowIpv4TosUnusedCounter

type PatternFlowIpv4TotalLength 

type PatternFlowIpv4TotalLength interface {
	Msg() *snappipb.PatternFlowIpv4TotalLength
	SetMsg(*snappipb.PatternFlowIpv4TotalLength) PatternFlowIpv4TotalLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4TotalLengthChoiceEnum
	SetChoice(value PatternFlowIpv4TotalLengthChoiceEnum) PatternFlowIpv4TotalLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4TotalLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4TotalLength
	Auto() PatternFlowIpv4TotalLengthAutoEnum
	SetAuto(value PatternFlowIpv4TotalLengthAutoEnum) PatternFlowIpv4TotalLength
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4TotalLength
	HasMetricGroup() bool
	Increment() PatternFlowIpv4TotalLengthCounter
	SetIncrement(value PatternFlowIpv4TotalLengthCounter) PatternFlowIpv4TotalLength
	HasIncrement() bool
	Decrement() PatternFlowIpv4TotalLengthCounter
	SetDecrement(value PatternFlowIpv4TotalLengthCounter) PatternFlowIpv4TotalLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TotalLength added in v0.6.5 

func NewPatternFlowIpv4TotalLength() PatternFlowIpv4TotalLength

type PatternFlowIpv4TotalLengthAutoEnum 

type PatternFlowIpv4TotalLengthAutoEnum string

type PatternFlowIpv4TotalLengthChoiceEnum 

type PatternFlowIpv4TotalLengthChoiceEnum string

type PatternFlowIpv4TotalLengthCounter 

type PatternFlowIpv4TotalLengthCounter interface {
	Msg() *snappipb.PatternFlowIpv4TotalLengthCounter
	SetMsg(*snappipb.PatternFlowIpv4TotalLengthCounter) PatternFlowIpv4TotalLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4TotalLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4TotalLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4TotalLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4TotalLengthCounter added in v0.6.5 

func NewPatternFlowIpv4TotalLengthCounter() PatternFlowIpv4TotalLengthCounter

type PatternFlowIpv4Version 

type PatternFlowIpv4Version interface {
	Msg() *snappipb.PatternFlowIpv4Version
	SetMsg(*snappipb.PatternFlowIpv4Version) PatternFlowIpv4Version
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv4VersionChoiceEnum
	SetChoice(value PatternFlowIpv4VersionChoiceEnum) PatternFlowIpv4Version
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv4Version
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv4Version
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv4Version
	HasMetricGroup() bool
	Increment() PatternFlowIpv4VersionCounter
	SetIncrement(value PatternFlowIpv4VersionCounter) PatternFlowIpv4Version
	HasIncrement() bool
	Decrement() PatternFlowIpv4VersionCounter
	SetDecrement(value PatternFlowIpv4VersionCounter) PatternFlowIpv4Version
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4Version added in v0.6.5 

func NewPatternFlowIpv4Version() PatternFlowIpv4Version

type PatternFlowIpv4VersionChoiceEnum 

type PatternFlowIpv4VersionChoiceEnum string

type PatternFlowIpv4VersionCounter 

type PatternFlowIpv4VersionCounter interface {
	Msg() *snappipb.PatternFlowIpv4VersionCounter
	SetMsg(*snappipb.PatternFlowIpv4VersionCounter) PatternFlowIpv4VersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv4VersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv4VersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv4VersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv4VersionCounter added in v0.6.5 

func NewPatternFlowIpv4VersionCounter() PatternFlowIpv4VersionCounter

type PatternFlowIpv6Dst 

type PatternFlowIpv6Dst interface {
	Msg() *snappipb.PatternFlowIpv6Dst
	SetMsg(*snappipb.PatternFlowIpv6Dst) PatternFlowIpv6Dst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6DstChoiceEnum
	SetChoice(value PatternFlowIpv6DstChoiceEnum) PatternFlowIpv6Dst
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowIpv6Dst
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowIpv6Dst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6Dst
	HasMetricGroup() bool
	Increment() PatternFlowIpv6DstCounter
	SetIncrement(value PatternFlowIpv6DstCounter) PatternFlowIpv6Dst
	HasIncrement() bool
	Decrement() PatternFlowIpv6DstCounter
	SetDecrement(value PatternFlowIpv6DstCounter) PatternFlowIpv6Dst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6Dst added in v0.6.5 

func NewPatternFlowIpv6Dst() PatternFlowIpv6Dst

type PatternFlowIpv6DstChoiceEnum 

type PatternFlowIpv6DstChoiceEnum string

type PatternFlowIpv6DstCounter 

type PatternFlowIpv6DstCounter interface {
	Msg() *snappipb.PatternFlowIpv6DstCounter
	SetMsg(*snappipb.PatternFlowIpv6DstCounter) PatternFlowIpv6DstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowIpv6DstCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowIpv6DstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6DstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6DstCounter added in v0.6.5 

func NewPatternFlowIpv6DstCounter() PatternFlowIpv6DstCounter

type PatternFlowIpv6FlowLabel 

type PatternFlowIpv6FlowLabel interface {
	Msg() *snappipb.PatternFlowIpv6FlowLabel
	SetMsg(*snappipb.PatternFlowIpv6FlowLabel) PatternFlowIpv6FlowLabel
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6FlowLabelChoiceEnum
	SetChoice(value PatternFlowIpv6FlowLabelChoiceEnum) PatternFlowIpv6FlowLabel
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6FlowLabel
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6FlowLabel
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6FlowLabel
	HasMetricGroup() bool
	Increment() PatternFlowIpv6FlowLabelCounter
	SetIncrement(value PatternFlowIpv6FlowLabelCounter) PatternFlowIpv6FlowLabel
	HasIncrement() bool
	Decrement() PatternFlowIpv6FlowLabelCounter
	SetDecrement(value PatternFlowIpv6FlowLabelCounter) PatternFlowIpv6FlowLabel
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6FlowLabel added in v0.6.5 

func NewPatternFlowIpv6FlowLabel() PatternFlowIpv6FlowLabel

type PatternFlowIpv6FlowLabelChoiceEnum 

type PatternFlowIpv6FlowLabelChoiceEnum string

type PatternFlowIpv6FlowLabelCounter 

type PatternFlowIpv6FlowLabelCounter interface {
	Msg() *snappipb.PatternFlowIpv6FlowLabelCounter
	SetMsg(*snappipb.PatternFlowIpv6FlowLabelCounter) PatternFlowIpv6FlowLabelCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6FlowLabelCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6FlowLabelCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6FlowLabelCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6FlowLabelCounter added in v0.6.5 

func NewPatternFlowIpv6FlowLabelCounter() PatternFlowIpv6FlowLabelCounter

type PatternFlowIpv6HopLimit 

type PatternFlowIpv6HopLimit interface {
	Msg() *snappipb.PatternFlowIpv6HopLimit
	SetMsg(*snappipb.PatternFlowIpv6HopLimit) PatternFlowIpv6HopLimit
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6HopLimitChoiceEnum
	SetChoice(value PatternFlowIpv6HopLimitChoiceEnum) PatternFlowIpv6HopLimit
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6HopLimit
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6HopLimit
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6HopLimit
	HasMetricGroup() bool
	Increment() PatternFlowIpv6HopLimitCounter
	SetIncrement(value PatternFlowIpv6HopLimitCounter) PatternFlowIpv6HopLimit
	HasIncrement() bool
	Decrement() PatternFlowIpv6HopLimitCounter
	SetDecrement(value PatternFlowIpv6HopLimitCounter) PatternFlowIpv6HopLimit
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6HopLimit added in v0.6.5 

func NewPatternFlowIpv6HopLimit() PatternFlowIpv6HopLimit

type PatternFlowIpv6HopLimitChoiceEnum 

type PatternFlowIpv6HopLimitChoiceEnum string

type PatternFlowIpv6HopLimitCounter 

type PatternFlowIpv6HopLimitCounter interface {
	Msg() *snappipb.PatternFlowIpv6HopLimitCounter
	SetMsg(*snappipb.PatternFlowIpv6HopLimitCounter) PatternFlowIpv6HopLimitCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6HopLimitCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6HopLimitCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6HopLimitCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6HopLimitCounter added in v0.6.5 

func NewPatternFlowIpv6HopLimitCounter() PatternFlowIpv6HopLimitCounter

type PatternFlowIpv6NextHeader 

type PatternFlowIpv6NextHeader interface {
	Msg() *snappipb.PatternFlowIpv6NextHeader
	SetMsg(*snappipb.PatternFlowIpv6NextHeader) PatternFlowIpv6NextHeader
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6NextHeaderChoiceEnum
	SetChoice(value PatternFlowIpv6NextHeaderChoiceEnum) PatternFlowIpv6NextHeader
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6NextHeader
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6NextHeader
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6NextHeader
	HasMetricGroup() bool
	Increment() PatternFlowIpv6NextHeaderCounter
	SetIncrement(value PatternFlowIpv6NextHeaderCounter) PatternFlowIpv6NextHeader
	HasIncrement() bool
	Decrement() PatternFlowIpv6NextHeaderCounter
	SetDecrement(value PatternFlowIpv6NextHeaderCounter) PatternFlowIpv6NextHeader
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6NextHeader added in v0.6.5 

func NewPatternFlowIpv6NextHeader() PatternFlowIpv6NextHeader

type PatternFlowIpv6NextHeaderChoiceEnum 

type PatternFlowIpv6NextHeaderChoiceEnum string

type PatternFlowIpv6NextHeaderCounter 

type PatternFlowIpv6NextHeaderCounter interface {
	Msg() *snappipb.PatternFlowIpv6NextHeaderCounter
	SetMsg(*snappipb.PatternFlowIpv6NextHeaderCounter) PatternFlowIpv6NextHeaderCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6NextHeaderCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6NextHeaderCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6NextHeaderCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6NextHeaderCounter added in v0.6.5 

func NewPatternFlowIpv6NextHeaderCounter() PatternFlowIpv6NextHeaderCounter

type PatternFlowIpv6PayloadLength 

type PatternFlowIpv6PayloadLength interface {
	Msg() *snappipb.PatternFlowIpv6PayloadLength
	SetMsg(*snappipb.PatternFlowIpv6PayloadLength) PatternFlowIpv6PayloadLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6PayloadLengthChoiceEnum
	SetChoice(value PatternFlowIpv6PayloadLengthChoiceEnum) PatternFlowIpv6PayloadLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6PayloadLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6PayloadLength
	Auto() PatternFlowIpv6PayloadLengthAutoEnum
	SetAuto(value PatternFlowIpv6PayloadLengthAutoEnum) PatternFlowIpv6PayloadLength
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6PayloadLength
	HasMetricGroup() bool
	Increment() PatternFlowIpv6PayloadLengthCounter
	SetIncrement(value PatternFlowIpv6PayloadLengthCounter) PatternFlowIpv6PayloadLength
	HasIncrement() bool
	Decrement() PatternFlowIpv6PayloadLengthCounter
	SetDecrement(value PatternFlowIpv6PayloadLengthCounter) PatternFlowIpv6PayloadLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6PayloadLength added in v0.6.5 

func NewPatternFlowIpv6PayloadLength() PatternFlowIpv6PayloadLength

type PatternFlowIpv6PayloadLengthAutoEnum 

type PatternFlowIpv6PayloadLengthAutoEnum string

type PatternFlowIpv6PayloadLengthChoiceEnum 

type PatternFlowIpv6PayloadLengthChoiceEnum string

type PatternFlowIpv6PayloadLengthCounter 

type PatternFlowIpv6PayloadLengthCounter interface {
	Msg() *snappipb.PatternFlowIpv6PayloadLengthCounter
	SetMsg(*snappipb.PatternFlowIpv6PayloadLengthCounter) PatternFlowIpv6PayloadLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6PayloadLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6PayloadLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6PayloadLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6PayloadLengthCounter added in v0.6.5 

func NewPatternFlowIpv6PayloadLengthCounter() PatternFlowIpv6PayloadLengthCounter

type PatternFlowIpv6Src 

type PatternFlowIpv6Src interface {
	Msg() *snappipb.PatternFlowIpv6Src
	SetMsg(*snappipb.PatternFlowIpv6Src) PatternFlowIpv6Src
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6SrcChoiceEnum
	SetChoice(value PatternFlowIpv6SrcChoiceEnum) PatternFlowIpv6Src
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowIpv6Src
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowIpv6Src
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6Src
	HasMetricGroup() bool
	Increment() PatternFlowIpv6SrcCounter
	SetIncrement(value PatternFlowIpv6SrcCounter) PatternFlowIpv6Src
	HasIncrement() bool
	Decrement() PatternFlowIpv6SrcCounter
	SetDecrement(value PatternFlowIpv6SrcCounter) PatternFlowIpv6Src
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6Src added in v0.6.5 

func NewPatternFlowIpv6Src() PatternFlowIpv6Src

type PatternFlowIpv6SrcChoiceEnum 

type PatternFlowIpv6SrcChoiceEnum string

type PatternFlowIpv6SrcCounter 

type PatternFlowIpv6SrcCounter interface {
	Msg() *snappipb.PatternFlowIpv6SrcCounter
	SetMsg(*snappipb.PatternFlowIpv6SrcCounter) PatternFlowIpv6SrcCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowIpv6SrcCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowIpv6SrcCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6SrcCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6SrcCounter added in v0.6.5 

func NewPatternFlowIpv6SrcCounter() PatternFlowIpv6SrcCounter

type PatternFlowIpv6TrafficClass 

type PatternFlowIpv6TrafficClass interface {
	Msg() *snappipb.PatternFlowIpv6TrafficClass
	SetMsg(*snappipb.PatternFlowIpv6TrafficClass) PatternFlowIpv6TrafficClass
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6TrafficClassChoiceEnum
	SetChoice(value PatternFlowIpv6TrafficClassChoiceEnum) PatternFlowIpv6TrafficClass
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6TrafficClass
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6TrafficClass
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6TrafficClass
	HasMetricGroup() bool
	Increment() PatternFlowIpv6TrafficClassCounter
	SetIncrement(value PatternFlowIpv6TrafficClassCounter) PatternFlowIpv6TrafficClass
	HasIncrement() bool
	Decrement() PatternFlowIpv6TrafficClassCounter
	SetDecrement(value PatternFlowIpv6TrafficClassCounter) PatternFlowIpv6TrafficClass
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6TrafficClass added in v0.6.5 

func NewPatternFlowIpv6TrafficClass() PatternFlowIpv6TrafficClass

type PatternFlowIpv6TrafficClassChoiceEnum 

type PatternFlowIpv6TrafficClassChoiceEnum string

type PatternFlowIpv6TrafficClassCounter 

type PatternFlowIpv6TrafficClassCounter interface {
	Msg() *snappipb.PatternFlowIpv6TrafficClassCounter
	SetMsg(*snappipb.PatternFlowIpv6TrafficClassCounter) PatternFlowIpv6TrafficClassCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6TrafficClassCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6TrafficClassCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6TrafficClassCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6TrafficClassCounter added in v0.6.5 

func NewPatternFlowIpv6TrafficClassCounter() PatternFlowIpv6TrafficClassCounter

type PatternFlowIpv6Version 

type PatternFlowIpv6Version interface {
	Msg() *snappipb.PatternFlowIpv6Version
	SetMsg(*snappipb.PatternFlowIpv6Version) PatternFlowIpv6Version
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowIpv6VersionChoiceEnum
	SetChoice(value PatternFlowIpv6VersionChoiceEnum) PatternFlowIpv6Version
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowIpv6Version
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowIpv6Version
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowIpv6Version
	HasMetricGroup() bool
	Increment() PatternFlowIpv6VersionCounter
	SetIncrement(value PatternFlowIpv6VersionCounter) PatternFlowIpv6Version
	HasIncrement() bool
	Decrement() PatternFlowIpv6VersionCounter
	SetDecrement(value PatternFlowIpv6VersionCounter) PatternFlowIpv6Version
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6Version added in v0.6.5 

func NewPatternFlowIpv6Version() PatternFlowIpv6Version

type PatternFlowIpv6VersionChoiceEnum 

type PatternFlowIpv6VersionChoiceEnum string

type PatternFlowIpv6VersionCounter 

type PatternFlowIpv6VersionCounter interface {
	Msg() *snappipb.PatternFlowIpv6VersionCounter
	SetMsg(*snappipb.PatternFlowIpv6VersionCounter) PatternFlowIpv6VersionCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowIpv6VersionCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowIpv6VersionCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowIpv6VersionCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowIpv6VersionCounter added in v0.6.5 

func NewPatternFlowIpv6VersionCounter() PatternFlowIpv6VersionCounter

type PatternFlowPfcPauseClassEnableVector 

type PatternFlowPfcPauseClassEnableVector interface {
	Msg() *snappipb.PatternFlowPfcPauseClassEnableVector
	SetMsg(*snappipb.PatternFlowPfcPauseClassEnableVector) PatternFlowPfcPauseClassEnableVector
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPauseClassEnableVectorChoiceEnum
	SetChoice(value PatternFlowPfcPauseClassEnableVectorChoiceEnum) PatternFlowPfcPauseClassEnableVector
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPauseClassEnableVector
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPauseClassEnableVector
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPauseClassEnableVector
	HasMetricGroup() bool
	Increment() PatternFlowPfcPauseClassEnableVectorCounter
	SetIncrement(value PatternFlowPfcPauseClassEnableVectorCounter) PatternFlowPfcPauseClassEnableVector
	HasIncrement() bool
	Decrement() PatternFlowPfcPauseClassEnableVectorCounter
	SetDecrement(value PatternFlowPfcPauseClassEnableVectorCounter) PatternFlowPfcPauseClassEnableVector
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseClassEnableVector added in v0.6.5 

func NewPatternFlowPfcPauseClassEnableVector() PatternFlowPfcPauseClassEnableVector

type PatternFlowPfcPauseClassEnableVectorChoiceEnum 

type PatternFlowPfcPauseClassEnableVectorChoiceEnum string

type PatternFlowPfcPauseClassEnableVectorCounter 

type PatternFlowPfcPauseClassEnableVectorCounter interface {
	Msg() *snappipb.PatternFlowPfcPauseClassEnableVectorCounter
	SetMsg(*snappipb.PatternFlowPfcPauseClassEnableVectorCounter) PatternFlowPfcPauseClassEnableVectorCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPauseClassEnableVectorCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPauseClassEnableVectorCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPauseClassEnableVectorCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseClassEnableVectorCounter added in v0.6.5 

func NewPatternFlowPfcPauseClassEnableVectorCounter() PatternFlowPfcPauseClassEnableVectorCounter

type PatternFlowPfcPauseControlOpCode 

type PatternFlowPfcPauseControlOpCode interface {
	Msg() *snappipb.PatternFlowPfcPauseControlOpCode
	SetMsg(*snappipb.PatternFlowPfcPauseControlOpCode) PatternFlowPfcPauseControlOpCode
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPauseControlOpCodeChoiceEnum
	SetChoice(value PatternFlowPfcPauseControlOpCodeChoiceEnum) PatternFlowPfcPauseControlOpCode
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPauseControlOpCode
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPauseControlOpCode
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPauseControlOpCode
	HasMetricGroup() bool
	Increment() PatternFlowPfcPauseControlOpCodeCounter
	SetIncrement(value PatternFlowPfcPauseControlOpCodeCounter) PatternFlowPfcPauseControlOpCode
	HasIncrement() bool
	Decrement() PatternFlowPfcPauseControlOpCodeCounter
	SetDecrement(value PatternFlowPfcPauseControlOpCodeCounter) PatternFlowPfcPauseControlOpCode
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseControlOpCode added in v0.6.5 

func NewPatternFlowPfcPauseControlOpCode() PatternFlowPfcPauseControlOpCode

type PatternFlowPfcPauseControlOpCodeChoiceEnum 

type PatternFlowPfcPauseControlOpCodeChoiceEnum string

type PatternFlowPfcPauseControlOpCodeCounter 

type PatternFlowPfcPauseControlOpCodeCounter interface {
	Msg() *snappipb.PatternFlowPfcPauseControlOpCodeCounter
	SetMsg(*snappipb.PatternFlowPfcPauseControlOpCodeCounter) PatternFlowPfcPauseControlOpCodeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPauseControlOpCodeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPauseControlOpCodeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPauseControlOpCodeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseControlOpCodeCounter added in v0.6.5 

func NewPatternFlowPfcPauseControlOpCodeCounter() PatternFlowPfcPauseControlOpCodeCounter

type PatternFlowPfcPauseDst 

type PatternFlowPfcPauseDst interface {
	Msg() *snappipb.PatternFlowPfcPauseDst
	SetMsg(*snappipb.PatternFlowPfcPauseDst) PatternFlowPfcPauseDst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPauseDstChoiceEnum
	SetChoice(value PatternFlowPfcPauseDstChoiceEnum) PatternFlowPfcPauseDst
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowPfcPauseDst
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowPfcPauseDst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPauseDst
	HasMetricGroup() bool
	Increment() PatternFlowPfcPauseDstCounter
	SetIncrement(value PatternFlowPfcPauseDstCounter) PatternFlowPfcPauseDst
	HasIncrement() bool
	Decrement() PatternFlowPfcPauseDstCounter
	SetDecrement(value PatternFlowPfcPauseDstCounter) PatternFlowPfcPauseDst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseDst added in v0.6.5 

func NewPatternFlowPfcPauseDst() PatternFlowPfcPauseDst

type PatternFlowPfcPauseDstChoiceEnum 

type PatternFlowPfcPauseDstChoiceEnum string

type PatternFlowPfcPauseDstCounter 

type PatternFlowPfcPauseDstCounter interface {
	Msg() *snappipb.PatternFlowPfcPauseDstCounter
	SetMsg(*snappipb.PatternFlowPfcPauseDstCounter) PatternFlowPfcPauseDstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowPfcPauseDstCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowPfcPauseDstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPauseDstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseDstCounter added in v0.6.5 

func NewPatternFlowPfcPauseDstCounter() PatternFlowPfcPauseDstCounter

type PatternFlowPfcPauseEtherType 

type PatternFlowPfcPauseEtherType interface {
	Msg() *snappipb.PatternFlowPfcPauseEtherType
	SetMsg(*snappipb.PatternFlowPfcPauseEtherType) PatternFlowPfcPauseEtherType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPauseEtherTypeChoiceEnum
	SetChoice(value PatternFlowPfcPauseEtherTypeChoiceEnum) PatternFlowPfcPauseEtherType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPauseEtherType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPauseEtherType
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPauseEtherType
	HasMetricGroup() bool
	Increment() PatternFlowPfcPauseEtherTypeCounter
	SetIncrement(value PatternFlowPfcPauseEtherTypeCounter) PatternFlowPfcPauseEtherType
	HasIncrement() bool
	Decrement() PatternFlowPfcPauseEtherTypeCounter
	SetDecrement(value PatternFlowPfcPauseEtherTypeCounter) PatternFlowPfcPauseEtherType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseEtherType added in v0.6.5 

func NewPatternFlowPfcPauseEtherType() PatternFlowPfcPauseEtherType

type PatternFlowPfcPauseEtherTypeChoiceEnum 

type PatternFlowPfcPauseEtherTypeChoiceEnum string

type PatternFlowPfcPauseEtherTypeCounter 

type PatternFlowPfcPauseEtherTypeCounter interface {
	Msg() *snappipb.PatternFlowPfcPauseEtherTypeCounter
	SetMsg(*snappipb.PatternFlowPfcPauseEtherTypeCounter) PatternFlowPfcPauseEtherTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPauseEtherTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPauseEtherTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPauseEtherTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseEtherTypeCounter added in v0.6.5 

func NewPatternFlowPfcPauseEtherTypeCounter() PatternFlowPfcPauseEtherTypeCounter

type PatternFlowPfcPausePauseClass0 

type PatternFlowPfcPausePauseClass0 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass0
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass0) PatternFlowPfcPausePauseClass0
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass0ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass0ChoiceEnum) PatternFlowPfcPausePauseClass0
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass0
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass0
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass0
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass0Counter
	SetIncrement(value PatternFlowPfcPausePauseClass0Counter) PatternFlowPfcPausePauseClass0
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass0Counter
	SetDecrement(value PatternFlowPfcPausePauseClass0Counter) PatternFlowPfcPausePauseClass0
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass0 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass0() PatternFlowPfcPausePauseClass0

type PatternFlowPfcPausePauseClass0ChoiceEnum 

type PatternFlowPfcPausePauseClass0ChoiceEnum string

type PatternFlowPfcPausePauseClass0Counter 

type PatternFlowPfcPausePauseClass0Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass0Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass0Counter) PatternFlowPfcPausePauseClass0Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass0Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass0Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass0Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass0Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass0Counter() PatternFlowPfcPausePauseClass0Counter

type PatternFlowPfcPausePauseClass1 

type PatternFlowPfcPausePauseClass1 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass1
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass1) PatternFlowPfcPausePauseClass1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass1ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass1ChoiceEnum) PatternFlowPfcPausePauseClass1
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass1
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass1
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass1
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass1Counter
	SetIncrement(value PatternFlowPfcPausePauseClass1Counter) PatternFlowPfcPausePauseClass1
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass1Counter
	SetDecrement(value PatternFlowPfcPausePauseClass1Counter) PatternFlowPfcPausePauseClass1
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass1 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass1() PatternFlowPfcPausePauseClass1

type PatternFlowPfcPausePauseClass1ChoiceEnum 

type PatternFlowPfcPausePauseClass1ChoiceEnum string

type PatternFlowPfcPausePauseClass1Counter 

type PatternFlowPfcPausePauseClass1Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass1Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass1Counter) PatternFlowPfcPausePauseClass1Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass1Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass1Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass1Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass1Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass1Counter() PatternFlowPfcPausePauseClass1Counter

type PatternFlowPfcPausePauseClass2 

type PatternFlowPfcPausePauseClass2 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass2
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass2) PatternFlowPfcPausePauseClass2
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass2ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass2ChoiceEnum) PatternFlowPfcPausePauseClass2
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass2
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass2
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass2
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass2Counter
	SetIncrement(value PatternFlowPfcPausePauseClass2Counter) PatternFlowPfcPausePauseClass2
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass2Counter
	SetDecrement(value PatternFlowPfcPausePauseClass2Counter) PatternFlowPfcPausePauseClass2
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass2 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass2() PatternFlowPfcPausePauseClass2

type PatternFlowPfcPausePauseClass2ChoiceEnum 

type PatternFlowPfcPausePauseClass2ChoiceEnum string

type PatternFlowPfcPausePauseClass2Counter 

type PatternFlowPfcPausePauseClass2Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass2Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass2Counter) PatternFlowPfcPausePauseClass2Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass2Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass2Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass2Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass2Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass2Counter() PatternFlowPfcPausePauseClass2Counter

type PatternFlowPfcPausePauseClass3 

type PatternFlowPfcPausePauseClass3 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass3
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass3) PatternFlowPfcPausePauseClass3
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass3ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass3ChoiceEnum) PatternFlowPfcPausePauseClass3
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass3
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass3
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass3
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass3Counter
	SetIncrement(value PatternFlowPfcPausePauseClass3Counter) PatternFlowPfcPausePauseClass3
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass3Counter
	SetDecrement(value PatternFlowPfcPausePauseClass3Counter) PatternFlowPfcPausePauseClass3
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass3 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass3() PatternFlowPfcPausePauseClass3

type PatternFlowPfcPausePauseClass3ChoiceEnum 

type PatternFlowPfcPausePauseClass3ChoiceEnum string

type PatternFlowPfcPausePauseClass3Counter 

type PatternFlowPfcPausePauseClass3Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass3Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass3Counter) PatternFlowPfcPausePauseClass3Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass3Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass3Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass3Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass3Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass3Counter() PatternFlowPfcPausePauseClass3Counter

type PatternFlowPfcPausePauseClass4 

type PatternFlowPfcPausePauseClass4 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass4
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass4) PatternFlowPfcPausePauseClass4
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass4ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass4ChoiceEnum) PatternFlowPfcPausePauseClass4
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass4
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass4
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass4
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass4Counter
	SetIncrement(value PatternFlowPfcPausePauseClass4Counter) PatternFlowPfcPausePauseClass4
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass4Counter
	SetDecrement(value PatternFlowPfcPausePauseClass4Counter) PatternFlowPfcPausePauseClass4
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass4 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass4() PatternFlowPfcPausePauseClass4

type PatternFlowPfcPausePauseClass4ChoiceEnum 

type PatternFlowPfcPausePauseClass4ChoiceEnum string

type PatternFlowPfcPausePauseClass4Counter 

type PatternFlowPfcPausePauseClass4Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass4Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass4Counter) PatternFlowPfcPausePauseClass4Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass4Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass4Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass4Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass4Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass4Counter() PatternFlowPfcPausePauseClass4Counter

type PatternFlowPfcPausePauseClass5 

type PatternFlowPfcPausePauseClass5 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass5
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass5) PatternFlowPfcPausePauseClass5
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass5ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass5ChoiceEnum) PatternFlowPfcPausePauseClass5
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass5
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass5
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass5
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass5Counter
	SetIncrement(value PatternFlowPfcPausePauseClass5Counter) PatternFlowPfcPausePauseClass5
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass5Counter
	SetDecrement(value PatternFlowPfcPausePauseClass5Counter) PatternFlowPfcPausePauseClass5
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass5 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass5() PatternFlowPfcPausePauseClass5

type PatternFlowPfcPausePauseClass5ChoiceEnum 

type PatternFlowPfcPausePauseClass5ChoiceEnum string

type PatternFlowPfcPausePauseClass5Counter 

type PatternFlowPfcPausePauseClass5Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass5Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass5Counter) PatternFlowPfcPausePauseClass5Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass5Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass5Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass5Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass5Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass5Counter() PatternFlowPfcPausePauseClass5Counter

type PatternFlowPfcPausePauseClass6 

type PatternFlowPfcPausePauseClass6 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass6
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass6) PatternFlowPfcPausePauseClass6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass6ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass6ChoiceEnum) PatternFlowPfcPausePauseClass6
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass6
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass6
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass6
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass6Counter
	SetIncrement(value PatternFlowPfcPausePauseClass6Counter) PatternFlowPfcPausePauseClass6
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass6Counter
	SetDecrement(value PatternFlowPfcPausePauseClass6Counter) PatternFlowPfcPausePauseClass6
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass6 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass6() PatternFlowPfcPausePauseClass6

type PatternFlowPfcPausePauseClass6ChoiceEnum 

type PatternFlowPfcPausePauseClass6ChoiceEnum string

type PatternFlowPfcPausePauseClass6Counter 

type PatternFlowPfcPausePauseClass6Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass6Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass6Counter) PatternFlowPfcPausePauseClass6Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass6Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass6Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass6Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass6Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass6Counter() PatternFlowPfcPausePauseClass6Counter

type PatternFlowPfcPausePauseClass7 

type PatternFlowPfcPausePauseClass7 interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass7
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass7) PatternFlowPfcPausePauseClass7
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPausePauseClass7ChoiceEnum
	SetChoice(value PatternFlowPfcPausePauseClass7ChoiceEnum) PatternFlowPfcPausePauseClass7
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPfcPausePauseClass7
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPfcPausePauseClass7
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPausePauseClass7
	HasMetricGroup() bool
	Increment() PatternFlowPfcPausePauseClass7Counter
	SetIncrement(value PatternFlowPfcPausePauseClass7Counter) PatternFlowPfcPausePauseClass7
	HasIncrement() bool
	Decrement() PatternFlowPfcPausePauseClass7Counter
	SetDecrement(value PatternFlowPfcPausePauseClass7Counter) PatternFlowPfcPausePauseClass7
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass7 added in v0.6.5 

func NewPatternFlowPfcPausePauseClass7() PatternFlowPfcPausePauseClass7

type PatternFlowPfcPausePauseClass7ChoiceEnum 

type PatternFlowPfcPausePauseClass7ChoiceEnum string

type PatternFlowPfcPausePauseClass7Counter 

type PatternFlowPfcPausePauseClass7Counter interface {
	Msg() *snappipb.PatternFlowPfcPausePauseClass7Counter
	SetMsg(*snappipb.PatternFlowPfcPausePauseClass7Counter) PatternFlowPfcPausePauseClass7Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPfcPausePauseClass7Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPfcPausePauseClass7Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPausePauseClass7Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPausePauseClass7Counter added in v0.6.5 

func NewPatternFlowPfcPausePauseClass7Counter() PatternFlowPfcPausePauseClass7Counter

type PatternFlowPfcPauseSrc 

type PatternFlowPfcPauseSrc interface {
	Msg() *snappipb.PatternFlowPfcPauseSrc
	SetMsg(*snappipb.PatternFlowPfcPauseSrc) PatternFlowPfcPauseSrc
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPfcPauseSrcChoiceEnum
	SetChoice(value PatternFlowPfcPauseSrcChoiceEnum) PatternFlowPfcPauseSrc
	HasChoice() bool
	Value() string
	SetValue(value string) PatternFlowPfcPauseSrc
	HasValue() bool
	Values() []string
	SetValues(value []string) PatternFlowPfcPauseSrc
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPfcPauseSrc
	HasMetricGroup() bool
	Increment() PatternFlowPfcPauseSrcCounter
	SetIncrement(value PatternFlowPfcPauseSrcCounter) PatternFlowPfcPauseSrc
	HasIncrement() bool
	Decrement() PatternFlowPfcPauseSrcCounter
	SetDecrement(value PatternFlowPfcPauseSrcCounter) PatternFlowPfcPauseSrc
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseSrc added in v0.6.5 

func NewPatternFlowPfcPauseSrc() PatternFlowPfcPauseSrc

type PatternFlowPfcPauseSrcChoiceEnum 

type PatternFlowPfcPauseSrcChoiceEnum string

type PatternFlowPfcPauseSrcCounter 

type PatternFlowPfcPauseSrcCounter interface {
	Msg() *snappipb.PatternFlowPfcPauseSrcCounter
	SetMsg(*snappipb.PatternFlowPfcPauseSrcCounter) PatternFlowPfcPauseSrcCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() string
	SetStart(value string) PatternFlowPfcPauseSrcCounter
	HasStart() bool
	Step() string
	SetStep(value string) PatternFlowPfcPauseSrcCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPfcPauseSrcCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPfcPauseSrcCounter added in v0.6.5 

func NewPatternFlowPfcPauseSrcCounter() PatternFlowPfcPauseSrcCounter

type PatternFlowPppAddress 

type PatternFlowPppAddress interface {
	Msg() *snappipb.PatternFlowPppAddress
	SetMsg(*snappipb.PatternFlowPppAddress) PatternFlowPppAddress
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPppAddressChoiceEnum
	SetChoice(value PatternFlowPppAddressChoiceEnum) PatternFlowPppAddress
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPppAddress
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPppAddress
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPppAddress
	HasMetricGroup() bool
	Increment() PatternFlowPppAddressCounter
	SetIncrement(value PatternFlowPppAddressCounter) PatternFlowPppAddress
	HasIncrement() bool
	Decrement() PatternFlowPppAddressCounter
	SetDecrement(value PatternFlowPppAddressCounter) PatternFlowPppAddress
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppAddress added in v0.6.5 

func NewPatternFlowPppAddress() PatternFlowPppAddress

type PatternFlowPppAddressChoiceEnum 

type PatternFlowPppAddressChoiceEnum string

type PatternFlowPppAddressCounter 

type PatternFlowPppAddressCounter interface {
	Msg() *snappipb.PatternFlowPppAddressCounter
	SetMsg(*snappipb.PatternFlowPppAddressCounter) PatternFlowPppAddressCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPppAddressCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPppAddressCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPppAddressCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppAddressCounter added in v0.6.5 

func NewPatternFlowPppAddressCounter() PatternFlowPppAddressCounter

type PatternFlowPppControl 

type PatternFlowPppControl interface {
	Msg() *snappipb.PatternFlowPppControl
	SetMsg(*snappipb.PatternFlowPppControl) PatternFlowPppControl
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPppControlChoiceEnum
	SetChoice(value PatternFlowPppControlChoiceEnum) PatternFlowPppControl
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPppControl
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPppControl
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPppControl
	HasMetricGroup() bool
	Increment() PatternFlowPppControlCounter
	SetIncrement(value PatternFlowPppControlCounter) PatternFlowPppControl
	HasIncrement() bool
	Decrement() PatternFlowPppControlCounter
	SetDecrement(value PatternFlowPppControlCounter) PatternFlowPppControl
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppControl added in v0.6.5 

func NewPatternFlowPppControl() PatternFlowPppControl

type PatternFlowPppControlChoiceEnum 

type PatternFlowPppControlChoiceEnum string

type PatternFlowPppControlCounter 

type PatternFlowPppControlCounter interface {
	Msg() *snappipb.PatternFlowPppControlCounter
	SetMsg(*snappipb.PatternFlowPppControlCounter) PatternFlowPppControlCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPppControlCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPppControlCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPppControlCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppControlCounter added in v0.6.5 

func NewPatternFlowPppControlCounter() PatternFlowPppControlCounter

type PatternFlowPppProtocolType 

type PatternFlowPppProtocolType interface {
	Msg() *snappipb.PatternFlowPppProtocolType
	SetMsg(*snappipb.PatternFlowPppProtocolType) PatternFlowPppProtocolType
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowPppProtocolTypeChoiceEnum
	SetChoice(value PatternFlowPppProtocolTypeChoiceEnum) PatternFlowPppProtocolType
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowPppProtocolType
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowPppProtocolType
	Auto() PatternFlowPppProtocolTypeAutoEnum
	SetAuto(value PatternFlowPppProtocolTypeAutoEnum) PatternFlowPppProtocolType
	HasAuto() bool
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowPppProtocolType
	HasMetricGroup() bool
	Increment() PatternFlowPppProtocolTypeCounter
	SetIncrement(value PatternFlowPppProtocolTypeCounter) PatternFlowPppProtocolType
	HasIncrement() bool
	Decrement() PatternFlowPppProtocolTypeCounter
	SetDecrement(value PatternFlowPppProtocolTypeCounter) PatternFlowPppProtocolType
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppProtocolType added in v0.6.5 

func NewPatternFlowPppProtocolType() PatternFlowPppProtocolType

type PatternFlowPppProtocolTypeAutoEnum 

type PatternFlowPppProtocolTypeAutoEnum string

type PatternFlowPppProtocolTypeChoiceEnum 

type PatternFlowPppProtocolTypeChoiceEnum string

type PatternFlowPppProtocolTypeCounter 

type PatternFlowPppProtocolTypeCounter interface {
	Msg() *snappipb.PatternFlowPppProtocolTypeCounter
	SetMsg(*snappipb.PatternFlowPppProtocolTypeCounter) PatternFlowPppProtocolTypeCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowPppProtocolTypeCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowPppProtocolTypeCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowPppProtocolTypeCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowPppProtocolTypeCounter added in v0.6.5 

func NewPatternFlowPppProtocolTypeCounter() PatternFlowPppProtocolTypeCounter

type PatternFlowTcpAckNum 

type PatternFlowTcpAckNum interface {
	Msg() *snappipb.PatternFlowTcpAckNum
	SetMsg(*snappipb.PatternFlowTcpAckNum) PatternFlowTcpAckNum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpAckNumChoiceEnum
	SetChoice(value PatternFlowTcpAckNumChoiceEnum) PatternFlowTcpAckNum
	HasChoice() bool
	Value() int64
	SetValue(value int64) PatternFlowTcpAckNum
	HasValue() bool
	Values() []int64
	SetValues(value []int64) PatternFlowTcpAckNum
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpAckNum
	HasMetricGroup() bool
	Increment() PatternFlowTcpAckNumCounter
	SetIncrement(value PatternFlowTcpAckNumCounter) PatternFlowTcpAckNum
	HasIncrement() bool
	Decrement() PatternFlowTcpAckNumCounter
	SetDecrement(value PatternFlowTcpAckNumCounter) PatternFlowTcpAckNum
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpAckNum added in v0.6.5 

func NewPatternFlowTcpAckNum() PatternFlowTcpAckNum

type PatternFlowTcpAckNumChoiceEnum 

type PatternFlowTcpAckNumChoiceEnum string

type PatternFlowTcpAckNumCounter 

type PatternFlowTcpAckNumCounter interface {
	Msg() *snappipb.PatternFlowTcpAckNumCounter
	SetMsg(*snappipb.PatternFlowTcpAckNumCounter) PatternFlowTcpAckNumCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int64
	SetStart(value int64) PatternFlowTcpAckNumCounter
	HasStart() bool
	Step() int64
	SetStep(value int64) PatternFlowTcpAckNumCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpAckNumCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpAckNumCounter added in v0.6.5 

func NewPatternFlowTcpAckNumCounter() PatternFlowTcpAckNumCounter

type PatternFlowTcpCtlAck 

type PatternFlowTcpCtlAck interface {
	Msg() *snappipb.PatternFlowTcpCtlAck
	SetMsg(*snappipb.PatternFlowTcpCtlAck) PatternFlowTcpCtlAck
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlAckChoiceEnum
	SetChoice(value PatternFlowTcpCtlAckChoiceEnum) PatternFlowTcpCtlAck
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlAck
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlAck
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlAck
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlAckCounter
	SetIncrement(value PatternFlowTcpCtlAckCounter) PatternFlowTcpCtlAck
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlAckCounter
	SetDecrement(value PatternFlowTcpCtlAckCounter) PatternFlowTcpCtlAck
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlAck added in v0.6.5 

func NewPatternFlowTcpCtlAck() PatternFlowTcpCtlAck

type PatternFlowTcpCtlAckChoiceEnum 

type PatternFlowTcpCtlAckChoiceEnum string

type PatternFlowTcpCtlAckCounter 

type PatternFlowTcpCtlAckCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlAckCounter
	SetMsg(*snappipb.PatternFlowTcpCtlAckCounter) PatternFlowTcpCtlAckCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlAckCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlAckCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlAckCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlAckCounter added in v0.6.5 

func NewPatternFlowTcpCtlAckCounter() PatternFlowTcpCtlAckCounter

type PatternFlowTcpCtlFin 

type PatternFlowTcpCtlFin interface {
	Msg() *snappipb.PatternFlowTcpCtlFin
	SetMsg(*snappipb.PatternFlowTcpCtlFin) PatternFlowTcpCtlFin
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlFinChoiceEnum
	SetChoice(value PatternFlowTcpCtlFinChoiceEnum) PatternFlowTcpCtlFin
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlFin
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlFin
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlFin
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlFinCounter
	SetIncrement(value PatternFlowTcpCtlFinCounter) PatternFlowTcpCtlFin
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlFinCounter
	SetDecrement(value PatternFlowTcpCtlFinCounter) PatternFlowTcpCtlFin
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlFin added in v0.6.5 

func NewPatternFlowTcpCtlFin() PatternFlowTcpCtlFin

type PatternFlowTcpCtlFinChoiceEnum 

type PatternFlowTcpCtlFinChoiceEnum string

type PatternFlowTcpCtlFinCounter 

type PatternFlowTcpCtlFinCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlFinCounter
	SetMsg(*snappipb.PatternFlowTcpCtlFinCounter) PatternFlowTcpCtlFinCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlFinCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlFinCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlFinCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlFinCounter added in v0.6.5 

func NewPatternFlowTcpCtlFinCounter() PatternFlowTcpCtlFinCounter

type PatternFlowTcpCtlPsh 

type PatternFlowTcpCtlPsh interface {
	Msg() *snappipb.PatternFlowTcpCtlPsh
	SetMsg(*snappipb.PatternFlowTcpCtlPsh) PatternFlowTcpCtlPsh
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlPshChoiceEnum
	SetChoice(value PatternFlowTcpCtlPshChoiceEnum) PatternFlowTcpCtlPsh
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlPsh
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlPsh
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlPsh
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlPshCounter
	SetIncrement(value PatternFlowTcpCtlPshCounter) PatternFlowTcpCtlPsh
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlPshCounter
	SetDecrement(value PatternFlowTcpCtlPshCounter) PatternFlowTcpCtlPsh
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlPsh added in v0.6.5 

func NewPatternFlowTcpCtlPsh() PatternFlowTcpCtlPsh

type PatternFlowTcpCtlPshChoiceEnum 

type PatternFlowTcpCtlPshChoiceEnum string

type PatternFlowTcpCtlPshCounter 

type PatternFlowTcpCtlPshCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlPshCounter
	SetMsg(*snappipb.PatternFlowTcpCtlPshCounter) PatternFlowTcpCtlPshCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlPshCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlPshCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlPshCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlPshCounter added in v0.6.5 

func NewPatternFlowTcpCtlPshCounter() PatternFlowTcpCtlPshCounter

type PatternFlowTcpCtlRst 

type PatternFlowTcpCtlRst interface {
	Msg() *snappipb.PatternFlowTcpCtlRst
	SetMsg(*snappipb.PatternFlowTcpCtlRst) PatternFlowTcpCtlRst
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlRstChoiceEnum
	SetChoice(value PatternFlowTcpCtlRstChoiceEnum) PatternFlowTcpCtlRst
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlRst
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlRst
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlRst
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlRstCounter
	SetIncrement(value PatternFlowTcpCtlRstCounter) PatternFlowTcpCtlRst
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlRstCounter
	SetDecrement(value PatternFlowTcpCtlRstCounter) PatternFlowTcpCtlRst
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlRst added in v0.6.5 

func NewPatternFlowTcpCtlRst() PatternFlowTcpCtlRst

type PatternFlowTcpCtlRstChoiceEnum 

type PatternFlowTcpCtlRstChoiceEnum string

type PatternFlowTcpCtlRstCounter 

type PatternFlowTcpCtlRstCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlRstCounter
	SetMsg(*snappipb.PatternFlowTcpCtlRstCounter) PatternFlowTcpCtlRstCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlRstCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlRstCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlRstCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlRstCounter added in v0.6.5 

func NewPatternFlowTcpCtlRstCounter() PatternFlowTcpCtlRstCounter

type PatternFlowTcpCtlSyn 

type PatternFlowTcpCtlSyn interface {
	Msg() *snappipb.PatternFlowTcpCtlSyn
	SetMsg(*snappipb.PatternFlowTcpCtlSyn) PatternFlowTcpCtlSyn
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlSynChoiceEnum
	SetChoice(value PatternFlowTcpCtlSynChoiceEnum) PatternFlowTcpCtlSyn
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlSyn
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlSyn
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlSyn
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlSynCounter
	SetIncrement(value PatternFlowTcpCtlSynCounter) PatternFlowTcpCtlSyn
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlSynCounter
	SetDecrement(value PatternFlowTcpCtlSynCounter) PatternFlowTcpCtlSyn
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlSyn added in v0.6.5 

func NewPatternFlowTcpCtlSyn() PatternFlowTcpCtlSyn

type PatternFlowTcpCtlSynChoiceEnum 

type PatternFlowTcpCtlSynChoiceEnum string

type PatternFlowTcpCtlSynCounter 

type PatternFlowTcpCtlSynCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlSynCounter
	SetMsg(*snappipb.PatternFlowTcpCtlSynCounter) PatternFlowTcpCtlSynCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlSynCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlSynCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlSynCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlSynCounter added in v0.6.5 

func NewPatternFlowTcpCtlSynCounter() PatternFlowTcpCtlSynCounter

type PatternFlowTcpCtlUrg 

type PatternFlowTcpCtlUrg interface {
	Msg() *snappipb.PatternFlowTcpCtlUrg
	SetMsg(*snappipb.PatternFlowTcpCtlUrg) PatternFlowTcpCtlUrg
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpCtlUrgChoiceEnum
	SetChoice(value PatternFlowTcpCtlUrgChoiceEnum) PatternFlowTcpCtlUrg
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpCtlUrg
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpCtlUrg
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpCtlUrg
	HasMetricGroup() bool
	Increment() PatternFlowTcpCtlUrgCounter
	SetIncrement(value PatternFlowTcpCtlUrgCounter) PatternFlowTcpCtlUrg
	HasIncrement() bool
	Decrement() PatternFlowTcpCtlUrgCounter
	SetDecrement(value PatternFlowTcpCtlUrgCounter) PatternFlowTcpCtlUrg
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlUrg added in v0.6.5 

func NewPatternFlowTcpCtlUrg() PatternFlowTcpCtlUrg

type PatternFlowTcpCtlUrgChoiceEnum 

type PatternFlowTcpCtlUrgChoiceEnum string

type PatternFlowTcpCtlUrgCounter 

type PatternFlowTcpCtlUrgCounter interface {
	Msg() *snappipb.PatternFlowTcpCtlUrgCounter
	SetMsg(*snappipb.PatternFlowTcpCtlUrgCounter) PatternFlowTcpCtlUrgCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpCtlUrgCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpCtlUrgCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpCtlUrgCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpCtlUrgCounter added in v0.6.5 

func NewPatternFlowTcpCtlUrgCounter() PatternFlowTcpCtlUrgCounter

type PatternFlowTcpDataOffset 

type PatternFlowTcpDataOffset interface {
	Msg() *snappipb.PatternFlowTcpDataOffset
	SetMsg(*snappipb.PatternFlowTcpDataOffset) PatternFlowTcpDataOffset
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpDataOffsetChoiceEnum
	SetChoice(value PatternFlowTcpDataOffsetChoiceEnum) PatternFlowTcpDataOffset
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpDataOffset
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpDataOffset
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpDataOffset
	HasMetricGroup() bool
	Increment() PatternFlowTcpDataOffsetCounter
	SetIncrement(value PatternFlowTcpDataOffsetCounter) PatternFlowTcpDataOffset
	HasIncrement() bool
	Decrement() PatternFlowTcpDataOffsetCounter
	SetDecrement(value PatternFlowTcpDataOffsetCounter) PatternFlowTcpDataOffset
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpDataOffset added in v0.6.5 

func NewPatternFlowTcpDataOffset() PatternFlowTcpDataOffset

type PatternFlowTcpDataOffsetChoiceEnum 

type PatternFlowTcpDataOffsetChoiceEnum string

type PatternFlowTcpDataOffsetCounter 

type PatternFlowTcpDataOffsetCounter interface {
	Msg() *snappipb.PatternFlowTcpDataOffsetCounter
	SetMsg(*snappipb.PatternFlowTcpDataOffsetCounter) PatternFlowTcpDataOffsetCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpDataOffsetCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpDataOffsetCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpDataOffsetCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpDataOffsetCounter added in v0.6.5 

func NewPatternFlowTcpDataOffsetCounter() PatternFlowTcpDataOffsetCounter

type PatternFlowTcpDstPort 

type PatternFlowTcpDstPort interface {
	Msg() *snappipb.PatternFlowTcpDstPort
	SetMsg(*snappipb.PatternFlowTcpDstPort) PatternFlowTcpDstPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpDstPortChoiceEnum
	SetChoice(value PatternFlowTcpDstPortChoiceEnum) PatternFlowTcpDstPort
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpDstPort
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpDstPort
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpDstPort
	HasMetricGroup() bool
	Increment() PatternFlowTcpDstPortCounter
	SetIncrement(value PatternFlowTcpDstPortCounter) PatternFlowTcpDstPort
	HasIncrement() bool
	Decrement() PatternFlowTcpDstPortCounter
	SetDecrement(value PatternFlowTcpDstPortCounter) PatternFlowTcpDstPort
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpDstPort added in v0.6.5 

func NewPatternFlowTcpDstPort() PatternFlowTcpDstPort

type PatternFlowTcpDstPortChoiceEnum 

type PatternFlowTcpDstPortChoiceEnum string

type PatternFlowTcpDstPortCounter 

type PatternFlowTcpDstPortCounter interface {
	Msg() *snappipb.PatternFlowTcpDstPortCounter
	SetMsg(*snappipb.PatternFlowTcpDstPortCounter) PatternFlowTcpDstPortCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpDstPortCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpDstPortCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpDstPortCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpDstPortCounter added in v0.6.5 

func NewPatternFlowTcpDstPortCounter() PatternFlowTcpDstPortCounter

type PatternFlowTcpEcnCwr 

type PatternFlowTcpEcnCwr interface {
	Msg() *snappipb.PatternFlowTcpEcnCwr
	SetMsg(*snappipb.PatternFlowTcpEcnCwr) PatternFlowTcpEcnCwr
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpEcnCwrChoiceEnum
	SetChoice(value PatternFlowTcpEcnCwrChoiceEnum) PatternFlowTcpEcnCwr
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpEcnCwr
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpEcnCwr
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpEcnCwr
	HasMetricGroup() bool
	Increment() PatternFlowTcpEcnCwrCounter
	SetIncrement(value PatternFlowTcpEcnCwrCounter) PatternFlowTcpEcnCwr
	HasIncrement() bool
	Decrement() PatternFlowTcpEcnCwrCounter
	SetDecrement(value PatternFlowTcpEcnCwrCounter) PatternFlowTcpEcnCwr
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnCwr added in v0.6.5 

func NewPatternFlowTcpEcnCwr() PatternFlowTcpEcnCwr

type PatternFlowTcpEcnCwrChoiceEnum 

type PatternFlowTcpEcnCwrChoiceEnum string

type PatternFlowTcpEcnCwrCounter 

type PatternFlowTcpEcnCwrCounter interface {
	Msg() *snappipb.PatternFlowTcpEcnCwrCounter
	SetMsg(*snappipb.PatternFlowTcpEcnCwrCounter) PatternFlowTcpEcnCwrCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpEcnCwrCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpEcnCwrCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpEcnCwrCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnCwrCounter added in v0.6.5 

func NewPatternFlowTcpEcnCwrCounter() PatternFlowTcpEcnCwrCounter

type PatternFlowTcpEcnEcho 

type PatternFlowTcpEcnEcho interface {
	Msg() *snappipb.PatternFlowTcpEcnEcho
	SetMsg(*snappipb.PatternFlowTcpEcnEcho) PatternFlowTcpEcnEcho
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpEcnEchoChoiceEnum
	SetChoice(value PatternFlowTcpEcnEchoChoiceEnum) PatternFlowTcpEcnEcho
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpEcnEcho
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpEcnEcho
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpEcnEcho
	HasMetricGroup() bool
	Increment() PatternFlowTcpEcnEchoCounter
	SetIncrement(value PatternFlowTcpEcnEchoCounter) PatternFlowTcpEcnEcho
	HasIncrement() bool
	Decrement() PatternFlowTcpEcnEchoCounter
	SetDecrement(value PatternFlowTcpEcnEchoCounter) PatternFlowTcpEcnEcho
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnEcho added in v0.6.5 

func NewPatternFlowTcpEcnEcho() PatternFlowTcpEcnEcho

type PatternFlowTcpEcnEchoChoiceEnum 

type PatternFlowTcpEcnEchoChoiceEnum string

type PatternFlowTcpEcnEchoCounter 

type PatternFlowTcpEcnEchoCounter interface {
	Msg() *snappipb.PatternFlowTcpEcnEchoCounter
	SetMsg(*snappipb.PatternFlowTcpEcnEchoCounter) PatternFlowTcpEcnEchoCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpEcnEchoCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpEcnEchoCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpEcnEchoCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnEchoCounter added in v0.6.5 

func NewPatternFlowTcpEcnEchoCounter() PatternFlowTcpEcnEchoCounter

type PatternFlowTcpEcnNs 

type PatternFlowTcpEcnNs interface {
	Msg() *snappipb.PatternFlowTcpEcnNs
	SetMsg(*snappipb.PatternFlowTcpEcnNs) PatternFlowTcpEcnNs
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpEcnNsChoiceEnum
	SetChoice(value PatternFlowTcpEcnNsChoiceEnum) PatternFlowTcpEcnNs
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpEcnNs
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpEcnNs
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpEcnNs
	HasMetricGroup() bool
	Increment() PatternFlowTcpEcnNsCounter
	SetIncrement(value PatternFlowTcpEcnNsCounter) PatternFlowTcpEcnNs
	HasIncrement() bool
	Decrement() PatternFlowTcpEcnNsCounter
	SetDecrement(value PatternFlowTcpEcnNsCounter) PatternFlowTcpEcnNs
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnNs added in v0.6.5 

func NewPatternFlowTcpEcnNs() PatternFlowTcpEcnNs

type PatternFlowTcpEcnNsChoiceEnum 

type PatternFlowTcpEcnNsChoiceEnum string

type PatternFlowTcpEcnNsCounter 

type PatternFlowTcpEcnNsCounter interface {
	Msg() *snappipb.PatternFlowTcpEcnNsCounter
	SetMsg(*snappipb.PatternFlowTcpEcnNsCounter) PatternFlowTcpEcnNsCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpEcnNsCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpEcnNsCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpEcnNsCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpEcnNsCounter added in v0.6.5 

func NewPatternFlowTcpEcnNsCounter() PatternFlowTcpEcnNsCounter

type PatternFlowTcpSeqNum 

type PatternFlowTcpSeqNum interface {
	Msg() *snappipb.PatternFlowTcpSeqNum
	SetMsg(*snappipb.PatternFlowTcpSeqNum) PatternFlowTcpSeqNum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpSeqNumChoiceEnum
	SetChoice(value PatternFlowTcpSeqNumChoiceEnum) PatternFlowTcpSeqNum
	HasChoice() bool
	Value() int64
	SetValue(value int64) PatternFlowTcpSeqNum
	HasValue() bool
	Values() []int64
	SetValues(value []int64) PatternFlowTcpSeqNum
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpSeqNum
	HasMetricGroup() bool
	Increment() PatternFlowTcpSeqNumCounter
	SetIncrement(value PatternFlowTcpSeqNumCounter) PatternFlowTcpSeqNum
	HasIncrement() bool
	Decrement() PatternFlowTcpSeqNumCounter
	SetDecrement(value PatternFlowTcpSeqNumCounter) PatternFlowTcpSeqNum
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpSeqNum added in v0.6.5 

func NewPatternFlowTcpSeqNum() PatternFlowTcpSeqNum

type PatternFlowTcpSeqNumChoiceEnum 

type PatternFlowTcpSeqNumChoiceEnum string

type PatternFlowTcpSeqNumCounter 

type PatternFlowTcpSeqNumCounter interface {
	Msg() *snappipb.PatternFlowTcpSeqNumCounter
	SetMsg(*snappipb.PatternFlowTcpSeqNumCounter) PatternFlowTcpSeqNumCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int64
	SetStart(value int64) PatternFlowTcpSeqNumCounter
	HasStart() bool
	Step() int64
	SetStep(value int64) PatternFlowTcpSeqNumCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpSeqNumCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpSeqNumCounter added in v0.6.5 

func NewPatternFlowTcpSeqNumCounter() PatternFlowTcpSeqNumCounter

type PatternFlowTcpSrcPort 

type PatternFlowTcpSrcPort interface {
	Msg() *snappipb.PatternFlowTcpSrcPort
	SetMsg(*snappipb.PatternFlowTcpSrcPort) PatternFlowTcpSrcPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpSrcPortChoiceEnum
	SetChoice(value PatternFlowTcpSrcPortChoiceEnum) PatternFlowTcpSrcPort
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpSrcPort
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpSrcPort
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpSrcPort
	HasMetricGroup() bool
	Increment() PatternFlowTcpSrcPortCounter
	SetIncrement(value PatternFlowTcpSrcPortCounter) PatternFlowTcpSrcPort
	HasIncrement() bool
	Decrement() PatternFlowTcpSrcPortCounter
	SetDecrement(value PatternFlowTcpSrcPortCounter) PatternFlowTcpSrcPort
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpSrcPort added in v0.6.5 

func NewPatternFlowTcpSrcPort() PatternFlowTcpSrcPort

type PatternFlowTcpSrcPortChoiceEnum 

type PatternFlowTcpSrcPortChoiceEnum string

type PatternFlowTcpSrcPortCounter 

type PatternFlowTcpSrcPortCounter interface {
	Msg() *snappipb.PatternFlowTcpSrcPortCounter
	SetMsg(*snappipb.PatternFlowTcpSrcPortCounter) PatternFlowTcpSrcPortCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpSrcPortCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpSrcPortCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpSrcPortCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpSrcPortCounter added in v0.6.5 

func NewPatternFlowTcpSrcPortCounter() PatternFlowTcpSrcPortCounter

type PatternFlowTcpWindow 

type PatternFlowTcpWindow interface {
	Msg() *snappipb.PatternFlowTcpWindow
	SetMsg(*snappipb.PatternFlowTcpWindow) PatternFlowTcpWindow
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowTcpWindowChoiceEnum
	SetChoice(value PatternFlowTcpWindowChoiceEnum) PatternFlowTcpWindow
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowTcpWindow
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowTcpWindow
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowTcpWindow
	HasMetricGroup() bool
	Increment() PatternFlowTcpWindowCounter
	SetIncrement(value PatternFlowTcpWindowCounter) PatternFlowTcpWindow
	HasIncrement() bool
	Decrement() PatternFlowTcpWindowCounter
	SetDecrement(value PatternFlowTcpWindowCounter) PatternFlowTcpWindow
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpWindow added in v0.6.5 

func NewPatternFlowTcpWindow() PatternFlowTcpWindow

type PatternFlowTcpWindowChoiceEnum 

type PatternFlowTcpWindowChoiceEnum string

type PatternFlowTcpWindowCounter 

type PatternFlowTcpWindowCounter interface {
	Msg() *snappipb.PatternFlowTcpWindowCounter
	SetMsg(*snappipb.PatternFlowTcpWindowCounter) PatternFlowTcpWindowCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowTcpWindowCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowTcpWindowCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowTcpWindowCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowTcpWindowCounter added in v0.6.5 

func NewPatternFlowTcpWindowCounter() PatternFlowTcpWindowCounter

type PatternFlowUdpChecksum 

type PatternFlowUdpChecksum interface {
	Msg() *snappipb.PatternFlowUdpChecksum
	SetMsg(*snappipb.PatternFlowUdpChecksum) PatternFlowUdpChecksum
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowUdpChecksumChoiceEnum
	SetChoice(value PatternFlowUdpChecksumChoiceEnum) PatternFlowUdpChecksum
	Generated() PatternFlowUdpChecksumGeneratedEnum
	SetGenerated(value PatternFlowUdpChecksumGeneratedEnum) PatternFlowUdpChecksum
	HasGenerated() bool
	Custom() int32
	SetCustom(value int32) PatternFlowUdpChecksum
	HasCustom() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpChecksum added in v0.6.5 

func NewPatternFlowUdpChecksum() PatternFlowUdpChecksum

type PatternFlowUdpChecksumChoiceEnum 

type PatternFlowUdpChecksumChoiceEnum string

type PatternFlowUdpChecksumGeneratedEnum 

type PatternFlowUdpChecksumGeneratedEnum string

type PatternFlowUdpDstPort 

type PatternFlowUdpDstPort interface {
	Msg() *snappipb.PatternFlowUdpDstPort
	SetMsg(*snappipb.PatternFlowUdpDstPort) PatternFlowUdpDstPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowUdpDstPortChoiceEnum
	SetChoice(value PatternFlowUdpDstPortChoiceEnum) PatternFlowUdpDstPort
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowUdpDstPort
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowUdpDstPort
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowUdpDstPort
	HasMetricGroup() bool
	Increment() PatternFlowUdpDstPortCounter
	SetIncrement(value PatternFlowUdpDstPortCounter) PatternFlowUdpDstPort
	HasIncrement() bool
	Decrement() PatternFlowUdpDstPortCounter
	SetDecrement(value PatternFlowUdpDstPortCounter) PatternFlowUdpDstPort
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpDstPort added in v0.6.5 

func NewPatternFlowUdpDstPort() PatternFlowUdpDstPort

type PatternFlowUdpDstPortChoiceEnum 

type PatternFlowUdpDstPortChoiceEnum string

type PatternFlowUdpDstPortCounter 

type PatternFlowUdpDstPortCounter interface {
	Msg() *snappipb.PatternFlowUdpDstPortCounter
	SetMsg(*snappipb.PatternFlowUdpDstPortCounter) PatternFlowUdpDstPortCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowUdpDstPortCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowUdpDstPortCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowUdpDstPortCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpDstPortCounter added in v0.6.5 

func NewPatternFlowUdpDstPortCounter() PatternFlowUdpDstPortCounter

type PatternFlowUdpLength 

type PatternFlowUdpLength interface {
	Msg() *snappipb.PatternFlowUdpLength
	SetMsg(*snappipb.PatternFlowUdpLength) PatternFlowUdpLength
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowUdpLengthChoiceEnum
	SetChoice(value PatternFlowUdpLengthChoiceEnum) PatternFlowUdpLength
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowUdpLength
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowUdpLength
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowUdpLength
	HasMetricGroup() bool
	Increment() PatternFlowUdpLengthCounter
	SetIncrement(value PatternFlowUdpLengthCounter) PatternFlowUdpLength
	HasIncrement() bool
	Decrement() PatternFlowUdpLengthCounter
	SetDecrement(value PatternFlowUdpLengthCounter) PatternFlowUdpLength
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpLength added in v0.6.5 

func NewPatternFlowUdpLength() PatternFlowUdpLength

type PatternFlowUdpLengthChoiceEnum 

type PatternFlowUdpLengthChoiceEnum string

type PatternFlowUdpLengthCounter 

type PatternFlowUdpLengthCounter interface {
	Msg() *snappipb.PatternFlowUdpLengthCounter
	SetMsg(*snappipb.PatternFlowUdpLengthCounter) PatternFlowUdpLengthCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowUdpLengthCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowUdpLengthCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowUdpLengthCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpLengthCounter added in v0.6.5 

func NewPatternFlowUdpLengthCounter() PatternFlowUdpLengthCounter

type PatternFlowUdpSrcPort 

type PatternFlowUdpSrcPort interface {
	Msg() *snappipb.PatternFlowUdpSrcPort
	SetMsg(*snappipb.PatternFlowUdpSrcPort) PatternFlowUdpSrcPort
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowUdpSrcPortChoiceEnum
	SetChoice(value PatternFlowUdpSrcPortChoiceEnum) PatternFlowUdpSrcPort
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowUdpSrcPort
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowUdpSrcPort
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowUdpSrcPort
	HasMetricGroup() bool
	Increment() PatternFlowUdpSrcPortCounter
	SetIncrement(value PatternFlowUdpSrcPortCounter) PatternFlowUdpSrcPort
	HasIncrement() bool
	Decrement() PatternFlowUdpSrcPortCounter
	SetDecrement(value PatternFlowUdpSrcPortCounter) PatternFlowUdpSrcPort
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpSrcPort added in v0.6.5 

func NewPatternFlowUdpSrcPort() PatternFlowUdpSrcPort

type PatternFlowUdpSrcPortChoiceEnum 

type PatternFlowUdpSrcPortChoiceEnum string

type PatternFlowUdpSrcPortCounter 

type PatternFlowUdpSrcPortCounter interface {
	Msg() *snappipb.PatternFlowUdpSrcPortCounter
	SetMsg(*snappipb.PatternFlowUdpSrcPortCounter) PatternFlowUdpSrcPortCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowUdpSrcPortCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowUdpSrcPortCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowUdpSrcPortCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowUdpSrcPortCounter added in v0.6.5 

func NewPatternFlowUdpSrcPortCounter() PatternFlowUdpSrcPortCounter

type PatternFlowVlanCfi 

type PatternFlowVlanCfi interface {
	Msg() *snappipb.PatternFlowVlanCfi
	SetMsg(*snappipb.PatternFlowVlanCfi) PatternFlowVlanCfi
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVlanCfiChoiceEnum
	SetChoice(value PatternFlowVlanCfiChoiceEnum) PatternFlowVlanCfi
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVlanCfi
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVlanCfi
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVlanCfi
	HasMetricGroup() bool
	Increment() PatternFlowVlanCfiCounter
	SetIncrement(value PatternFlowVlanCfiCounter) PatternFlowVlanCfi
	HasIncrement() bool
	Decrement() PatternFlowVlanCfiCounter
	SetDecrement(value PatternFlowVlanCfiCounter) PatternFlowVlanCfi
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanCfi added in v0.6.5 

func NewPatternFlowVlanCfi() PatternFlowVlanCfi

type PatternFlowVlanCfiChoiceEnum 

type PatternFlowVlanCfiChoiceEnum string

type PatternFlowVlanCfiCounter 

type PatternFlowVlanCfiCounter interface {
	Msg() *snappipb.PatternFlowVlanCfiCounter
	SetMsg(*snappipb.PatternFlowVlanCfiCounter) PatternFlowVlanCfiCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVlanCfiCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVlanCfiCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVlanCfiCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanCfiCounter added in v0.6.5 

func NewPatternFlowVlanCfiCounter() PatternFlowVlanCfiCounter

type PatternFlowVlanId 

type PatternFlowVlanId interface {
	Msg() *snappipb.PatternFlowVlanId
	SetMsg(*snappipb.PatternFlowVlanId) PatternFlowVlanId
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVlanIdChoiceEnum
	SetChoice(value PatternFlowVlanIdChoiceEnum) PatternFlowVlanId
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVlanId
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVlanId
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVlanId
	HasMetricGroup() bool
	Increment() PatternFlowVlanIdCounter
	SetIncrement(value PatternFlowVlanIdCounter) PatternFlowVlanId
	HasIncrement() bool
	Decrement() PatternFlowVlanIdCounter
	SetDecrement(value PatternFlowVlanIdCounter) PatternFlowVlanId
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanId added in v0.6.5 

func NewPatternFlowVlanId() PatternFlowVlanId

type PatternFlowVlanIdChoiceEnum 

type PatternFlowVlanIdChoiceEnum string

type PatternFlowVlanIdCounter 

type PatternFlowVlanIdCounter interface {
	Msg() *snappipb.PatternFlowVlanIdCounter
	SetMsg(*snappipb.PatternFlowVlanIdCounter) PatternFlowVlanIdCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVlanIdCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVlanIdCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVlanIdCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanIdCounter added in v0.6.5 

func NewPatternFlowVlanIdCounter() PatternFlowVlanIdCounter

type PatternFlowVlanPriority 

type PatternFlowVlanPriority interface {
	Msg() *snappipb.PatternFlowVlanPriority
	SetMsg(*snappipb.PatternFlowVlanPriority) PatternFlowVlanPriority
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVlanPriorityChoiceEnum
	SetChoice(value PatternFlowVlanPriorityChoiceEnum) PatternFlowVlanPriority
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVlanPriority
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVlanPriority
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVlanPriority
	HasMetricGroup() bool
	Increment() PatternFlowVlanPriorityCounter
	SetIncrement(value PatternFlowVlanPriorityCounter) PatternFlowVlanPriority
	HasIncrement() bool
	Decrement() PatternFlowVlanPriorityCounter
	SetDecrement(value PatternFlowVlanPriorityCounter) PatternFlowVlanPriority
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanPriority added in v0.6.5 

func NewPatternFlowVlanPriority() PatternFlowVlanPriority

type PatternFlowVlanPriorityChoiceEnum 

type PatternFlowVlanPriorityChoiceEnum string

type PatternFlowVlanPriorityCounter 

type PatternFlowVlanPriorityCounter interface {
	Msg() *snappipb.PatternFlowVlanPriorityCounter
	SetMsg(*snappipb.PatternFlowVlanPriorityCounter) PatternFlowVlanPriorityCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVlanPriorityCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVlanPriorityCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVlanPriorityCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanPriorityCounter added in v0.6.5 

func NewPatternFlowVlanPriorityCounter() PatternFlowVlanPriorityCounter

type PatternFlowVlanTpid 

type PatternFlowVlanTpid interface {
	Msg() *snappipb.PatternFlowVlanTpid
	SetMsg(*snappipb.PatternFlowVlanTpid) PatternFlowVlanTpid
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVlanTpidChoiceEnum
	SetChoice(value PatternFlowVlanTpidChoiceEnum) PatternFlowVlanTpid
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVlanTpid
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVlanTpid
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVlanTpid
	HasMetricGroup() bool
	Increment() PatternFlowVlanTpidCounter
	SetIncrement(value PatternFlowVlanTpidCounter) PatternFlowVlanTpid
	HasIncrement() bool
	Decrement() PatternFlowVlanTpidCounter
	SetDecrement(value PatternFlowVlanTpidCounter) PatternFlowVlanTpid
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanTpid added in v0.6.5 

func NewPatternFlowVlanTpid() PatternFlowVlanTpid

type PatternFlowVlanTpidChoiceEnum 

type PatternFlowVlanTpidChoiceEnum string

type PatternFlowVlanTpidCounter 

type PatternFlowVlanTpidCounter interface {
	Msg() *snappipb.PatternFlowVlanTpidCounter
	SetMsg(*snappipb.PatternFlowVlanTpidCounter) PatternFlowVlanTpidCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVlanTpidCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVlanTpidCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVlanTpidCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVlanTpidCounter added in v0.6.5 

func NewPatternFlowVlanTpidCounter() PatternFlowVlanTpidCounter

type PatternFlowVxlanFlags 

type PatternFlowVxlanFlags interface {
	Msg() *snappipb.PatternFlowVxlanFlags
	SetMsg(*snappipb.PatternFlowVxlanFlags) PatternFlowVxlanFlags
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVxlanFlagsChoiceEnum
	SetChoice(value PatternFlowVxlanFlagsChoiceEnum) PatternFlowVxlanFlags
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVxlanFlags
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVxlanFlags
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVxlanFlags
	HasMetricGroup() bool
	Increment() PatternFlowVxlanFlagsCounter
	SetIncrement(value PatternFlowVxlanFlagsCounter) PatternFlowVxlanFlags
	HasIncrement() bool
	Decrement() PatternFlowVxlanFlagsCounter
	SetDecrement(value PatternFlowVxlanFlagsCounter) PatternFlowVxlanFlags
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanFlags added in v0.6.5 

func NewPatternFlowVxlanFlags() PatternFlowVxlanFlags

type PatternFlowVxlanFlagsChoiceEnum 

type PatternFlowVxlanFlagsChoiceEnum string

type PatternFlowVxlanFlagsCounter 

type PatternFlowVxlanFlagsCounter interface {
	Msg() *snappipb.PatternFlowVxlanFlagsCounter
	SetMsg(*snappipb.PatternFlowVxlanFlagsCounter) PatternFlowVxlanFlagsCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVxlanFlagsCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVxlanFlagsCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVxlanFlagsCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanFlagsCounter added in v0.6.5 

func NewPatternFlowVxlanFlagsCounter() PatternFlowVxlanFlagsCounter

type PatternFlowVxlanReserved0 

type PatternFlowVxlanReserved0 interface {
	Msg() *snappipb.PatternFlowVxlanReserved0
	SetMsg(*snappipb.PatternFlowVxlanReserved0) PatternFlowVxlanReserved0
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVxlanReserved0ChoiceEnum
	SetChoice(value PatternFlowVxlanReserved0ChoiceEnum) PatternFlowVxlanReserved0
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVxlanReserved0
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVxlanReserved0
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVxlanReserved0
	HasMetricGroup() bool
	Increment() PatternFlowVxlanReserved0Counter
	SetIncrement(value PatternFlowVxlanReserved0Counter) PatternFlowVxlanReserved0
	HasIncrement() bool
	Decrement() PatternFlowVxlanReserved0Counter
	SetDecrement(value PatternFlowVxlanReserved0Counter) PatternFlowVxlanReserved0
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanReserved0 added in v0.6.5 

func NewPatternFlowVxlanReserved0() PatternFlowVxlanReserved0

type PatternFlowVxlanReserved0ChoiceEnum 

type PatternFlowVxlanReserved0ChoiceEnum string

type PatternFlowVxlanReserved0Counter 

type PatternFlowVxlanReserved0Counter interface {
	Msg() *snappipb.PatternFlowVxlanReserved0Counter
	SetMsg(*snappipb.PatternFlowVxlanReserved0Counter) PatternFlowVxlanReserved0Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVxlanReserved0Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVxlanReserved0Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVxlanReserved0Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanReserved0Counter added in v0.6.5 

func NewPatternFlowVxlanReserved0Counter() PatternFlowVxlanReserved0Counter

type PatternFlowVxlanReserved1 

type PatternFlowVxlanReserved1 interface {
	Msg() *snappipb.PatternFlowVxlanReserved1
	SetMsg(*snappipb.PatternFlowVxlanReserved1) PatternFlowVxlanReserved1
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVxlanReserved1ChoiceEnum
	SetChoice(value PatternFlowVxlanReserved1ChoiceEnum) PatternFlowVxlanReserved1
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVxlanReserved1
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVxlanReserved1
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVxlanReserved1
	HasMetricGroup() bool
	Increment() PatternFlowVxlanReserved1Counter
	SetIncrement(value PatternFlowVxlanReserved1Counter) PatternFlowVxlanReserved1
	HasIncrement() bool
	Decrement() PatternFlowVxlanReserved1Counter
	SetDecrement(value PatternFlowVxlanReserved1Counter) PatternFlowVxlanReserved1
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanReserved1 added in v0.6.5 

func NewPatternFlowVxlanReserved1() PatternFlowVxlanReserved1

type PatternFlowVxlanReserved1ChoiceEnum 

type PatternFlowVxlanReserved1ChoiceEnum string

type PatternFlowVxlanReserved1Counter 

type PatternFlowVxlanReserved1Counter interface {
	Msg() *snappipb.PatternFlowVxlanReserved1Counter
	SetMsg(*snappipb.PatternFlowVxlanReserved1Counter) PatternFlowVxlanReserved1Counter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVxlanReserved1Counter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVxlanReserved1Counter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVxlanReserved1Counter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanReserved1Counter added in v0.6.5 

func NewPatternFlowVxlanReserved1Counter() PatternFlowVxlanReserved1Counter

type PatternFlowVxlanVni 

type PatternFlowVxlanVni interface {
	Msg() *snappipb.PatternFlowVxlanVni
	SetMsg(*snappipb.PatternFlowVxlanVni) PatternFlowVxlanVni
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PatternFlowVxlanVniChoiceEnum
	SetChoice(value PatternFlowVxlanVniChoiceEnum) PatternFlowVxlanVni
	HasChoice() bool
	Value() int32
	SetValue(value int32) PatternFlowVxlanVni
	HasValue() bool
	Values() []int32
	SetValues(value []int32) PatternFlowVxlanVni
	MetricGroup() string
	SetMetricGroup(value string) PatternFlowVxlanVni
	HasMetricGroup() bool
	Increment() PatternFlowVxlanVniCounter
	SetIncrement(value PatternFlowVxlanVniCounter) PatternFlowVxlanVni
	HasIncrement() bool
	Decrement() PatternFlowVxlanVniCounter
	SetDecrement(value PatternFlowVxlanVniCounter) PatternFlowVxlanVni
	HasDecrement() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanVni added in v0.6.5 

func NewPatternFlowVxlanVni() PatternFlowVxlanVni

type PatternFlowVxlanVniChoiceEnum 

type PatternFlowVxlanVniChoiceEnum string

type PatternFlowVxlanVniCounter 

type PatternFlowVxlanVniCounter interface {
	Msg() *snappipb.PatternFlowVxlanVniCounter
	SetMsg(*snappipb.PatternFlowVxlanVniCounter) PatternFlowVxlanVniCounter
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Start() int32
	SetStart(value int32) PatternFlowVxlanVniCounter
	HasStart() bool
	Step() int32
	SetStep(value int32) PatternFlowVxlanVniCounter
	HasStep() bool
	Count() int32
	SetCount(value int32) PatternFlowVxlanVniCounter
	HasCount() bool
	// contains filtered or unexported methods
}

func NewPatternFlowVxlanVniCounter added in v0.6.5 

func NewPatternFlowVxlanVniCounter() PatternFlowVxlanVniCounter

type Ping added in v0.5.8 

type Ping interface {
	Msg() *snappipb.Ping
	SetMsg(*snappipb.Ping) Ping
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Choice() PingChoiceEnum
	SetChoice(value PingChoiceEnum) Ping
	HasChoice() bool
	Ipv4() PingIpv4
	SetIpv4(value PingIpv4) Ping
	HasIpv4() bool
	Ipv6() PingIpv6
	SetIpv6(value PingIpv6) Ping
	HasIpv6() bool
	// contains filtered or unexported methods
}

func NewPing added in v0.6.5 

func NewPing() Ping

type PingChoiceEnum added in v0.5.8 

type PingChoiceEnum string

type PingIpv4 added in v0.5.8 

type PingIpv4 interface {
	Msg() *snappipb.PingIpv4
	SetMsg(*snappipb.PingIpv4) PingIpv4
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SrcName() string
	SetSrcName(value string) PingIpv4
	HasSrcName() bool
	DstIp() string
	SetDstIp(value string) PingIpv4
	HasDstIp() bool
	// contains filtered or unexported methods
}

func NewPingIpv4 added in v0.6.5 

func NewPingIpv4() PingIpv4

type PingIpv6 added in v0.5.8 

type PingIpv6 interface {
	Msg() *snappipb.PingIpv6
	SetMsg(*snappipb.PingIpv6) PingIpv6
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SrcName() string
	SetSrcName(value string) PingIpv6
	HasSrcName() bool
	DstIp() string
	SetDstIp(value string) PingIpv6
	HasDstIp() bool
	// contains filtered or unexported methods
}

func NewPingIpv6 added in v0.6.5 

func NewPingIpv6() PingIpv6

type PingRequest added in v0.5.8 

type PingRequest interface {
	Msg() *snappipb.PingRequest
	SetMsg(*snappipb.PingRequest) PingRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Endpoints() PingRequestPingIter
	// contains filtered or unexported methods
}

func NewPingRequest added in v0.6.5 

func NewPingRequest() PingRequest

type PingRequestPingIter added in v0.5.8 

type PingRequestPingIter interface {
	Add() Ping
	Items() []Ping
}

type PingResponse added in v0.5.8 

type PingResponse interface {
	Msg() *snappipb.PingResponse
	SetMsg(*snappipb.PingResponse) PingResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Responses() PingResponseResponseIter
	// contains filtered or unexported methods
}

func NewPingResponse added in v0.6.5 

func NewPingResponse() PingResponse

type PingResponseResponseIter added in v0.5.8 

type PingResponseResponseIter interface {
	Add() Response
	Items() []Response
}

type Port 

type Port interface {
	Msg() *snappipb.Port
	SetMsg(*snappipb.Port) Port
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Location() string
	SetLocation(value string) Port
	HasLocation() bool
	Name() string
	SetName(value string) Port
	// contains filtered or unexported methods
}

func NewPort added in v0.6.5 

func NewPort() Port

type PortMetric 

type PortMetric interface {
	Msg() *snappipb.PortMetric
	SetMsg(*snappipb.PortMetric) PortMetric
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) PortMetric
	HasName() bool
	Location() string
	SetLocation(value string) PortMetric
	HasLocation() bool
	Link() PortMetricLinkEnum
	SetLink(value PortMetricLinkEnum) PortMetric
	HasLink() bool
	Capture() PortMetricCaptureEnum
	SetCapture(value PortMetricCaptureEnum) PortMetric
	HasCapture() bool
	FramesTx() int32
	SetFramesTx(value int32) PortMetric
	HasFramesTx() bool
	FramesRx() int32
	SetFramesRx(value int32) PortMetric
	HasFramesRx() bool
	BytesTx() int32
	SetBytesTx(value int32) PortMetric
	HasBytesTx() bool
	BytesRx() int32
	SetBytesRx(value int32) PortMetric
	HasBytesRx() bool
	FramesTxRate() float32
	SetFramesTxRate(value float32) PortMetric
	HasFramesTxRate() bool
	FramesRxRate() float32
	SetFramesRxRate(value float32) PortMetric
	HasFramesRxRate() bool
	BytesTxRate() float32
	SetBytesTxRate(value float32) PortMetric
	HasBytesTxRate() bool
	BytesRxRate() float32
	SetBytesRxRate(value float32) PortMetric
	HasBytesRxRate() bool
	// contains filtered or unexported methods
}

func NewPortMetric added in v0.6.5 

func NewPortMetric() PortMetric

type PortMetricCaptureEnum 

type PortMetricCaptureEnum string

type PortMetricLinkEnum 

type PortMetricLinkEnum string

type PortMetricsRequest 

type PortMetricsRequest interface {
	Msg() *snappipb.PortMetricsRequest
	SetMsg(*snappipb.PortMetricsRequest) PortMetricsRequest
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortNames() []string
	SetPortNames(value []string) PortMetricsRequest
	ColumnNames() []PortMetricsRequestColumnNamesEnum
	SetColumnNames(value []PortMetricsRequestColumnNamesEnum) PortMetricsRequest
	// contains filtered or unexported methods
}

func NewPortMetricsRequest added in v0.6.5 

func NewPortMetricsRequest() PortMetricsRequest

type PortMetricsRequestColumnNamesEnum 

type PortMetricsRequestColumnNamesEnum string

type PortOptions 

type PortOptions interface {
	Msg() *snappipb.PortOptions
	SetMsg(*snappipb.PortOptions) PortOptions
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	LocationPreemption() bool
	SetLocationPreemption(value bool) PortOptions
	HasLocationPreemption() bool
	// contains filtered or unexported methods
}

func NewPortOptions added in v0.6.5 

func NewPortOptions() PortOptions

type PortState 

type PortState interface {
	Msg() *snappipb.PortState
	SetMsg(*snappipb.PortState) PortState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Name() string
	SetName(value string) PortState
	HasName() bool
	Link() PortStateLinkEnum
	SetLink(value PortStateLinkEnum) PortState
	HasLink() bool
	Capture() PortStateCaptureEnum
	SetCapture(value PortStateCaptureEnum) PortState
	HasCapture() bool
	// contains filtered or unexported methods
}

func NewPortState added in v0.6.5 

func NewPortState() PortState

type PortStateCaptureEnum 

type PortStateCaptureEnum string

type PortStateLinkEnum 

type PortStateLinkEnum string

type ProtocolState added in v0.6.1 

type ProtocolState interface {
	Msg() *snappipb.ProtocolState
	SetMsg(*snappipb.ProtocolState) ProtocolState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	State() ProtocolStateStateEnum
	SetState(value ProtocolStateStateEnum) ProtocolState
	// contains filtered or unexported methods
}

func NewProtocolState added in v0.6.5 

func NewProtocolState() ProtocolState

type ProtocolStateStateEnum added in v0.6.1 

type ProtocolStateStateEnum string

type Response added in v0.5.8 

type Response interface {
	Msg() *snappipb.Response
	SetMsg(*snappipb.Response) Response
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	SrcName() string
	SetSrcName(value string) Response
	HasSrcName() bool
	DstIp() string
	SetDstIp(value string) Response
	HasDstIp() bool
	Result() ResponseResultEnum
	SetResult(value ResponseResultEnum) Response
	HasResult() bool
	// contains filtered or unexported methods
}

func NewResponse added in v0.6.5 

func NewResponse() Response

type ResponseError 

type ResponseError interface {
	Msg() *snappipb.ResponseError
	SetMsg(*snappipb.ResponseError) ResponseError
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Errors() []string
	SetErrors(value []string) ResponseError
	// contains filtered or unexported methods
}

func NewResponseError added in v0.6.5 

func NewResponseError() ResponseError

type ResponseResultEnum added in v0.5.8 

type ResponseResultEnum string

type ResponseWarning 

type ResponseWarning interface {
	Msg() *snappipb.ResponseWarning
	SetMsg(*snappipb.ResponseWarning) ResponseWarning
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Warnings() []string
	SetWarnings(value []string) ResponseWarning
	// contains filtered or unexported methods
}

func NewResponseWarning added in v0.6.5 

func NewResponseWarning() ResponseWarning

type RouteState 

type RouteState interface {
	Msg() *snappipb.RouteState
	SetMsg(*snappipb.RouteState) RouteState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Names() []string
	SetNames(value []string) RouteState
	State() RouteStateStateEnum
	SetState(value RouteStateStateEnum) RouteState
	// contains filtered or unexported methods
}

func NewRouteState added in v0.6.5 

func NewRouteState() RouteState

type RouteStateStateEnum 

type RouteStateStateEnum string

type SendPingResponse added in v0.5.8 

type SendPingResponse interface {
	Msg() *snappipb.SendPingResponse
	SetMsg(*snappipb.SendPingResponse) SendPingResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() PingResponse
	SetStatusCode200(value PingResponse) SendPingResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SendPingResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SendPingResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSendPingResponse added in v0.6.5 

func NewSendPingResponse() SendPingResponse

type SetCaptureStateResponse 

type SetCaptureStateResponse interface {
	Msg() *snappipb.SetCaptureStateResponse
	SetMsg(*snappipb.SetCaptureStateResponse) SetCaptureStateResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetCaptureStateResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetCaptureStateResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetCaptureStateResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetCaptureStateResponse added in v0.6.5 

func NewSetCaptureStateResponse() SetCaptureStateResponse

type SetConfigResponse 

type SetConfigResponse interface {
	Msg() *snappipb.SetConfigResponse
	SetMsg(*snappipb.SetConfigResponse) SetConfigResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetConfigResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetConfigResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetConfigResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetConfigResponse added in v0.6.5 

func NewSetConfigResponse() SetConfigResponse

type SetLinkStateResponse 

type SetLinkStateResponse interface {
	Msg() *snappipb.SetLinkStateResponse
	SetMsg(*snappipb.SetLinkStateResponse) SetLinkStateResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetLinkStateResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetLinkStateResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetLinkStateResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetLinkStateResponse added in v0.6.5 

func NewSetLinkStateResponse() SetLinkStateResponse

type SetProtocolStateResponse added in v0.6.1 

type SetProtocolStateResponse interface {
	Msg() *snappipb.SetProtocolStateResponse
	SetMsg(*snappipb.SetProtocolStateResponse) SetProtocolStateResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetProtocolStateResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetProtocolStateResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetProtocolStateResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetProtocolStateResponse added in v0.6.5 

func NewSetProtocolStateResponse() SetProtocolStateResponse

type SetRouteStateResponse 

type SetRouteStateResponse interface {
	Msg() *snappipb.SetRouteStateResponse
	SetMsg(*snappipb.SetRouteStateResponse) SetRouteStateResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetRouteStateResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetRouteStateResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetRouteStateResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetRouteStateResponse added in v0.6.5 

func NewSetRouteStateResponse() SetRouteStateResponse

type SetTransmitStateResponse 

type SetTransmitStateResponse interface {
	Msg() *snappipb.SetTransmitStateResponse
	SetMsg(*snappipb.SetTransmitStateResponse) SetTransmitStateResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() ResponseWarning
	SetStatusCode200(value ResponseWarning) SetTransmitStateResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) SetTransmitStateResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) SetTransmitStateResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewSetTransmitStateResponse added in v0.6.5 

func NewSetTransmitStateResponse() SetTransmitStateResponse

type StateMetrics 

type StateMetrics interface {
	Msg() *snappipb.StateMetrics
	SetMsg(*snappipb.StateMetrics) StateMetrics
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	PortState() StateMetricsPortStateIter
	FlowState() StateMetricsFlowStateIter
	// contains filtered or unexported methods
}

func NewStateMetrics added in v0.6.5 

func NewStateMetrics() StateMetrics

type StateMetricsFlowStateIter 

type StateMetricsFlowStateIter interface {
	Add() FlowState
	Items() []FlowState
}

type StateMetricsPortStateIter 

type StateMetricsPortStateIter interface {
	Add() PortState
	Items() []PortState
}

type TransmitState 

type TransmitState interface {
	Msg() *snappipb.TransmitState
	SetMsg(*snappipb.TransmitState) TransmitState
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	FlowNames() []string
	SetFlowNames(value []string) TransmitState
	State() TransmitStateStateEnum
	SetState(value TransmitStateStateEnum) TransmitState
	// contains filtered or unexported methods
}

func NewTransmitState added in v0.6.5 

func NewTransmitState() TransmitState

type TransmitStateStateEnum 

type TransmitStateStateEnum string

type UpdateFlowsResponse 

type UpdateFlowsResponse interface {
	Msg() *snappipb.UpdateFlowsResponse
	SetMsg(*snappipb.UpdateFlowsResponse) UpdateFlowsResponse
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	StatusCode200() Config
	SetStatusCode200(value Config) UpdateFlowsResponse
	HasStatusCode200() bool
	StatusCode400() ResponseError
	SetStatusCode400(value ResponseError) UpdateFlowsResponse
	HasStatusCode400() bool
	StatusCode500() ResponseError
	SetStatusCode500(value ResponseError) UpdateFlowsResponse
	HasStatusCode500() bool
	// contains filtered or unexported methods
}

func NewUpdateFlowsResponse added in v0.6.5 

func NewUpdateFlowsResponse() UpdateFlowsResponse

type V4RouteAddress added in v0.6.1 

type V4RouteAddress interface {
	Msg() *snappipb.V4RouteAddress
	SetMsg(*snappipb.V4RouteAddress) V4RouteAddress
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Address() string
	SetAddress(value string) V4RouteAddress
	Prefix() int32
	SetPrefix(value int32) V4RouteAddress
	HasPrefix() bool
	Count() int32
	SetCount(value int32) V4RouteAddress
	HasCount() bool
	Step() int32
	SetStep(value int32) V4RouteAddress
	HasStep() bool
	// contains filtered or unexported methods
}

func NewV4RouteAddress added in v0.6.5 

func NewV4RouteAddress() V4RouteAddress

type V6RouteAddress added in v0.6.1 

type V6RouteAddress interface {
	Msg() *snappipb.V6RouteAddress
	SetMsg(*snappipb.V6RouteAddress) V6RouteAddress
	ToPbText() string
	ToYaml() string
	ToJson() string
	FromPbText(value string) error
	FromYaml(value string) error
	FromJson(value string) error
	Validate(defaults ...bool) error

	Address() string
	SetAddress(value string) V6RouteAddress
	Prefix() int32
	SetPrefix(value int32) V6RouteAddress
	HasPrefix() bool
	Count() int32
	SetCount(value int32) V6RouteAddress
	HasCount() bool
	Step() int32
	SetStep(value int32) V6RouteAddress
	HasStep() bool
	// contains filtered or unexported methods
}

func NewV6RouteAddress added in v0.6.5 

func NewV6RouteAddress() V6RouteAddress

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.