ocstruct

package
v0.0.0-...-db8a646 Latest Latest
Warning

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

 Go to latest Published: Dec 13, 2018 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Package ocstruct is a generated package which contains definitions of structs which represent a YANG schema. The generated schema can be compressed by a series of transformations (compression was false in this case).

Index

Constants

This section is empty.

Variables

View Source 
var (
	SchemaTree map[string]*yang.Entry
)
View Source 
var ΛEnum = map[string]map[int64]ygot.EnumDefinition{
	"E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE": {
		1: {Name: "AAA_ACCOUNTING_EVENT_COMMAND", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "AAA_ACCOUNTING_EVENT_LOGIN", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE": {
		1: {Name: "AAA_AUTHORIZATION_EVENT_COMMAND", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "AAA_AUTHORIZATION_EVENT_CONFIG", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_METHOD_TYPE": {
		1: {Name: "LOCAL", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "RADIUS_ALL", DefiningModule: "openconfig-aaa-types"},
		3: {Name: "TACACS_ALL", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_SERVER_TYPE": {
		1: {Name: "RADIUS", DefiningModule: "openconfig-aaa"},
		2: {Name: "TACACS", DefiningModule: "openconfig-aaa"},
	},
	"E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES": {
		1: {Name: "SYSTEM_ROLE_ADMIN", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode": {
		1: {Name: "A"},
		2: {Name: "B"},
		3: {Name: "G"},
		4: {Name: "N"},
		5: {Name: "AC"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode": {
		1: {Name: "OPEN"},
		2: {Name: "WPA2_PERSONAL"},
		3: {Name: "WPA2_ENTERPRISE"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod": {
		1: {Name: "OVA"},
		2: {Name: "ODS"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record": {
		1: {Name: "START_STOP"},
		2: {Name: "STOP"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index": {
		1: {Name: "ALL"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses": {
		1: {Name: "ANY"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType": {
		1: {Name: "SERVER"},
		2: {Name: "PEER"},
		3: {Name: "POOL"},
	},
	"E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion": {
		1: {Name: "V2"},
		2: {Name: "V1"},
		3: {Name: "V1_V2"},
	},
	"E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY": {
		1: {Name: "CRITICAL", DefiningModule: "openconfig-alarm-types"},
		2: {Name: "MAJOR", DefiningModule: "openconfig-alarm-types"},
		3: {Name: "MINOR", DefiningModule: "openconfig-alarm-types"},
		4: {Name: "UNKNOWN", DefiningModule: "openconfig-alarm-types"},
		5: {Name: "WARNING", DefiningModule: "openconfig-alarm-types"},
	},
	"E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID": {
		1: {Name: "AIS", DefiningModule: "openconfig-alarm-types"},
		2: {Name: "EQPT", DefiningModule: "openconfig-alarm-types"},
		3: {Name: "LOS", DefiningModule: "openconfig-alarm-types"},
		4: {Name: "OTS", DefiningModule: "openconfig-alarm-types"},
	},
	"E_OpenconfigSystemLogging_SYSLOG_FACILITY": {
		1:  {Name: "ALL", DefiningModule: "openconfig-system-logging"},
		2:  {Name: "AUDIT", DefiningModule: "openconfig-system-logging"},
		3:  {Name: "AUTH", DefiningModule: "openconfig-system-logging"},
		4:  {Name: "AUTHPRIV", DefiningModule: "openconfig-system-logging"},
		5:  {Name: "CONSOLE", DefiningModule: "openconfig-system-logging"},
		6:  {Name: "KERNEL", DefiningModule: "openconfig-system-logging"},
		7:  {Name: "LOCAL0", DefiningModule: "openconfig-system-logging"},
		8:  {Name: "LOCAL1", DefiningModule: "openconfig-system-logging"},
		9:  {Name: "LOCAL2", DefiningModule: "openconfig-system-logging"},
		10: {Name: "LOCAL3", DefiningModule: "openconfig-system-logging"},
		11: {Name: "LOCAL4", DefiningModule: "openconfig-system-logging"},
		12: {Name: "LOCAL5", DefiningModule: "openconfig-system-logging"},
		13: {Name: "LOCAL6", DefiningModule: "openconfig-system-logging"},
		14: {Name: "LOCAL7", DefiningModule: "openconfig-system-logging"},
		15: {Name: "MAIL", DefiningModule: "openconfig-system-logging"},
		16: {Name: "NTP", DefiningModule: "openconfig-system-logging"},
		17: {Name: "SYSLOG", DefiningModule: "openconfig-system-logging"},
		18: {Name: "SYSTEM_DAEMON", DefiningModule: "openconfig-system-logging"},
		19: {Name: "USER", DefiningModule: "openconfig-system-logging"},
	},
	"E_OpenconfigSystemLogging_SyslogSeverity": {
		1: {Name: "EMERGENCY"},
		2: {Name: "ALERT"},
		3: {Name: "CRITICAL"},
		4: {Name: "ERROR"},
		5: {Name: "WARNING"},
		6: {Name: "NOTICE"},
		7: {Name: "INFORMATIONAL"},
		8: {Name: "DEBUG"},
	},
	"E_OpenconfigSystem_NTP_AUTH_TYPE": {
		1: {Name: "NTP_AUTH_MD5", DefiningModule: "openconfig-system"},
	},
	"E_OpenconfigWifiTypes_CHANGE_REASON_TYPE": {
		1: {Name: "BETTER-CHANNEL", DefiningModule: "openconfig-wifi-types"},
		2: {Name: "DFS", DefiningModule: "openconfig-wifi-types"},
		3: {Name: "ERRORS", DefiningModule: "openconfig-wifi-types"},
		4: {Name: "NOISE", DefiningModule: "openconfig-wifi-types"},
	},
	"E_OpenconfigWifiTypes_CLIENT_CAPABILITIES": {
		1: {Name: "DOT_11R", DefiningModule: "openconfig-wifi-types"},
		2: {Name: "DOT_11V", DefiningModule: "openconfig-wifi-types"},
		3: {Name: "MU_BEAMFORMEE", DefiningModule: "openconfig-wifi-types"},
		4: {Name: "MU_BEAMFORMER", DefiningModule: "openconfig-wifi-types"},
	},
	"E_OpenconfigWifiTypes_CLIENT_STATE": {
		1:  {Name: "ASSOCIATED", DefiningModule: "openconfig-wifi-types"},
		2:  {Name: "AUTHENTICATED", DefiningModule: "openconfig-wifi-types"},
		3:  {Name: "BLACKLISTED", DefiningModule: "openconfig-wifi-types"},
		4:  {Name: "DHCP_FAILURE", DefiningModule: "openconfig-wifi-types"},
		5:  {Name: "DHCP_REQD", DefiningModule: "openconfig-wifi-types"},
		6:  {Name: "L2AUTH_FAILURE_REJECT", DefiningModule: "openconfig-wifi-types"},
		7:  {Name: "L2AUTH_FAILURE_TIMEOUT", DefiningModule: "openconfig-wifi-types"},
		8:  {Name: "L2AUTH_REQD", DefiningModule: "openconfig-wifi-types"},
		9:  {Name: "L3AUTH_FAILURE", DefiningModule: "openconfig-wifi-types"},
		10: {Name: "L3AUTH_REQD", DefiningModule: "openconfig-wifi-types"},
		11: {Name: "POWERSAVE", DefiningModule: "openconfig-wifi-types"},
	},
	"E_OpenconfigWifiTypes_DATA_RATE": {
		1:  {Name: "RATE_11MB", DefiningModule: "openconfig-wifi-types"},
		2:  {Name: "RATE_12MB", DefiningModule: "openconfig-wifi-types"},
		3:  {Name: "RATE_18MB", DefiningModule: "openconfig-wifi-types"},
		4:  {Name: "RATE_1MB", DefiningModule: "openconfig-wifi-types"},
		5:  {Name: "RATE_24MB", DefiningModule: "openconfig-wifi-types"},
		6:  {Name: "RATE_2MB", DefiningModule: "openconfig-wifi-types"},
		7:  {Name: "RATE_36MB", DefiningModule: "openconfig-wifi-types"},
		8:  {Name: "RATE_48MB", DefiningModule: "openconfig-wifi-types"},
		9:  {Name: "RATE_5.5MB", DefiningModule: "openconfig-wifi-types"},
		10: {Name: "RATE_54MB", DefiningModule: "openconfig-wifi-types"},
		11: {Name: "RATE_6MB", DefiningModule: "openconfig-wifi-types"},
		12: {Name: "RATE_9MB", DefiningModule: "openconfig-wifi-types"},
	},
	"E_OpenconfigWifiTypes_OPERATING_FREQUENCY": {
		1: {Name: "FREQ_2GHZ", DefiningModule: "openconfig-wifi-types"},
		2: {Name: "FREQ_2_5_GHZ", DefiningModule: "openconfig-wifi-types"},
		3: {Name: "FREQ_5GHZ", DefiningModule: "openconfig-wifi-types"},
	},
}

ΛEnum is a map, keyed by the name of the type defined for each enum in the generated Go code, which provides a mapping between the constant int64 value of each value of the enumeration, and the string that is used to represent it in the YANG schema. The map is named ΛEnum in order to avoid clash with any valid YANG identifier.

View Source 
var ΛEnumTypes = map[string][]reflect.Type{
	"/access-points/access-point/radios/radio/config/operating-frequency": {
		reflect.TypeOf((E_OpenconfigWifiTypes_OPERATING_FREQUENCY)(0)),
	},
	"/access-points/access-point/radios/radio/state/channel-change-reason": {
		reflect.TypeOf((E_OpenconfigWifiTypes_CHANGE_REASON_TYPE)(0)),
	},
	"/access-points/access-point/radios/radio/state/operating-frequency": {
		reflect.TypeOf((E_OpenconfigWifiTypes_OPERATING_FREQUENCY)(0)),
	},
	"/access-points/access-point/ssids/ssid/clients/client/client-capabilities/state/client-capabilities": {
		reflect.TypeOf((E_OpenconfigWifiTypes_CLIENT_CAPABILITIES)(0)),
	},
	"/access-points/access-point/ssids/ssid/clients/client/client-connection/state/client-state": {
		reflect.TypeOf((E_OpenconfigWifiTypes_CLIENT_STATE)(0)),
	},
	"/access-points/access-point/ssids/ssid/clients/client/client-rf/state/connection-mode": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode)(0)),
	},
	"/access-points/access-point/ssids/ssid/config/basic-data-rates": {
		reflect.TypeOf((E_OpenconfigWifiTypes_DATA_RATE)(0)),
	},
	"/access-points/access-point/ssids/ssid/config/operating-frequency": {
		reflect.TypeOf((E_OpenconfigWifiTypes_OPERATING_FREQUENCY)(0)),
	},
	"/access-points/access-point/ssids/ssid/config/opmode": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode)(0)),
	},
	"/access-points/access-point/ssids/ssid/config/supported-data-rates": {
		reflect.TypeOf((E_OpenconfigWifiTypes_DATA_RATE)(0)),
	},
	"/access-points/access-point/ssids/ssid/dot11r/config/dot11r-method": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod)(0)),
	},
	"/access-points/access-point/ssids/ssid/dot11r/state/dot11r-method": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod)(0)),
	},
	"/access-points/access-point/ssids/ssid/state/basic-data-rates": {
		reflect.TypeOf((E_OpenconfigWifiTypes_DATA_RATE)(0)),
	},
	"/access-points/access-point/ssids/ssid/state/operating-frequency": {
		reflect.TypeOf((E_OpenconfigWifiTypes_OPERATING_FREQUENCY)(0)),
	},
	"/access-points/access-point/ssids/ssid/state/opmode": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode)(0)),
	},
	"/access-points/access-point/ssids/ssid/state/supported-data-rates": {
		reflect.TypeOf((E_OpenconfigWifiTypes_DATA_RATE)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/config/accounting-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/events/event/config/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/events/event/config/record": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/events/event/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/events/event/state/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/events/event/state/record": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record)(0)),
	},
	"/access-points/access-point/system/aaa/accounting/state/accounting-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authentication/config/authentication-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authentication/state/authentication-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authentication/users/user/config/role": {
		reflect.TypeOf((E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES)(0)),
	},
	"/access-points/access-point/system/aaa/authentication/users/user/state/role": {
		reflect.TypeOf((E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES)(0)),
	},
	"/access-points/access-point/system/aaa/authorization/config/authorization-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authorization/events/event/config/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authorization/events/event/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authorization/events/event/state/event-type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/authorization/state/authorization-method": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/server-groups/server-group/config/type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_SERVER_TYPE)(0)),
	},
	"/access-points/access-point/system/aaa/server-groups/server-group/state/type": {
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_SERVER_TYPE)(0)),
	},
	"/access-points/access-point/system/alarms/alarm/state/severity": {
		reflect.TypeOf((E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY)(0)),
	},
	"/access-points/access-point/system/alarms/alarm/state/type-id": {
		reflect.TypeOf((E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID)(0)),
	},
	"/access-points/access-point/system/cpus/cpu/index": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index)(0)),
	},
	"/access-points/access-point/system/grpc-server/config/listen-addresses": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses)(0)),
	},
	"/access-points/access-point/system/grpc-server/state/listen-addresses": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/config/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/config/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/state/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/console/selectors/selector/state/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/config/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/config/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/state/facility": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/state/severity": {
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/access-points/access-point/system/ntp/ntp-keys/ntp-key/config/key-type": {
		reflect.TypeOf((E_OpenconfigSystem_NTP_AUTH_TYPE)(0)),
	},
	"/access-points/access-point/system/ntp/ntp-keys/ntp-key/state/key-type": {
		reflect.TypeOf((E_OpenconfigSystem_NTP_AUTH_TYPE)(0)),
	},
	"/access-points/access-point/system/ntp/servers/server/config/association-type": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType)(0)),
	},
	"/access-points/access-point/system/ntp/servers/server/state/association-type": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType)(0)),
	},
	"/access-points/access-point/system/ssh-server/config/protocol-version": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion)(0)),
	},
	"/access-points/access-point/system/ssh-server/state/protocol-version": {
		reflect.TypeOf((E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion)(0)),
	},
}

ΛEnumTypes is a map, keyed by a YANG schema path, of the enumerated types that correspond with the leaf. The type is represented as a reflect.Type. The naming of the map ensures that there are no clashes with valid YANG identifiers.

Functions

func Unmarshal 

func Unmarshal(data []byte, destStruct ygot.GoStruct, opts ...ytypes.UnmarshalOpt) error

Unmarshal unmarshals data, which must be RFC7951 JSON format, into destStruct, which must be non-nil and the correct GoStruct type. It returns an error if the destStruct is not found in the schema or the data cannot be unmarshaled. The supplied options (opts) are used to control the behaviour of the unmarshal function - for example, determining whether errors are thrown for unknown fields in the input JSON.

Types

type Binary 

type Binary []byte

Binary is a type that is used for fields that have a YANG type of binary. It is used such that binary fields can be distinguished from leaf-lists of uint8s (which are mapped to []uint8, equivalent to []byte in reflection).

type Device 

type Device struct {
	AccessPoints *OpenconfigAccessPoints_AccessPoints `path:"access-points" module:"openconfig-access-points"`
	Gasket       *OpenconfigGasket_Gasket             `path:"gasket" module:"openconfig-gasket"`
}

Device represents the /device YANG schema element.

func (*Device) IsYANGGoStruct 

func (*Device) IsYANGGoStruct()

IsYANGGoStruct ensures that Device implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*Device) Validate 

func (s *Device) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*Device) ΛEnumTypeMap 

func (t *Device) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE 

type E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE int64

E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE. An additional value named OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 0
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_COMMAND corresponds to the value AAA_ACCOUNTING_EVENT_COMMAND of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_COMMAND E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 1
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_LOGIN corresponds to the value AAA_ACCOUNTING_EVENT_LOGIN of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_LOGIN E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE.

type E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE 

type E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE int64

E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE. An additional value named OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 0
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_COMMAND corresponds to the value AAA_AUTHORIZATION_EVENT_COMMAND of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_COMMAND E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 1
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_CONFIG corresponds to the value AAA_AUTHORIZATION_EVENT_CONFIG of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_CONFIG E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE.

type E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type E_OpenconfigAaaTypes_AAA_METHOD_TYPE int64

E_OpenconfigAaaTypes_AAA_METHOD_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_METHOD_TYPE. An additional value named OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 0
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_LOCAL corresponds to the value LOCAL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_LOCAL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 1
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_RADIUS_ALL corresponds to the value RADIUS_ALL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_RADIUS_ALL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 2
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_TACACS_ALL corresponds to the value TACACS_ALL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_TACACS_ALL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 3
)

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_METHOD_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_METHOD_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_METHOD_TYPE.

type E_OpenconfigAaaTypes_AAA_SERVER_TYPE 

type E_OpenconfigAaaTypes_AAA_SERVER_TYPE int64

E_OpenconfigAaaTypes_AAA_SERVER_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_SERVER_TYPE. An additional value named OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 0
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_RADIUS corresponds to the value RADIUS of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_RADIUS E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 1
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_TACACS corresponds to the value TACACS of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_TACACS E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_SERVER_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_SERVER_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_SERVER_TYPE.

type E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES 

type E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES int64

E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES. An additional value named OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
	OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES = 0
	// OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_SYSTEM_ROLE_ADMIN corresponds to the value SYSTEM_ROLE_ADMIN of OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
	OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_SYSTEM_ROLE_ADMIN E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES = 1
)

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) ΛMap 

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_A corresponds to the value A of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_A E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_B corresponds to the value B of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_B E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 2
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_G corresponds to the value G of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_G E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 3
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_N corresponds to the value N of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_N E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 4
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_AC corresponds to the value AC of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode_AC E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode = 5
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_OPEN corresponds to the value OPEN of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_OPEN E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_WPA2_PERSONAL corresponds to the value WPA2_PERSONAL of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_WPA2_PERSONAL E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode = 2
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_WPA2_ENTERPRISE corresponds to the value WPA2_ENTERPRISE of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode_WPA2_ENTERPRISE E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode = 3
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_OVA corresponds to the value OVA of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_OVA E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_ODS corresponds to the value ODS of OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod
	OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod_ODS E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod = 2
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_START_STOP corresponds to the value START_STOP of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_START_STOP E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_STOP corresponds to the value STOP of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record_STOP E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record = 2
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_ALL corresponds to the value ALL of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_ALL E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index = 1
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_ANY corresponds to the value ANY of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_ANY E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses = 1
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_SERVER corresponds to the value SERVER of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_SERVER E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_PEER corresponds to the value PEER of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_PEER E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType = 2
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_POOL corresponds to the value POOL of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType_POOL E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType = 3
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType.

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion 

type E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion int64

E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion is a derived int64 type which is used to represent the enumerated node OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion. An additional value named OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_UNSET corresponds to the value UNSET of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_UNSET E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion = 0
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V2 corresponds to the value V2 of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V2 E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion = 1
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V1 corresponds to the value V1 of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V1 E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion = 2
	// OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V1_V2 corresponds to the value V1_V2 of OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion
	OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion_V1_V2 E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion = 3
)

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion) IsYANGGoEnum 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion implements the yang.GoEnum interface. This ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion) ΛMap 

func (E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion.

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY 

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY int64

E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY is a derived int64 type which is used to represent the enumerated node OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY. An additional value named OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET corresponds to the value UNSET of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 0
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_CRITICAL corresponds to the value CRITICAL of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_CRITICAL E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 1
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MAJOR corresponds to the value MAJOR of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MAJOR E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 2
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MINOR corresponds to the value MINOR of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MINOR E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 3
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNKNOWN corresponds to the value UNKNOWN of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNKNOWN E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 4
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_WARNING corresponds to the value WARNING of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_WARNING E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 5
)

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) IsYANGGoEnum 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY implements the yang.GoEnum interface. This ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) ΛMap 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY.

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID 

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID int64

E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID is a derived int64 type which is used to represent the enumerated node OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID. An additional value named OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET corresponds to the value UNSET of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 0
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_AIS corresponds to the value AIS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_AIS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 1
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_EQPT corresponds to the value EQPT of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_EQPT E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 2
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_LOS corresponds to the value LOS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_LOS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 3
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_OTS corresponds to the value OTS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_OTS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 4
)

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) IsYANGGoEnum 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID implements the yang.GoEnum interface. This ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) ΛMap 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID.

type E_OpenconfigSystemLogging_SYSLOG_FACILITY 

type E_OpenconfigSystemLogging_SYSLOG_FACILITY int64

E_OpenconfigSystemLogging_SYSLOG_FACILITY is a derived int64 type which is used to represent the enumerated node OpenconfigSystemLogging_SYSLOG_FACILITY. An additional value named OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET corresponds to the value UNSET of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET E_OpenconfigSystemLogging_SYSLOG_FACILITY = 0
	// OpenconfigSystemLogging_SYSLOG_FACILITY_ALL corresponds to the value ALL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_ALL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 1
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUDIT corresponds to the value AUDIT of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUDIT E_OpenconfigSystemLogging_SYSLOG_FACILITY = 2
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUTH corresponds to the value AUTH of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUTH E_OpenconfigSystemLogging_SYSLOG_FACILITY = 3
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUTHPRIV corresponds to the value AUTHPRIV of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUTHPRIV E_OpenconfigSystemLogging_SYSLOG_FACILITY = 4
	// OpenconfigSystemLogging_SYSLOG_FACILITY_CONSOLE corresponds to the value CONSOLE of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_CONSOLE E_OpenconfigSystemLogging_SYSLOG_FACILITY = 5
	// OpenconfigSystemLogging_SYSLOG_FACILITY_KERNEL corresponds to the value KERNEL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_KERNEL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 6
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL0 corresponds to the value LOCAL0 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL0 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 7
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL1 corresponds to the value LOCAL1 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL1 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 8
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL2 corresponds to the value LOCAL2 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL2 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 9
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL3 corresponds to the value LOCAL3 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL3 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 10
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL4 corresponds to the value LOCAL4 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL4 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 11
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL5 corresponds to the value LOCAL5 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL5 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 12
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL6 corresponds to the value LOCAL6 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL6 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 13
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL7 corresponds to the value LOCAL7 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL7 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 14
	// OpenconfigSystemLogging_SYSLOG_FACILITY_MAIL corresponds to the value MAIL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_MAIL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 15
	// OpenconfigSystemLogging_SYSLOG_FACILITY_NTP corresponds to the value NTP of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_NTP E_OpenconfigSystemLogging_SYSLOG_FACILITY = 16
	// OpenconfigSystemLogging_SYSLOG_FACILITY_SYSLOG corresponds to the value SYSLOG of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_SYSLOG E_OpenconfigSystemLogging_SYSLOG_FACILITY = 17
	// OpenconfigSystemLogging_SYSLOG_FACILITY_SYSTEM_DAEMON corresponds to the value SYSTEM_DAEMON of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_SYSTEM_DAEMON E_OpenconfigSystemLogging_SYSLOG_FACILITY = 18
	// OpenconfigSystemLogging_SYSLOG_FACILITY_USER corresponds to the value USER of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_USER E_OpenconfigSystemLogging_SYSLOG_FACILITY = 19
)

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) IsYANGGoEnum 

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemLogging_SYSLOG_FACILITY implements the yang.GoEnum interface. This ensures that OpenconfigSystemLogging_SYSLOG_FACILITY can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) ΛMap 

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemLogging_SYSLOG_FACILITY.

type E_OpenconfigSystemLogging_SyslogSeverity 

type E_OpenconfigSystemLogging_SyslogSeverity int64

E_OpenconfigSystemLogging_SyslogSeverity is a derived int64 type which is used to represent the enumerated node OpenconfigSystemLogging_SyslogSeverity. An additional value named OpenconfigSystemLogging_SyslogSeverity_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemLogging_SyslogSeverity_UNSET corresponds to the value UNSET of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_UNSET E_OpenconfigSystemLogging_SyslogSeverity = 0
	// OpenconfigSystemLogging_SyslogSeverity_EMERGENCY corresponds to the value EMERGENCY of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_EMERGENCY E_OpenconfigSystemLogging_SyslogSeverity = 1
	// OpenconfigSystemLogging_SyslogSeverity_ALERT corresponds to the value ALERT of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_ALERT E_OpenconfigSystemLogging_SyslogSeverity = 2
	// OpenconfigSystemLogging_SyslogSeverity_CRITICAL corresponds to the value CRITICAL of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_CRITICAL E_OpenconfigSystemLogging_SyslogSeverity = 3
	// OpenconfigSystemLogging_SyslogSeverity_ERROR corresponds to the value ERROR of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_ERROR E_OpenconfigSystemLogging_SyslogSeverity = 4
	// OpenconfigSystemLogging_SyslogSeverity_WARNING corresponds to the value WARNING of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_WARNING E_OpenconfigSystemLogging_SyslogSeverity = 5
	// OpenconfigSystemLogging_SyslogSeverity_NOTICE corresponds to the value NOTICE of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_NOTICE E_OpenconfigSystemLogging_SyslogSeverity = 6
	// OpenconfigSystemLogging_SyslogSeverity_INFORMATIONAL corresponds to the value INFORMATIONAL of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_INFORMATIONAL E_OpenconfigSystemLogging_SyslogSeverity = 7
	// OpenconfigSystemLogging_SyslogSeverity_DEBUG corresponds to the value DEBUG of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_DEBUG E_OpenconfigSystemLogging_SyslogSeverity = 8
)

func (E_OpenconfigSystemLogging_SyslogSeverity) IsYANGGoEnum 

func (E_OpenconfigSystemLogging_SyslogSeverity) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemLogging_SyslogSeverity implements the yang.GoEnum interface. This ensures that OpenconfigSystemLogging_SyslogSeverity can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemLogging_SyslogSeverity) ΛMap 

func (E_OpenconfigSystemLogging_SyslogSeverity) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemLogging_SyslogSeverity.

type E_OpenconfigSystem_NTP_AUTH_TYPE 

type E_OpenconfigSystem_NTP_AUTH_TYPE int64

E_OpenconfigSystem_NTP_AUTH_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigSystem_NTP_AUTH_TYPE. An additional value named OpenconfigSystem_NTP_AUTH_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystem_NTP_AUTH_TYPE_UNSET corresponds to the value UNSET of OpenconfigSystem_NTP_AUTH_TYPE
	OpenconfigSystem_NTP_AUTH_TYPE_UNSET E_OpenconfigSystem_NTP_AUTH_TYPE = 0
	// OpenconfigSystem_NTP_AUTH_TYPE_NTP_AUTH_MD5 corresponds to the value NTP_AUTH_MD5 of OpenconfigSystem_NTP_AUTH_TYPE
	OpenconfigSystem_NTP_AUTH_TYPE_NTP_AUTH_MD5 E_OpenconfigSystem_NTP_AUTH_TYPE = 1
)

func (E_OpenconfigSystem_NTP_AUTH_TYPE) IsYANGGoEnum 

func (E_OpenconfigSystem_NTP_AUTH_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystem_NTP_AUTH_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigSystem_NTP_AUTH_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystem_NTP_AUTH_TYPE) ΛMap 

func (E_OpenconfigSystem_NTP_AUTH_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystem_NTP_AUTH_TYPE.

type E_OpenconfigWifiTypes_CHANGE_REASON_TYPE 

type E_OpenconfigWifiTypes_CHANGE_REASON_TYPE int64

E_OpenconfigWifiTypes_CHANGE_REASON_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigWifiTypes_CHANGE_REASON_TYPE. An additional value named OpenconfigWifiTypes_CHANGE_REASON_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigWifiTypes_CHANGE_REASON_TYPE_UNSET corresponds to the value UNSET of OpenconfigWifiTypes_CHANGE_REASON_TYPE
	OpenconfigWifiTypes_CHANGE_REASON_TYPE_UNSET E_OpenconfigWifiTypes_CHANGE_REASON_TYPE = 0
	// OpenconfigWifiTypes_CHANGE_REASON_TYPE_BETTER_CHANNEL corresponds to the value BETTER_CHANNEL of OpenconfigWifiTypes_CHANGE_REASON_TYPE
	OpenconfigWifiTypes_CHANGE_REASON_TYPE_BETTER_CHANNEL E_OpenconfigWifiTypes_CHANGE_REASON_TYPE = 1
	// OpenconfigWifiTypes_CHANGE_REASON_TYPE_DFS corresponds to the value DFS of OpenconfigWifiTypes_CHANGE_REASON_TYPE
	OpenconfigWifiTypes_CHANGE_REASON_TYPE_DFS E_OpenconfigWifiTypes_CHANGE_REASON_TYPE = 2
	// OpenconfigWifiTypes_CHANGE_REASON_TYPE_ERRORS corresponds to the value ERRORS of OpenconfigWifiTypes_CHANGE_REASON_TYPE
	OpenconfigWifiTypes_CHANGE_REASON_TYPE_ERRORS E_OpenconfigWifiTypes_CHANGE_REASON_TYPE = 3
	// OpenconfigWifiTypes_CHANGE_REASON_TYPE_NOISE corresponds to the value NOISE of OpenconfigWifiTypes_CHANGE_REASON_TYPE
	OpenconfigWifiTypes_CHANGE_REASON_TYPE_NOISE E_OpenconfigWifiTypes_CHANGE_REASON_TYPE = 4
)

func (E_OpenconfigWifiTypes_CHANGE_REASON_TYPE) IsYANGGoEnum 

func (E_OpenconfigWifiTypes_CHANGE_REASON_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigWifiTypes_CHANGE_REASON_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigWifiTypes_CHANGE_REASON_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigWifiTypes_CHANGE_REASON_TYPE) ΛMap 

func (E_OpenconfigWifiTypes_CHANGE_REASON_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigWifiTypes_CHANGE_REASON_TYPE.

type E_OpenconfigWifiTypes_CLIENT_CAPABILITIES 

type E_OpenconfigWifiTypes_CLIENT_CAPABILITIES int64

E_OpenconfigWifiTypes_CLIENT_CAPABILITIES is a derived int64 type which is used to represent the enumerated node OpenconfigWifiTypes_CLIENT_CAPABILITIES. An additional value named OpenconfigWifiTypes_CLIENT_CAPABILITIES_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigWifiTypes_CLIENT_CAPABILITIES_UNSET corresponds to the value UNSET of OpenconfigWifiTypes_CLIENT_CAPABILITIES
	OpenconfigWifiTypes_CLIENT_CAPABILITIES_UNSET E_OpenconfigWifiTypes_CLIENT_CAPABILITIES = 0
	// OpenconfigWifiTypes_CLIENT_CAPABILITIES_DOT_11R corresponds to the value DOT_11R of OpenconfigWifiTypes_CLIENT_CAPABILITIES
	OpenconfigWifiTypes_CLIENT_CAPABILITIES_DOT_11R E_OpenconfigWifiTypes_CLIENT_CAPABILITIES = 1
	// OpenconfigWifiTypes_CLIENT_CAPABILITIES_DOT_11V corresponds to the value DOT_11V of OpenconfigWifiTypes_CLIENT_CAPABILITIES
	OpenconfigWifiTypes_CLIENT_CAPABILITIES_DOT_11V E_OpenconfigWifiTypes_CLIENT_CAPABILITIES = 2
	// OpenconfigWifiTypes_CLIENT_CAPABILITIES_MU_BEAMFORMEE corresponds to the value MU_BEAMFORMEE of OpenconfigWifiTypes_CLIENT_CAPABILITIES
	OpenconfigWifiTypes_CLIENT_CAPABILITIES_MU_BEAMFORMEE E_OpenconfigWifiTypes_CLIENT_CAPABILITIES = 3
	// OpenconfigWifiTypes_CLIENT_CAPABILITIES_MU_BEAMFORMER corresponds to the value MU_BEAMFORMER of OpenconfigWifiTypes_CLIENT_CAPABILITIES
	OpenconfigWifiTypes_CLIENT_CAPABILITIES_MU_BEAMFORMER E_OpenconfigWifiTypes_CLIENT_CAPABILITIES = 4
)

func (E_OpenconfigWifiTypes_CLIENT_CAPABILITIES) IsYANGGoEnum 

func (E_OpenconfigWifiTypes_CLIENT_CAPABILITIES) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigWifiTypes_CLIENT_CAPABILITIES implements the yang.GoEnum interface. This ensures that OpenconfigWifiTypes_CLIENT_CAPABILITIES can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigWifiTypes_CLIENT_CAPABILITIES) ΛMap 

func (E_OpenconfigWifiTypes_CLIENT_CAPABILITIES) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigWifiTypes_CLIENT_CAPABILITIES.

type E_OpenconfigWifiTypes_CLIENT_STATE 

type E_OpenconfigWifiTypes_CLIENT_STATE int64

E_OpenconfigWifiTypes_CLIENT_STATE is a derived int64 type which is used to represent the enumerated node OpenconfigWifiTypes_CLIENT_STATE. An additional value named OpenconfigWifiTypes_CLIENT_STATE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigWifiTypes_CLIENT_STATE_UNSET corresponds to the value UNSET of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_UNSET E_OpenconfigWifiTypes_CLIENT_STATE = 0
	// OpenconfigWifiTypes_CLIENT_STATE_ASSOCIATED corresponds to the value ASSOCIATED of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_ASSOCIATED E_OpenconfigWifiTypes_CLIENT_STATE = 1
	// OpenconfigWifiTypes_CLIENT_STATE_AUTHENTICATED corresponds to the value AUTHENTICATED of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_AUTHENTICATED E_OpenconfigWifiTypes_CLIENT_STATE = 2
	// OpenconfigWifiTypes_CLIENT_STATE_BLACKLISTED corresponds to the value BLACKLISTED of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_BLACKLISTED E_OpenconfigWifiTypes_CLIENT_STATE = 3
	// OpenconfigWifiTypes_CLIENT_STATE_DHCP_FAILURE corresponds to the value DHCP_FAILURE of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_DHCP_FAILURE E_OpenconfigWifiTypes_CLIENT_STATE = 4
	// OpenconfigWifiTypes_CLIENT_STATE_DHCP_REQD corresponds to the value DHCP_REQD of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_DHCP_REQD E_OpenconfigWifiTypes_CLIENT_STATE = 5
	// OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_FAILURE_REJECT corresponds to the value L2AUTH_FAILURE_REJECT of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_FAILURE_REJECT E_OpenconfigWifiTypes_CLIENT_STATE = 6
	// OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_FAILURE_TIMEOUT corresponds to the value L2AUTH_FAILURE_TIMEOUT of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_FAILURE_TIMEOUT E_OpenconfigWifiTypes_CLIENT_STATE = 7
	// OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_REQD corresponds to the value L2AUTH_REQD of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_L2AUTH_REQD E_OpenconfigWifiTypes_CLIENT_STATE = 8
	// OpenconfigWifiTypes_CLIENT_STATE_L3AUTH_FAILURE corresponds to the value L3AUTH_FAILURE of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_L3AUTH_FAILURE E_OpenconfigWifiTypes_CLIENT_STATE = 9
	// OpenconfigWifiTypes_CLIENT_STATE_L3AUTH_REQD corresponds to the value L3AUTH_REQD of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_L3AUTH_REQD E_OpenconfigWifiTypes_CLIENT_STATE = 10
	// OpenconfigWifiTypes_CLIENT_STATE_POWERSAVE corresponds to the value POWERSAVE of OpenconfigWifiTypes_CLIENT_STATE
	OpenconfigWifiTypes_CLIENT_STATE_POWERSAVE E_OpenconfigWifiTypes_CLIENT_STATE = 11
)

func (E_OpenconfigWifiTypes_CLIENT_STATE) IsYANGGoEnum 

func (E_OpenconfigWifiTypes_CLIENT_STATE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigWifiTypes_CLIENT_STATE implements the yang.GoEnum interface. This ensures that OpenconfigWifiTypes_CLIENT_STATE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigWifiTypes_CLIENT_STATE) ΛMap 

func (E_OpenconfigWifiTypes_CLIENT_STATE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigWifiTypes_CLIENT_STATE.

type E_OpenconfigWifiTypes_DATA_RATE 

type E_OpenconfigWifiTypes_DATA_RATE int64

E_OpenconfigWifiTypes_DATA_RATE is a derived int64 type which is used to represent the enumerated node OpenconfigWifiTypes_DATA_RATE. An additional value named OpenconfigWifiTypes_DATA_RATE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigWifiTypes_DATA_RATE_UNSET corresponds to the value UNSET of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_UNSET E_OpenconfigWifiTypes_DATA_RATE = 0
	// OpenconfigWifiTypes_DATA_RATE_RATE_11MB corresponds to the value RATE_11MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_11MB E_OpenconfigWifiTypes_DATA_RATE = 1
	// OpenconfigWifiTypes_DATA_RATE_RATE_12MB corresponds to the value RATE_12MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_12MB E_OpenconfigWifiTypes_DATA_RATE = 2
	// OpenconfigWifiTypes_DATA_RATE_RATE_18MB corresponds to the value RATE_18MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_18MB E_OpenconfigWifiTypes_DATA_RATE = 3
	// OpenconfigWifiTypes_DATA_RATE_RATE_1MB corresponds to the value RATE_1MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_1MB E_OpenconfigWifiTypes_DATA_RATE = 4
	// OpenconfigWifiTypes_DATA_RATE_RATE_24MB corresponds to the value RATE_24MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_24MB E_OpenconfigWifiTypes_DATA_RATE = 5
	// OpenconfigWifiTypes_DATA_RATE_RATE_2MB corresponds to the value RATE_2MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_2MB E_OpenconfigWifiTypes_DATA_RATE = 6
	// OpenconfigWifiTypes_DATA_RATE_RATE_36MB corresponds to the value RATE_36MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_36MB E_OpenconfigWifiTypes_DATA_RATE = 7
	// OpenconfigWifiTypes_DATA_RATE_RATE_48MB corresponds to the value RATE_48MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_48MB E_OpenconfigWifiTypes_DATA_RATE = 8
	// OpenconfigWifiTypes_DATA_RATE_RATE_5_5MB corresponds to the value RATE_5_5MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_5_5MB E_OpenconfigWifiTypes_DATA_RATE = 9
	// OpenconfigWifiTypes_DATA_RATE_RATE_54MB corresponds to the value RATE_54MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_54MB E_OpenconfigWifiTypes_DATA_RATE = 10
	// OpenconfigWifiTypes_DATA_RATE_RATE_6MB corresponds to the value RATE_6MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_6MB E_OpenconfigWifiTypes_DATA_RATE = 11
	// OpenconfigWifiTypes_DATA_RATE_RATE_9MB corresponds to the value RATE_9MB of OpenconfigWifiTypes_DATA_RATE
	OpenconfigWifiTypes_DATA_RATE_RATE_9MB E_OpenconfigWifiTypes_DATA_RATE = 12
)

func (E_OpenconfigWifiTypes_DATA_RATE) IsYANGGoEnum 

func (E_OpenconfigWifiTypes_DATA_RATE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigWifiTypes_DATA_RATE implements the yang.GoEnum interface. This ensures that OpenconfigWifiTypes_DATA_RATE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigWifiTypes_DATA_RATE) ΛMap 

func (E_OpenconfigWifiTypes_DATA_RATE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigWifiTypes_DATA_RATE.

type E_OpenconfigWifiTypes_OPERATING_FREQUENCY 

type E_OpenconfigWifiTypes_OPERATING_FREQUENCY int64

E_OpenconfigWifiTypes_OPERATING_FREQUENCY is a derived int64 type which is used to represent the enumerated node OpenconfigWifiTypes_OPERATING_FREQUENCY. An additional value named OpenconfigWifiTypes_OPERATING_FREQUENCY_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigWifiTypes_OPERATING_FREQUENCY_UNSET corresponds to the value UNSET of OpenconfigWifiTypes_OPERATING_FREQUENCY
	OpenconfigWifiTypes_OPERATING_FREQUENCY_UNSET E_OpenconfigWifiTypes_OPERATING_FREQUENCY = 0
	// OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_2GHZ corresponds to the value FREQ_2GHZ of OpenconfigWifiTypes_OPERATING_FREQUENCY
	OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_2GHZ E_OpenconfigWifiTypes_OPERATING_FREQUENCY = 1
	// OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_2_5_GHZ corresponds to the value FREQ_2_5_GHZ of OpenconfigWifiTypes_OPERATING_FREQUENCY
	OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_2_5_GHZ E_OpenconfigWifiTypes_OPERATING_FREQUENCY = 2
	// OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_5GHZ corresponds to the value FREQ_5GHZ of OpenconfigWifiTypes_OPERATING_FREQUENCY
	OpenconfigWifiTypes_OPERATING_FREQUENCY_FREQ_5GHZ E_OpenconfigWifiTypes_OPERATING_FREQUENCY = 3
)

func (E_OpenconfigWifiTypes_OPERATING_FREQUENCY) IsYANGGoEnum 

func (E_OpenconfigWifiTypes_OPERATING_FREQUENCY) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigWifiTypes_OPERATING_FREQUENCY implements the yang.GoEnum interface. This ensures that OpenconfigWifiTypes_OPERATING_FREQUENCY can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigWifiTypes_OPERATING_FREQUENCY) ΛMap 

func (E_OpenconfigWifiTypes_OPERATING_FREQUENCY) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigWifiTypes_OPERATING_FREQUENCY.

type OpenconfigAccessPoints_AccessPoints 

type OpenconfigAccessPoints_AccessPoints struct {
	AccessPoint map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint `path:"access-point" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints represents the /openconfig-access-points/access-points YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints) NewAccessPoint 

func (t *OpenconfigAccessPoints_AccessPoints) NewAccessPoint(Hostname string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint, error)

NewAccessPoint creates a new entry in the AccessPoint list of the OpenconfigAccessPoints_AccessPoints struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints) Validate 

func (s *OpenconfigAccessPoints_AccessPoints) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint 

type OpenconfigAccessPoints_AccessPoints_AccessPoint struct {
	AssignedApManagers *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers `path:"assigned-ap-managers" module:"openconfig-access-points"`
	Hostname           *string                                                             `path:"hostname" module:"openconfig-access-points"`
	Radios             *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios             `path:"radios" module:"openconfig-access-points"`
	Ssids              *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids              `path:"ssids" module:"openconfig-access-points"`
	System             *OpenconfigAccessPoints_AccessPoints_AccessPoint_System             `path:"system" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint represents the /openconfig-access-points/access-points/access-point YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers struct {
	ApManager map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager `path:"ap-manager" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers represents the /openconfig-access-points/access-points/access-point/assigned-ap-managers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) NewApManager 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) NewApManager(Id string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager, error)

NewApManager creates a new entry in the ApManager list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config `path:"config" module:"openconfig-access-points"`
	Id     *string                                                                              `path:"id" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager represents the /openconfig-access-points/access-points/access-point/assigned-ap-managers/ap-manager YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config struct {
	ApManagerIpv4Address *string  `path:"ap-manager-ipv4-address" module:"openconfig-access-points"`
	ApManagerIpv6Address []string `path:"ap-manager-ipv6-address" module:"openconfig-access-points"`
	Fqdn                 *string  `path:"fqdn" module:"openconfig-access-points"`
	Id                   *string  `path:"id" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config represents the /openconfig-access-points/access-points/access-point/assigned-ap-managers/ap-manager/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State struct {
	ApManagerIpv4Address *string  `path:"ap-manager-ipv4-address" module:"openconfig-access-points"`
	ApManagerIpv6Address []string `path:"ap-manager-ipv6-address" module:"openconfig-access-points"`
	Fqdn                 *string  `path:"fqdn" module:"openconfig-access-points"`
	Id                   *string  `path:"id" module:"openconfig-access-points"`
	Joined               *bool    `path:"joined" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State represents the /openconfig-access-points/access-points/access-point/assigned-ap-managers/ap-manager/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios struct {
	Radio map[uint8]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio `path:"radio" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios represents the /openconfig-access-points/access-points/access-point/radios YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) NewRadio 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) NewRadio(Id uint8) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio, error)

NewRadio creates a new entry in the Radio list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio struct {
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config    `path:"config" module:"openconfig-access-points"`
	Id        *uint8                                                                  `path:"id" module:"openconfig-access-points"`
	Neighbors *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors `path:"neighbors" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State     `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio represents the /openconfig-access-points/access-points/access-point/radios/radio YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config struct {
	AllowedChannels      []uint8                                   `path:"allowed-channels" module:"openconfig-access-points"`
	AntennaGain          *int8                                     `path:"antenna-gain" module:"openconfig-access-points"`
	Channel              *uint8                                    `path:"channel" module:"openconfig-access-points"`
	ChannelWidth         *uint8                                    `path:"channel-width" module:"openconfig-access-points"`
	Dca                  *bool                                     `path:"dca" module:"openconfig-access-points"`
	Dtp                  *bool                                     `path:"dtp" module:"openconfig-access-points"`
	DtpMax               *uint8                                    `path:"dtp-max" module:"openconfig-access-points"`
	DtpMin               *uint8                                    `path:"dtp-min" module:"openconfig-access-points"`
	Enabled              *bool                                     `path:"enabled" module:"openconfig-access-points"`
	Id                   *uint8                                    `path:"id" module:"openconfig-access-points"`
	OperatingFrequency   E_OpenconfigWifiTypes_OPERATING_FREQUENCY `path:"operating-frequency" module:"openconfig-access-points"`
	Scanning             *bool                                     `path:"scanning" module:"openconfig-access-points"`
	ScanningDeferClients *uint8                                    `path:"scanning-defer-clients" module:"openconfig-access-points"`
	ScanningDeferTraffic *bool                                     `path:"scanning-defer-traffic" module:"openconfig-access-points"`
	ScanningDwellTime    *uint16                                   `path:"scanning-dwell-time" module:"openconfig-access-points"`
	ScanningInterval     *uint8                                    `path:"scanning-interval" module:"openconfig-access-points"`
	TransmitPower        *uint8                                    `path:"transmit-power" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config represents the /openconfig-access-points/access-points/access-point/radios/radio/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors struct {
	Neighbor map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor `path:"neighbor" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors represents the /openconfig-access-points/access-points/access-point/radios/radio/neighbors YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) NewNeighbor 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) NewNeighbor(Bssid string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor, error)

NewNeighbor creates a new entry in the Neighbor list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor struct {
	Bssid *string                                                                                `path:"bssid" module:"openconfig-access-points"`
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor represents the /openconfig-access-points/access-points/access-point/radios/radio/neighbors/neighbor YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State struct {
	Bssid          *string `path:"bssid" module:"openconfig-access-points"`
	Channel        *uint16 `path:"channel" module:"openconfig-access-points"`
	LastSeen       *uint64 `path:"last-seen" module:"openconfig-access-points"`
	PrimaryChannel *uint16 `path:"primary-channel" module:"openconfig-access-points"`
	Rssi           *int8   `path:"rssi" module:"openconfig-access-points"`
	Ssid           *string `path:"ssid" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State represents the /openconfig-access-points/access-points/access-point/radios/radio/neighbors/neighbor/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State struct {
	AllowedChannels           []uint8                                                                      `path:"allowed-channels" module:"openconfig-access-points"`
	AntennaGain               *int8                                                                        `path:"antenna-gain" module:"openconfig-access-points"`
	BaseRadioMac              *string                                                                      `path:"base-radio-mac" module:"openconfig-access-points"`
	Channel                   *uint8                                                                       `path:"channel" module:"openconfig-access-points"`
	ChannelChangeReason       E_OpenconfigWifiTypes_CHANGE_REASON_TYPE                                     `path:"channel-change-reason" module:"openconfig-access-points"`
	ChannelWidth              *uint8                                                                       `path:"channel-width" module:"openconfig-access-points"`
	Counters                  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters `path:"counters" module:"openconfig-access-points"`
	Dca                       *bool                                                                        `path:"dca" module:"openconfig-access-points"`
	DfsHitTime                *uint64                                                                      `path:"dfs-hit-time" module:"openconfig-access-points"`
	Dtp                       *bool                                                                        `path:"dtp" module:"openconfig-access-points"`
	DtpMax                    *uint8                                                                       `path:"dtp-max" module:"openconfig-access-points"`
	DtpMin                    *uint8                                                                       `path:"dtp-min" module:"openconfig-access-points"`
	Enabled                   *bool                                                                        `path:"enabled" module:"openconfig-access-points"`
	Id                        *uint8                                                                       `path:"id" module:"openconfig-access-points"`
	OperatingFrequency        E_OpenconfigWifiTypes_OPERATING_FREQUENCY                                    `path:"operating-frequency" module:"openconfig-access-points"`
	RxDot11ChannelUtilization *uint8                                                                       `path:"rx-dot11-channel-utilization" module:"openconfig-access-points"`
	RxNoiseChannelUtilization *uint8                                                                       `path:"rx-noise-channel-utilization" module:"openconfig-access-points"`
	Scanning                  *bool                                                                        `path:"scanning" module:"openconfig-access-points"`
	ScanningDeferClients      *uint8                                                                       `path:"scanning-defer-clients" module:"openconfig-access-points"`
	ScanningDeferTraffic      *bool                                                                        `path:"scanning-defer-traffic" module:"openconfig-access-points"`
	ScanningDwellTime         *uint16                                                                      `path:"scanning-dwell-time" module:"openconfig-access-points"`
	ScanningInterval          *uint8                                                                       `path:"scanning-interval" module:"openconfig-access-points"`
	TotalChannelUtilization   *uint8                                                                       `path:"total-channel-utilization" module:"openconfig-access-points"`
	TransmitPower             *uint8                                                                       `path:"transmit-power" module:"openconfig-access-points"`
	TxDot11ChannelUtilization *uint8                                                                       `path:"tx-dot11-channel-utilization" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State represents the /openconfig-access-points/access-points/access-point/radios/radio/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters struct {
	FailedFcsFrames *uint64 `path:"failed-fcs-frames" module:"openconfig-access-points"`
	NoiseFloor      *int8   `path:"noise-floor" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters represents the /openconfig-access-points/access-points/access-point/radios/radio/state/counters YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids struct {
	Ssid map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid `path:"ssid" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids represents the /openconfig-access-points/access-points/access-point/ssids YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) NewSsid 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) NewSsid(Name string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid, error)

NewSsid creates a new entry in the Ssid list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid struct {
	BandSteering *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering `path:"band-steering" module:"openconfig-access-points"`
	Bssids       *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids       `path:"bssids" module:"openconfig-access-points"`
	Clients      *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients      `path:"clients" module:"openconfig-access-points"`
	Config       *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config       `path:"config" module:"openconfig-access-points"`
	Dot11R       *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R       `path:"dot11r" module:"openconfig-access-points"`
	Dot11V       *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V       `path:"dot11v" module:"openconfig-access-points"`
	Dot1XTimers  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers  `path:"dot1x-timers" module:"openconfig-access-points"`
	Name         *string                                                                  `path:"name" module:"openconfig-access-points"`
	State        *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State        `path:"state" module:"openconfig-access-points"`
	Wmm          *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm          `path:"wmm" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid represents the /openconfig-access-points/access-points/access-point/ssids/ssid YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering represents the /openconfig-access-points/access-points/access-point/ssids/ssid/band-steering YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config struct {
	BandSteering *bool `path:"band-steering" module:"openconfig-access-points"`
	SteeringRssi *int8 `path:"steering-rssi" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/band-steering/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State struct {
	BandSteering *bool `path:"band-steering" module:"openconfig-access-points"`
	SteeringRssi *int8 `path:"steering-rssi" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/band-steering/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids struct {
	Bssid map[OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid `path:"bssid" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) NewBssid 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) NewBssid(RadioId uint8, Bssid string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid, error)

NewBssid creates a new entry in the Bssid list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid struct {
	Bssid   *string                                                                        `path:"bssid" module:"openconfig-access-points"`
	RadioId *uint8                                                                         `path:"radio-id" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key struct {
	RadioId uint8  `path:"radio-id"`
	Bssid   string `path:"bssid"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key represents the key for list Bssid of element /openconfig-access-points/access-points/access-point/ssids/ssid/bssids.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State struct {
	Bssid                *string                                                                                 `path:"bssid" module:"openconfig-access-points"`
	Counters             *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters `path:"counters" module:"openconfig-access-points"`
	NumAssociatedClients *uint8                                                                                  `path:"num-associated-clients" module:"openconfig-access-points"`
	RadioId              *uint8                                                                                  `path:"radio-id" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters struct {
	BssChannelUtilization        *uint8                                                                                             `path:"bss-channel-utilization" module:"openconfig-access-points"`
	RxBssDot11ChannelUtilization *uint8                                                                                             `path:"rx-bss-dot11-channel-utilization" module:"openconfig-access-points"`
	RxBytesData                  *uint64                                                                                            `path:"rx-bytes-data" module:"openconfig-access-points"`
	RxControl                    *uint64                                                                                            `path:"rx-control" module:"openconfig-access-points"`
	RxDataDist                   *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist `path:"rx-data-dist" module:"openconfig-access-points"`
	RxDataWmm                    *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm  `path:"rx-data-wmm" module:"openconfig-access-points"`
	RxMcs                        *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs      `path:"rx-mcs" module:"openconfig-access-points"`
	RxMgmt                       *uint64                                                                                            `path:"rx-mgmt" module:"openconfig-access-points"`
	RxRetries                    *uint64                                                                                            `path:"rx-retries" module:"openconfig-access-points"`
	RxRetriesData                *uint64                                                                                            `path:"rx-retries-data" module:"openconfig-access-points"`
	RxRetriesSubframe            *uint64                                                                                            `path:"rx-retries-subframe" module:"openconfig-access-points"`
	TxBssDot11ChannelUtilization *uint8                                                                                             `path:"tx-bss-dot11-channel-utilization" module:"openconfig-access-points"`
	TxBytesData                  *uint64                                                                                            `path:"tx-bytes-data" module:"openconfig-access-points"`
	TxControl                    *uint64                                                                                            `path:"tx-control" module:"openconfig-access-points"`
	TxDataDist                   *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist `path:"tx-data-dist" module:"openconfig-access-points"`
	TxDataWmm                    *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm  `path:"tx-data-wmm" module:"openconfig-access-points"`
	TxMcs                        *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs      `path:"tx-mcs" module:"openconfig-access-points"`
	TxMgmt                       *uint64                                                                                            `path:"tx-mgmt" module:"openconfig-access-points"`
	TxRetries                    *uint64                                                                                            `path:"tx-retries" module:"openconfig-access-points"`
	TxRetriesData                *uint64                                                                                            `path:"tx-retries-data" module:"openconfig-access-points"`
	TxRetriesSubframe            *uint64                                                                                            `path:"tx-retries-subframe" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist struct {
	Rx_0_64           *uint64 `path:"rx-0-64" module:"openconfig-access-points"`
	Rx_1025_2048      *uint64 `path:"rx-1025-2048" module:"openconfig-access-points"`
	Rx_129_256        *uint64 `path:"rx-129-256" module:"openconfig-access-points"`
	Rx_131073_262144  *uint64 `path:"rx-131073-262144" module:"openconfig-access-points"`
	Rx_16385_32768    *uint64 `path:"rx-16385-32768" module:"openconfig-access-points"`
	Rx_2049_4096      *uint64 `path:"rx-2049-4096" module:"openconfig-access-points"`
	Rx_257_512        *uint64 `path:"rx-257-512" module:"openconfig-access-points"`
	Rx_262145_524288  *uint64 `path:"rx-262145-524288" module:"openconfig-access-points"`
	Rx_32769_65536    *uint64 `path:"rx-32769-65536" module:"openconfig-access-points"`
	Rx_4097_8192      *uint64 `path:"rx-4097-8192" module:"openconfig-access-points"`
	Rx_513_1024       *uint64 `path:"rx-513-1024" module:"openconfig-access-points"`
	Rx_524289_1048576 *uint64 `path:"rx-524289-1048576" module:"openconfig-access-points"`
	Rx_65_128         *uint64 `path:"rx-65-128" module:"openconfig-access-points"`
	Rx_65537_131072   *uint64 `path:"rx-65537-131072" module:"openconfig-access-points"`
	Rx_8193_16384     *uint64 `path:"rx-8193-16384" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/rx-data-dist YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataDist) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm struct {
	Be *uint64 `path:"be" module:"openconfig-access-points"`
	Bk *uint64 `path:"bk" module:"openconfig-access-points"`
	Vi *uint64 `path:"vi" module:"openconfig-access-points"`
	Vo *uint64 `path:"vo" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/rx-data-wmm YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxDataWmm) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs struct {
	Mcs0 *uint64 `path:"mcs0" module:"openconfig-access-points"`
	Mcs1 *uint64 `path:"mcs1" module:"openconfig-access-points"`
	Mcs2 *uint64 `path:"mcs2" module:"openconfig-access-points"`
	Mcs3 *uint64 `path:"mcs3" module:"openconfig-access-points"`
	Mcs4 *uint64 `path:"mcs4" module:"openconfig-access-points"`
	Mcs5 *uint64 `path:"mcs5" module:"openconfig-access-points"`
	Mcs6 *uint64 `path:"mcs6" module:"openconfig-access-points"`
	Mcs7 *uint64 `path:"mcs7" module:"openconfig-access-points"`
	Mcs8 *uint64 `path:"mcs8" module:"openconfig-access-points"`
	Mcs9 *uint64 `path:"mcs9" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/rx-mcs YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_RxMcs) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist struct {
	Tx_0_64           *uint64 `path:"tx-0-64" module:"openconfig-access-points"`
	Tx_1025_2048      *uint64 `path:"tx-1025-2048" module:"openconfig-access-points"`
	Tx_129_256        *uint64 `path:"tx-129-256" module:"openconfig-access-points"`
	Tx_131073_262144  *uint64 `path:"tx-131073-262144" module:"openconfig-access-points"`
	Tx_16385_32768    *uint64 `path:"tx-16385-32768" module:"openconfig-access-points"`
	Tx_2049_4096      *uint64 `path:"tx-2049-4096" module:"openconfig-access-points"`
	Tx_257_512        *uint64 `path:"tx-257-512" module:"openconfig-access-points"`
	Tx_262145_524288  *uint64 `path:"tx-262145-524288" module:"openconfig-access-points"`
	Tx_32769_65536    *uint64 `path:"tx-32769-65536" module:"openconfig-access-points"`
	Tx_4097_8192      *uint64 `path:"tx-4097-8192" module:"openconfig-access-points"`
	Tx_513_1024       *uint64 `path:"tx-513-1024" module:"openconfig-access-points"`
	Tx_524289_1048576 *uint64 `path:"tx-524289-1048576" module:"openconfig-access-points"`
	Tx_65_128         *uint64 `path:"tx-65-128" module:"openconfig-access-points"`
	Tx_65537_131072   *uint64 `path:"tx-65537-131072" module:"openconfig-access-points"`
	Tx_8193_16384     *uint64 `path:"tx-8193-16384" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/tx-data-dist YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataDist) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm struct {
	Be *uint64 `path:"be" module:"openconfig-access-points"`
	Bk *uint64 `path:"bk" module:"openconfig-access-points"`
	Vi *uint64 `path:"vi" module:"openconfig-access-points"`
	Vo *uint64 `path:"vo" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/tx-data-wmm YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxDataWmm) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs struct {
	Mcs0 *uint64 `path:"mcs0" module:"openconfig-access-points"`
	Mcs1 *uint64 `path:"mcs1" module:"openconfig-access-points"`
	Mcs2 *uint64 `path:"mcs2" module:"openconfig-access-points"`
	Mcs3 *uint64 `path:"mcs3" module:"openconfig-access-points"`
	Mcs4 *uint64 `path:"mcs4" module:"openconfig-access-points"`
	Mcs5 *uint64 `path:"mcs5" module:"openconfig-access-points"`
	Mcs6 *uint64 `path:"mcs6" module:"openconfig-access-points"`
	Mcs7 *uint64 `path:"mcs7" module:"openconfig-access-points"`
	Mcs8 *uint64 `path:"mcs8" module:"openconfig-access-points"`
	Mcs9 *uint64 `path:"mcs9" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs represents the /openconfig-access-points/access-points/access-point/ssids/ssid/bssids/bssid/state/counters/tx-mcs YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_State_Counters_TxMcs) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients struct {
	Client map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client `path:"client" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) NewClient 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) NewClient(Mac string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client, error)

NewClient creates a new entry in the Client list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client struct {
	ClientCapabilities *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities `path:"client-capabilities" module:"openconfig-access-points"`
	ClientConnection   *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection   `path:"client-connection" module:"openconfig-access-points"`
	ClientRf           *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf           `path:"client-rf" module:"openconfig-access-points"`
	Dot11KNeighbors    *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors    `path:"dot11k-neighbors" module:"openconfig-access-points"`
	Mac                *string                                                                                       `path:"mac" module:"openconfig-access-points"`
	State              *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State              `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities struct {
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-capabilities YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State struct {
	ChannelSupport     []uint8                                     `path:"channel-support" module:"openconfig-access-points"`
	ClientCapabilities []E_OpenconfigWifiTypes_CLIENT_CAPABILITIES `path:"client-capabilities" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-capabilities/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientCapabilities_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection struct {
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-connection YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State struct {
	ClientState     E_OpenconfigWifiTypes_CLIENT_STATE `path:"client-state" module:"openconfig-access-points"`
	ConnectionTime  *uint16                            `path:"connection-time" module:"openconfig-access-points"`
	Hostname        *string                            `path:"hostname" module:"openconfig-access-points"`
	Ipv4Address     *string                            `path:"ipv4-address" module:"openconfig-access-points"`
	Ipv6Address     *string                            `path:"ipv6-address" module:"openconfig-access-points"`
	OperatingSystem *string                            `path:"operating-system" module:"openconfig-access-points"`
	Username        *string                            `path:"username" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-connection/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientConnection_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf struct {
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-rf YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State struct {
	ConnectionMode E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State_ConnectionMode `path:"connection-mode" module:"openconfig-access-points"`
	Frequency      *uint8                                                                                                    `path:"frequency" module:"openconfig-access-points"`
	PhyRate        *uint16                                                                                                   `path:"phy-rate" module:"openconfig-access-points"`
	Rssi           *int8                                                                                                     `path:"rssi" module:"openconfig-access-points"`
	Snr            *uint8                                                                                                    `path:"snr" module:"openconfig-access-points"`
	Ss             *uint8                                                                                                    `path:"ss" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/client-rf/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_ClientRf_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors struct {
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/dot11k-neighbors YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State struct {
	ChannelLoadReport *uint8  `path:"channel-load-report" module:"openconfig-access-points"`
	NeighborAntenna   *uint8  `path:"neighbor-antenna" module:"openconfig-access-points"`
	NeighborBssid     *string `path:"neighbor-bssid" module:"openconfig-access-points"`
	NeighborChannel   *uint8  `path:"neighbor-channel" module:"openconfig-access-points"`
	NeighborRssi      *int8   `path:"neighbor-rssi" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/dot11k-neighbors/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_Dot11KNeighbors_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State struct {
	Counters *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters `path:"counters" module:"openconfig-access-points"`
	Mac      *string                                                                                   `path:"mac" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters struct {
	RxBytes   *uint64 `path:"rx-bytes" module:"openconfig-access-points"`
	RxRetries *uint64 `path:"rx-retries" module:"openconfig-access-points"`
	TxBytes   *uint64 `path:"tx-bytes" module:"openconfig-access-points"`
	TxRetries *uint64 `path:"tx-retries" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters represents the /openconfig-access-points/access-points/access-point/ssids/ssid/clients/client/state/counters YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Clients_Client_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config struct {
	AdvertiseApname    *bool                                                                      `path:"advertise-apname" module:"openconfig-access-points"`
	BasicDataRates     []E_OpenconfigWifiTypes_DATA_RATE                                          `path:"basic-data-rates" module:"openconfig-access-points"`
	BroadcastFilter    *bool                                                                      `path:"broadcast-filter" module:"openconfig-access-points"`
	Csa                *bool                                                                      `path:"csa" module:"openconfig-access-points"`
	DefaultVlan        *uint16                                                                    `path:"default-vlan" module:"openconfig-access-points"`
	DhcpRequired       *bool                                                                      `path:"dhcp-required" module:"openconfig-access-points"`
	Dot11K             *bool                                                                      `path:"dot11k" module:"openconfig-access-points"`
	Dva                *bool                                                                      `path:"dva" module:"openconfig-access-points"`
	Enabled            *bool                                                                      `path:"enabled" module:"openconfig-access-points"`
	GtkTimeout         *uint16                                                                    `path:"gtk-timeout" module:"openconfig-access-points"`
	Hidden             *bool                                                                      `path:"hidden" module:"openconfig-access-points"`
	Ipv6NdpFilter      *bool                                                                      `path:"ipv6-ndp-filter" module:"openconfig-access-points"`
	Ipv6NdpFilterTimer *uint16                                                                    `path:"ipv6-ndp-filter-timer" module:"openconfig-access-points"`
	MobilityDomain     *string                                                                    `path:"mobility-domain" module:"openconfig-access-points"`
	MulticastFilter    *bool                                                                      `path:"multicast-filter" module:"openconfig-access-points"`
	Name               *string                                                                    `path:"name" module:"openconfig-access-points"`
	Okc                *bool                                                                      `path:"okc" module:"openconfig-access-points"`
	OperatingFrequency E_OpenconfigWifiTypes_OPERATING_FREQUENCY                                  `path:"operating-frequency" module:"openconfig-access-points"`
	Opmode             E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode `path:"opmode" module:"openconfig-access-points"`
	PtkTimeout         *uint16                                                                    `path:"ptk-timeout" module:"openconfig-access-points"`
	QbssLoad           *bool                                                                      `path:"qbss-load" module:"openconfig-access-points"`
	ServerGroup        *string                                                                    `path:"server-group" module:"openconfig-access-points"`
	StationIsolation   *bool                                                                      `path:"station-isolation" module:"openconfig-access-points"`
	SupportedDataRates []E_OpenconfigWifiTypes_DATA_RATE                                          `path:"supported-data-rates" module:"openconfig-access-points"`
	VlanList           []uint16                                                                   `path:"vlan-list" module:"openconfig-access-points"`
	Wpa2Psk            *string                                                                    `path:"wpa2-psk" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot1x-timers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config struct {
	BlacklistTime   *uint16 `path:"blacklist-time" module:"openconfig-access-points"`
	MaxAuthFailures *uint8  `path:"max-auth-failures" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot1x-timers/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State struct {
	BlacklistTime   *uint16 `path:"blacklist-time" module:"openconfig-access-points"`
	MaxAuthFailures *uint8  `path:"max-auth-failures" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot1x-timers/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot1XTimers_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11r YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config struct {
	Dot11R             *bool                                                                                   `path:"dot11r" module:"openconfig-access-points"`
	Dot11RDomainid     *uint16                                                                                 `path:"dot11r-domainid" module:"openconfig-access-points"`
	Dot11RMethod       E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod `path:"dot11r-method" module:"openconfig-access-points"`
	Dot11RR1KeyTimeout *uint16                                                                                 `path:"dot11r-r1key-timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11r/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State struct {
	Dot11R             *bool                                                                                   `path:"dot11r" module:"openconfig-access-points"`
	Dot11RDomainid     *uint16                                                                                 `path:"dot11r-domainid" module:"openconfig-access-points"`
	Dot11RMethod       E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_Config_Dot11RMethod `path:"dot11r-method" module:"openconfig-access-points"`
	Dot11RR1KeyTimeout *uint16                                                                                 `path:"dot11r-r1key-timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11r/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11R_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11v YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config struct {
	Dot11VBssidle        *bool   `path:"dot11v-bssidle" module:"openconfig-access-points"`
	Dot11VBssidleTimeout *uint16 `path:"dot11v-bssidle-timeout" module:"openconfig-access-points"`
	Dot11VBsstransition  *bool   `path:"dot11v-bsstransition" module:"openconfig-access-points"`
	Dot11VDms            *bool   `path:"dot11v-dms" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11v/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State struct {
	Dot11VBssidle        *bool   `path:"dot11v-bssidle" module:"openconfig-access-points"`
	Dot11VBssidleTimeout *uint16 `path:"dot11v-bssidle-timeout" module:"openconfig-access-points"`
	Dot11VBsstransition  *bool   `path:"dot11v-bsstransition" module:"openconfig-access-points"`
	Dot11VDms            *bool   `path:"dot11v-dms" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/dot11v/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Dot11V_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State struct {
	AdvertiseApname    *bool                                                                      `path:"advertise-apname" module:"openconfig-access-points"`
	BasicDataRates     []E_OpenconfigWifiTypes_DATA_RATE                                          `path:"basic-data-rates" module:"openconfig-access-points"`
	BroadcastFilter    *bool                                                                      `path:"broadcast-filter" module:"openconfig-access-points"`
	Csa                *bool                                                                      `path:"csa" module:"openconfig-access-points"`
	DefaultVlan        *uint16                                                                    `path:"default-vlan" module:"openconfig-access-points"`
	DhcpRequired       *bool                                                                      `path:"dhcp-required" module:"openconfig-access-points"`
	Dot11K             *bool                                                                      `path:"dot11k" module:"openconfig-access-points"`
	Dva                *bool                                                                      `path:"dva" module:"openconfig-access-points"`
	Enabled            *bool                                                                      `path:"enabled" module:"openconfig-access-points"`
	GtkTimeout         *uint16                                                                    `path:"gtk-timeout" module:"openconfig-access-points"`
	Hidden             *bool                                                                      `path:"hidden" module:"openconfig-access-points"`
	Ipv6NdpFilter      *bool                                                                      `path:"ipv6-ndp-filter" module:"openconfig-access-points"`
	Ipv6NdpFilterTimer *uint16                                                                    `path:"ipv6-ndp-filter-timer" module:"openconfig-access-points"`
	MobilityDomain     *string                                                                    `path:"mobility-domain" module:"openconfig-access-points"`
	MulticastFilter    *bool                                                                      `path:"multicast-filter" module:"openconfig-access-points"`
	Name               *string                                                                    `path:"name" module:"openconfig-access-points"`
	Okc                *bool                                                                      `path:"okc" module:"openconfig-access-points"`
	OperatingFrequency E_OpenconfigWifiTypes_OPERATING_FREQUENCY                                  `path:"operating-frequency" module:"openconfig-access-points"`
	Opmode             E_OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Config_Opmode `path:"opmode" module:"openconfig-access-points"`
	PtkTimeout         *uint16                                                                    `path:"ptk-timeout" module:"openconfig-access-points"`
	QbssLoad           *bool                                                                      `path:"qbss-load" module:"openconfig-access-points"`
	ServerGroup        *string                                                                    `path:"server-group" module:"openconfig-access-points"`
	StationIsolation   *bool                                                                      `path:"station-isolation" module:"openconfig-access-points"`
	SupportedDataRates []E_OpenconfigWifiTypes_DATA_RATE                                          `path:"supported-data-rates" module:"openconfig-access-points"`
	VlanList           []uint16                                                                   `path:"vlan-list" module:"openconfig-access-points"`
	Wpa2Psk            *string                                                                    `path:"wpa2-psk" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm represents the /openconfig-access-points/access-points/access-point/ssids/ssid/wmm YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config struct {
	TrustDscp   *bool   `path:"trust-dscp" module:"openconfig-access-points"`
	WmmBeRemark []uint8 `path:"wmm-be-remark" module:"openconfig-access-points"`
	WmmBkRemark []uint8 `path:"wmm-bk-remark" module:"openconfig-access-points"`
	WmmViRemark []uint8 `path:"wmm-vi-remark" module:"openconfig-access-points"`
	WmmVoRemark []uint8 `path:"wmm-vo-remark" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config represents the /openconfig-access-points/access-points/access-point/ssids/ssid/wmm/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State struct {
	TrustDscp   *bool   `path:"trust-dscp" module:"openconfig-access-points"`
	WmmBeRemark []uint8 `path:"wmm-be-remark" module:"openconfig-access-points"`
	WmmBkRemark []uint8 `path:"wmm-bk-remark" module:"openconfig-access-points"`
	WmmViRemark []uint8 `path:"wmm-vi-remark" module:"openconfig-access-points"`
	WmmVoRemark []uint8 `path:"wmm-vo-remark" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State represents the /openconfig-access-points/access-points/access-point/ssids/ssid/wmm/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Wmm_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System struct {
	Aaa          *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa          `path:"aaa" module:"openconfig-access-points"`
	Alarms       *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms       `path:"alarms" module:"openconfig-access-points"`
	Clock        *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock        `path:"clock" module:"openconfig-access-points"`
	Config       *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config       `path:"config" module:"openconfig-access-points"`
	Cpus         *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus         `path:"cpus" module:"openconfig-access-points"`
	Dns          *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns          `path:"dns" module:"openconfig-access-points"`
	GrpcServer   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer   `path:"grpc-server" module:"openconfig-access-points"`
	Logging      *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging      `path:"logging" module:"openconfig-access-points"`
	Memory       *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory       `path:"memory" module:"openconfig-access-points"`
	Ntp          *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp          `path:"ntp" module:"openconfig-access-points"`
	Processes    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes    `path:"processes" module:"openconfig-access-points"`
	SshServer    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer    `path:"ssh-server" module:"openconfig-access-points"`
	State        *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State        `path:"state" module:"openconfig-access-points"`
	TelnetServer *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer `path:"telnet-server" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System represents the /openconfig-access-points/access-points/access-point/system YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa struct {
	Accounting     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting     `path:"accounting" module:"openconfig-access-points"`
	Authentication *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication `path:"authentication" module:"openconfig-access-points"`
	Authorization  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization  `path:"authorization" module:"openconfig-access-points"`
	Config         *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config         `path:"config" module:"openconfig-access-points"`
	ServerGroups   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups   `path:"server-groups" module:"openconfig-access-points"`
	State          *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State          `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa represents the /openconfig-access-points/access-points/access-point/system/aaa YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config `path:"config" module:"openconfig-access-points"`
	Events *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events `path:"events" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config struct {
	AccountingMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union `path:"accounting-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/accounting/config/accounting-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/accounting/config/accounting-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/accounting/config/accounting-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Config_AccountingMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events struct {
	Event map[E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event `path:"event" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/events YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) NewEvent 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) NewEvent(EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event, error)

NewEvent creates a new entry in the Event list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event struct {
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config `path:"config" module:"openconfig-access-points"`
	EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE                                             `path:"event-type" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/events/event YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config struct {
	EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE                                                     `path:"event-type" module:"openconfig-access-points"`
	Record    E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record `path:"record" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/events/event/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State struct {
	EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE                                                     `path:"event-type" module:"openconfig-access-points"`
	Record    E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_Config_Record `path:"record" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/events/event/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_Events_Event_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State struct {
	AccountingMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union `path:"accounting-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State represents the /openconfig-access-points/access-points/access-point/system/aaa/accounting/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/accounting/state/accounting-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/accounting/state/accounting-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/accounting/state/accounting-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Accounting_State_AccountingMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication struct {
	AdminUser *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser `path:"admin-user" module:"openconfig-access-points"`
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config    `path:"config" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State     `path:"state" module:"openconfig-access-points"`
	Users     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users     `path:"users" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/admin-user YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config struct {
	AdminPassword       *string `path:"admin-password" module:"openconfig-access-points"`
	AdminPasswordHashed *string `path:"admin-password-hashed" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/admin-user/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State struct {
	AdminPassword       *string `path:"admin-password" module:"openconfig-access-points"`
	AdminPasswordHashed *string `path:"admin-password-hashed" module:"openconfig-access-points"`
	AdminUsername       *string `path:"admin-username" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/admin-user/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_AdminUser_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config struct {
	AuthenticationMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union `path:"authentication-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authentication/config/authentication-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/config/authentication-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/config/authentication-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Config_AuthenticationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State struct {
	AuthenticationMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union `path:"authentication-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authentication/state/authentication-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/state/authentication-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/state/authentication-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_State_AuthenticationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users struct {
	User map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User `path:"user" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/users YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) NewUser 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) NewUser(Username string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User, error)

NewUser creates a new entry in the User list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User struct {
	Config   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config `path:"config" module:"openconfig-access-points"`
	State    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State  `path:"state" module:"openconfig-access-points"`
	Username *string                                                                                      `path:"username" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config struct {
	Password       *string                                                                                                `path:"password" module:"openconfig-access-points"`
	PasswordHashed *string                                                                                                `path:"password-hashed" module:"openconfig-access-points"`
	Role           OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union `path:"role" module:"openconfig-access-points"`
	SshKey         *string                                                                                                `path:"ssh-key" module:"openconfig-access-points"`
	Username       *string                                                                                                `path:"username" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/config/role within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES struct {
	E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/config/role is to be set to a E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/config/role is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_Config_Role_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State struct {
	Password       *string                                                                                               `path:"password" module:"openconfig-access-points"`
	PasswordHashed *string                                                                                               `path:"password-hashed" module:"openconfig-access-points"`
	Role           OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union `path:"role" module:"openconfig-access-points"`
	SshKey         *string                                                                                               `path:"ssh-key" module:"openconfig-access-points"`
	Username       *string                                                                                               `path:"username" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State represents the /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/state/role within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES struct {
	E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/state/role is to be set to a E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authentication/users/user/state/role is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authentication_Users_User_State_Role_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config `path:"config" module:"openconfig-access-points"`
	Events *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events `path:"events" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config struct {
	AuthorizationMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union `path:"authorization-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authorization/config/authorization-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/authorization/config/authorization-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authorization/config/authorization-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Config_AuthorizationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events struct {
	Event map[E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event `path:"event" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/events YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) NewEvent 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) NewEvent(EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event, error)

NewEvent creates a new entry in the Event list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event struct {
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config `path:"config" module:"openconfig-access-points"`
	EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE                                             `path:"event-type" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/events/event YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config struct {
	EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE `path:"event-type" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/events/event/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State struct {
	EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE `path:"event-type" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/events/event/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_Events_Event_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State struct {
	AuthorizationMethod []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union `path:"authorization-method" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State represents the /openconfig-access-points/access-points/access-point/system/aaa/authorization/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/aaa/authorization/state/authorization-method within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-access-points/access-points/access-point/system/aaa/authorization/state/authorization-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String is used when /openconfig-access-points/access-points/access-point/system/aaa/authorization/state/authorization-method is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Authorization_State_AuthorizationMethod_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups struct {
	ServerGroup map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup `path:"server-group" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) NewServerGroup 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) NewServerGroup(Name string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup, error)

NewServerGroup creates a new entry in the ServerGroup list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup struct {
	Config  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config  `path:"config" module:"openconfig-access-points"`
	Name    *string                                                                                      `path:"name" module:"openconfig-access-points"`
	Servers *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers `path:"servers" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State   `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config struct {
	Name *string                              `path:"name" module:"openconfig-access-points"`
	Type E_OpenconfigAaaTypes_AAA_SERVER_TYPE `path:"type" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers struct {
	Server map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server `path:"server" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) NewServer 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) NewServer(Address string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server, error)

NewServer creates a new entry in the Server list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server struct {
	Address *string                                                                                                    `path:"address" module:"openconfig-access-points"`
	Config  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config `path:"config" module:"openconfig-access-points"`
	Radius  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius `path:"radius" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State  `path:"state" module:"openconfig-access-points"`
	Tacacs  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs `path:"tacacs" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config struct {
	Address *string `path:"address" module:"openconfig-access-points"`
	Name    *string `path:"name" module:"openconfig-access-points"`
	Timeout *uint16 `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/radius YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config struct {
	AcctPort           *uint16 `path:"acct-port" module:"openconfig-access-points"`
	AuthPort           *uint16 `path:"auth-port" module:"openconfig-access-points"`
	RetransmitAttempts *uint8  `path:"retransmit-attempts" module:"openconfig-access-points"`
	SecretKey          *string `path:"secret-key" module:"openconfig-access-points"`
	SourceAddress      *string `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/radius/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State struct {
	AcctPort           *uint16                                                                                                                   `path:"acct-port" module:"openconfig-access-points"`
	AuthPort           *uint16                                                                                                                   `path:"auth-port" module:"openconfig-access-points"`
	Counters           *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters `path:"counters" module:"openconfig-access-points"`
	RetransmitAttempts *uint8                                                                                                                    `path:"retransmit-attempts" module:"openconfig-access-points"`
	SecretKey          *string                                                                                                                   `path:"secret-key" module:"openconfig-access-points"`
	SourceAddress      *string                                                                                                                   `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/radius/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters struct {
	AccessAccepts         *uint64 `path:"access-accepts" module:"openconfig-access-points"`
	AccessRejects         *uint64 `path:"access-rejects" module:"openconfig-access-points"`
	RetriedAccessRequests *uint64 `path:"retried-access-requests" module:"openconfig-access-points"`
	TimeoutAccessRequests *uint64 `path:"timeout-access-requests" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/radius/state/counters YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Radius_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State struct {
	Address            *string `path:"address" module:"openconfig-access-points"`
	ConnectionAborts   *uint64 `path:"connection-aborts" module:"openconfig-access-points"`
	ConnectionCloses   *uint64 `path:"connection-closes" module:"openconfig-access-points"`
	ConnectionFailures *uint64 `path:"connection-failures" module:"openconfig-access-points"`
	ConnectionOpens    *uint64 `path:"connection-opens" module:"openconfig-access-points"`
	ConnectionTimeouts *uint64 `path:"connection-timeouts" module:"openconfig-access-points"`
	ErrorsReceived     *uint64 `path:"errors-received" module:"openconfig-access-points"`
	MessagesReceived   *uint64 `path:"messages-received" module:"openconfig-access-points"`
	MessagesSent       *uint64 `path:"messages-sent" module:"openconfig-access-points"`
	Name               *string `path:"name" module:"openconfig-access-points"`
	Timeout            *uint16 `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/tacacs YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config struct {
	Port          *uint16 `path:"port" module:"openconfig-access-points"`
	SecretKey     *string `path:"secret-key" module:"openconfig-access-points"`
	SourceAddress *string `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/tacacs/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State struct {
	Port          *uint16 `path:"port" module:"openconfig-access-points"`
	SecretKey     *string `path:"secret-key" module:"openconfig-access-points"`
	SourceAddress *string `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/servers/server/tacacs/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_Servers_Server_Tacacs_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State struct {
	Name *string                              `path:"name" module:"openconfig-access-points"`
	Type E_OpenconfigAaaTypes_AAA_SERVER_TYPE `path:"type" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State represents the /openconfig-access-points/access-points/access-point/system/aaa/server-groups/server-group/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_ServerGroups_ServerGroup_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State represents the /openconfig-access-points/access-points/access-point/system/aaa/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Aaa_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms struct {
	Alarm map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm `path:"alarm" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms represents the /openconfig-access-points/access-points/access-point/system/alarms YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) NewAlarm 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) NewAlarm(Id string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm, error)

NewAlarm creates a new entry in the Alarm list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config `path:"config" module:"openconfig-access-points"`
	Id     *string                                                                     `path:"id" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm represents the /openconfig-access-points/access-points/access-point/system/alarms/alarm YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config represents the /openconfig-access-points/access-points/access-point/system/alarms/alarm/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State struct {
	Id          *string                                                                                `path:"id" module:"openconfig-access-points"`
	Resource    *string                                                                                `path:"resource" module:"openconfig-access-points"`
	Severity    E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY                                       `path:"severity" module:"openconfig-access-points"`
	Text        *string                                                                                `path:"text" module:"openconfig-access-points"`
	TimeCreated *uint64                                                                                `path:"time-created" module:"openconfig-access-points"`
	TypeId      OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union `path:"type-id" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State represents the /openconfig-access-points/access-points/access-point/system/alarms/alarm/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/alarms/alarm/state/type-id within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID struct {
	E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID is used when /openconfig-access-points/access-points/access-point/system/alarms/alarm/state/type-id is to be set to a E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String is used when /openconfig-access-points/access-points/access-point/system/alarms/alarm/state/type-id is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Alarms_Alarm_State_TypeId_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock represents the /openconfig-access-points/access-points/access-point/system/clock YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config struct {
	TimezoneName *string `path:"timezone-name" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config represents the /openconfig-access-points/access-points/access-point/system/clock/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State struct {
	TimezoneName *string `path:"timezone-name" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State represents the /openconfig-access-points/access-points/access-point/system/clock/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Clock_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config struct {
	DomainName  *string `path:"domain-name" module:"openconfig-access-points"`
	Hostname    *string `path:"hostname" module:"openconfig-access-points"`
	LoginBanner *string `path:"login-banner" module:"openconfig-access-points"`
	MotdBanner  *string `path:"motd-banner" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config represents the /openconfig-access-points/access-points/access-point/system/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus struct {
	Cpu map[OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu `path:"cpu" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus represents the /openconfig-access-points/access-points/access-point/system/cpus YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) NewCpu 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) NewCpu(Index OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu, error)

NewCpu creates a new entry in the Cpu list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu struct {
	Index OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union `path:"index" module:"openconfig-access-points"`
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State            `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State struct {
	HardwareInterrupt *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt `path:"hardware-interrupt" module:"openconfig-access-points"`
	Idle              *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle              `path:"idle" module:"openconfig-access-points"`
	Index             OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union        `path:"index" module:"openconfig-access-points"`
	Kernel            *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel            `path:"kernel" module:"openconfig-access-points"`
	Nice              *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice              `path:"nice" module:"openconfig-access-points"`
	SoftwareInterrupt *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt `path:"software-interrupt" module:"openconfig-access-points"`
	Total             *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total             `path:"total" module:"openconfig-access-points"`
	User              *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User              `path:"user" module:"openconfig-access-points"`
	Wait              *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait              `path:"wait" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/hardware-interrupt YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_HardwareInterrupt) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/idle YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Idle) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/cpus/cpu/index within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index struct {
	E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index is used when /openconfig-access-points/access-points/access-point/system/cpus/cpu/index is to be set to a E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32 struct {
	Uint32 uint32
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32 is used when /openconfig-access-points/access-points/access-point/system/cpus/cpu/index is to be set to a uint32 value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union_Uint32 implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Index_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/kernel YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Kernel) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/nice YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Nice) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/software-interrupt YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_SoftwareInterrupt) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/total YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Total) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/user YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_User) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait struct {
	Avg      *uint8  `path:"avg" module:"openconfig-access-points"`
	Instant  *uint8  `path:"instant" module:"openconfig-access-points"`
	Interval *uint64 `path:"interval" module:"openconfig-access-points"`
	Max      *uint8  `path:"max" module:"openconfig-access-points"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-access-points"`
	Min      *uint8  `path:"min" module:"openconfig-access-points"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait represents the /openconfig-access-points/access-points/access-point/system/cpus/cpu/state/wait YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Cpus_Cpu_State_Wait) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns struct {
	Config      *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config      `path:"config" module:"openconfig-access-points"`
	HostEntries *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries `path:"host-entries" module:"openconfig-access-points"`
	Servers     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers     `path:"servers" module:"openconfig-access-points"`
	State       *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State       `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns represents the /openconfig-access-points/access-points/access-point/system/dns YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config struct {
	Search []string `path:"search" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config represents the /openconfig-access-points/access-points/access-point/system/dns/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries struct {
	HostEntry map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry `path:"host-entry" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries represents the /openconfig-access-points/access-points/access-point/system/dns/host-entries YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) NewHostEntry 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) NewHostEntry(Hostname string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry, error)

NewHostEntry creates a new entry in the HostEntry list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry struct {
	Config   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config `path:"config" module:"openconfig-access-points"`
	Hostname *string                                                                                  `path:"hostname" module:"openconfig-access-points"`
	State    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry represents the /openconfig-access-points/access-points/access-point/system/dns/host-entries/host-entry YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config struct {
	Alias       []string `path:"alias" module:"openconfig-access-points"`
	Hostname    *string  `path:"hostname" module:"openconfig-access-points"`
	Ipv4Address []string `path:"ipv4-address" module:"openconfig-access-points"`
	Ipv6Address []string `path:"ipv6-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config represents the /openconfig-access-points/access-points/access-point/system/dns/host-entries/host-entry/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State struct {
	Alias       []string `path:"alias" module:"openconfig-access-points"`
	Hostname    *string  `path:"hostname" module:"openconfig-access-points"`
	Ipv4Address []string `path:"ipv4-address" module:"openconfig-access-points"`
	Ipv6Address []string `path:"ipv6-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State represents the /openconfig-access-points/access-points/access-point/system/dns/host-entries/host-entry/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_HostEntries_HostEntry_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers struct {
	Server map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server `path:"server" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers represents the /openconfig-access-points/access-points/access-point/system/dns/servers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) NewServer 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) NewServer(Address string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server, error)

NewServer creates a new entry in the Server list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server struct {
	Address *string                                                                           `path:"address" module:"openconfig-access-points"`
	Config  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config `path:"config" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server represents the /openconfig-access-points/access-points/access-point/system/dns/servers/server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config struct {
	Address *string `path:"address" module:"openconfig-access-points"`
	Port    *uint16 `path:"port" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config represents the /openconfig-access-points/access-points/access-point/system/dns/servers/server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State struct {
	Address *string `path:"address" module:"openconfig-access-points"`
	Port    *uint16 `path:"port" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State represents the /openconfig-access-points/access-points/access-point/system/dns/servers/server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_Servers_Server_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State struct {
	Search []string `path:"search" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State represents the /openconfig-access-points/access-points/access-point/system/dns/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Dns_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer represents the /openconfig-access-points/access-points/access-point/system/grpc-server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config struct {
	CertificateId     *string                                                                                          `path:"certificate-id" module:"openconfig-access-points"`
	Enable            *bool                                                                                            `path:"enable" module:"openconfig-access-points"`
	ListenAddresses   []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union `path:"listen-addresses" module:"openconfig-access-points"`
	Port              *uint16                                                                                          `path:"port" module:"openconfig-access-points"`
	TransportSecurity *bool                                                                                            `path:"transport-security" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config represents the /openconfig-access-points/access-points/access-point/system/grpc-server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/grpc-server/config/listen-addresses within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses struct {
	E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses is used when /openconfig-access-points/access-points/access-point/system/grpc-server/config/listen-addresses is to be set to a E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String is used when /openconfig-access-points/access-points/access-point/system/grpc-server/config/listen-addresses is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State struct {
	CertificateId     *string                                                                                         `path:"certificate-id" module:"openconfig-access-points"`
	Enable            *bool                                                                                           `path:"enable" module:"openconfig-access-points"`
	ListenAddresses   []OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union `path:"listen-addresses" module:"openconfig-access-points"`
	Port              *uint16                                                                                         `path:"port" module:"openconfig-access-points"`
	TransportSecurity *bool                                                                                           `path:"transport-security" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State represents the /openconfig-access-points/access-points/access-point/system/grpc-server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union(i interface{}) (OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union, error)

To_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union takes an input interface{} and attempts to convert it to a struct which implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union interface {
	Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union()
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-access-points/access-points/access-point/system/grpc-server/state/listen-addresses within the YANG schema.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses struct {
	E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses is used when /openconfig-access-points/access-points/access-point/system/grpc-server/state/listen-addresses is to be set to a E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_Config_ListenAddresses implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String struct {
	String string
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String is used when /openconfig-access-points/access-points/access-point/system/grpc-server/state/listen-addresses is to be set to a string value.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String) Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union()

Is_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union_String implements the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_GrpcServer_State_ListenAddresses_Union interface.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging struct {
	Console       *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console       `path:"console" module:"openconfig-access-points"`
	RemoteServers *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers `path:"remote-servers" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging represents the /openconfig-access-points/access-points/access-point/system/logging YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console struct {
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config    `path:"config" module:"openconfig-access-points"`
	Selectors *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors `path:"selectors" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State     `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console represents the /openconfig-access-points/access-points/access-point/system/logging/console YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config represents the /openconfig-access-points/access-points/access-point/system/logging/console/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors struct {
	Selector map[OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Key]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector `path:"selector" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors represents the /openconfig-access-points/access-points/access-point/system/logging/console/selectors YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) NewSelector 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) NewSelector(Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY, Severity E_OpenconfigSystemLogging_SyslogSeverity) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector, error)

NewSelector creates a new entry in the Selector list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector struct {
	Config   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config `path:"config" module:"openconfig-access-points"`
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY                                                         `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity                                                          `path:"severity" module:"openconfig-access-points"`
	State    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector represents the /openconfig-access-points/access-points/access-point/system/logging/console/selectors/selector YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config represents the /openconfig-access-points/access-points/access-point/system/logging/console/selectors/selector/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Key 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Key struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_Key represents the key for list Selector of element /openconfig-access-points/access-points/access-point/system/logging/console/selectors.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State represents the /openconfig-access-points/access-points/access-point/system/logging/console/selectors/selector/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_Selectors_Selector_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State represents the /openconfig-access-points/access-points/access-point/system/logging/console/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_Console_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers struct {
	RemoteServer map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer `path:"remote-server" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) NewRemoteServer 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) NewRemoteServer(Host string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer, error)

NewRemoteServer creates a new entry in the RemoteServer list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer struct {
	Config    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config    `path:"config" module:"openconfig-access-points"`
	Host      *string                                                                                              `path:"host" module:"openconfig-access-points"`
	Selectors *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors `path:"selectors" module:"openconfig-access-points"`
	State     *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State     `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config struct {
	Host          *string `path:"host" module:"openconfig-access-points"`
	RemotePort    *uint16 `path:"remote-port" module:"openconfig-access-points"`
	SourceAddress *string `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors struct {
	Selector map[OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Key]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector `path:"selector" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/selectors YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) NewSelector 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) NewSelector(Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY, Severity E_OpenconfigSystemLogging_SyslogSeverity) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector, error)

NewSelector creates a new entry in the Selector list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector struct {
	Config   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config `path:"config" module:"openconfig-access-points"`
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY                                                                            `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity                                                                             `path:"severity" module:"openconfig-access-points"`
	State    *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Key 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Key struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_Key represents the key for list Selector of element /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/selectors.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility" module:"openconfig-access-points"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/selectors/selector/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_Selectors_Selector_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State struct {
	Host          *string `path:"host" module:"openconfig-access-points"`
	RemotePort    *uint16 `path:"remote-port" module:"openconfig-access-points"`
	SourceAddress *string `path:"source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State represents the /openconfig-access-points/access-points/access-point/system/logging/remote-servers/remote-server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Logging_RemoteServers_RemoteServer_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory represents the /openconfig-access-points/access-points/access-point/system/memory YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config struct {
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config represents the /openconfig-access-points/access-points/access-point/system/memory/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State struct {
	Physical *uint64 `path:"physical" module:"openconfig-access-points"`
	Reserved *uint64 `path:"reserved" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State represents the /openconfig-access-points/access-points/access-point/system/memory/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Memory_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp struct {
	Config  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config  `path:"config" module:"openconfig-access-points"`
	NtpKeys *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys `path:"ntp-keys" module:"openconfig-access-points"`
	Servers *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers `path:"servers" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State   `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp represents the /openconfig-access-points/access-points/access-point/system/ntp YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config struct {
	EnableNtpAuth    *bool   `path:"enable-ntp-auth" module:"openconfig-access-points"`
	Enabled          *bool   `path:"enabled" module:"openconfig-access-points"`
	NtpSourceAddress *string `path:"ntp-source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config represents the /openconfig-access-points/access-points/access-point/system/ntp/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys struct {
	NtpKey map[uint16]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey `path:"ntp-key" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys represents the /openconfig-access-points/access-points/access-point/system/ntp/ntp-keys YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) NewNtpKey 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) NewNtpKey(KeyId uint16) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey, error)

NewNtpKey creates a new entry in the NtpKey list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config `path:"config" module:"openconfig-access-points"`
	KeyId  *uint16                                                                           `path:"key-id" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey represents the /openconfig-access-points/access-points/access-point/system/ntp/ntp-keys/ntp-key YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config struct {
	KeyId    *uint16                          `path:"key-id" module:"openconfig-access-points"`
	KeyType  E_OpenconfigSystem_NTP_AUTH_TYPE `path:"key-type" module:"openconfig-access-points"`
	KeyValue *string                          `path:"key-value" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config represents the /openconfig-access-points/access-points/access-point/system/ntp/ntp-keys/ntp-key/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State struct {
	KeyId    *uint16                          `path:"key-id" module:"openconfig-access-points"`
	KeyType  E_OpenconfigSystem_NTP_AUTH_TYPE `path:"key-type" module:"openconfig-access-points"`
	KeyValue *string                          `path:"key-value" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State represents the /openconfig-access-points/access-points/access-point/system/ntp/ntp-keys/ntp-key/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_NtpKeys_NtpKey_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers struct {
	Server map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server `path:"server" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers represents the /openconfig-access-points/access-points/access-point/system/ntp/servers YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) NewServer 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) NewServer(Address string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server, error)

NewServer creates a new entry in the Server list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server struct {
	Address *string                                                                           `path:"address" module:"openconfig-access-points"`
	Config  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config `path:"config" module:"openconfig-access-points"`
	State   *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server represents the /openconfig-access-points/access-points/access-point/system/ntp/servers/server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config struct {
	Address         *string                                                                                            `path:"address" module:"openconfig-access-points"`
	AssociationType E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType `path:"association-type" module:"openconfig-access-points"`
	Iburst          *bool                                                                                              `path:"iburst" module:"openconfig-access-points"`
	Port            *uint16                                                                                            `path:"port" module:"openconfig-access-points"`
	Prefer          *bool                                                                                              `path:"prefer" module:"openconfig-access-points"`
	Version         *uint8                                                                                             `path:"version" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config represents the /openconfig-access-points/access-points/access-point/system/ntp/servers/server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State struct {
	Address         *string                                                                                            `path:"address" module:"openconfig-access-points"`
	AssociationType E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_Config_AssociationType `path:"association-type" module:"openconfig-access-points"`
	Iburst          *bool                                                                                              `path:"iburst" module:"openconfig-access-points"`
	Offset          *uint64                                                                                            `path:"offset" module:"openconfig-access-points"`
	PollInterval    *uint32                                                                                            `path:"poll-interval" module:"openconfig-access-points"`
	Port            *uint16                                                                                            `path:"port" module:"openconfig-access-points"`
	Prefer          *bool                                                                                              `path:"prefer" module:"openconfig-access-points"`
	RootDelay       *uint32                                                                                            `path:"root-delay" module:"openconfig-access-points"`
	RootDispersion  *uint64                                                                                            `path:"root-dispersion" module:"openconfig-access-points"`
	Stratum         *uint8                                                                                             `path:"stratum" module:"openconfig-access-points"`
	Version         *uint8                                                                                             `path:"version" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State represents the /openconfig-access-points/access-points/access-point/system/ntp/servers/server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_Servers_Server_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State struct {
	AuthMismatch     *uint64 `path:"auth-mismatch" module:"openconfig-access-points"`
	EnableNtpAuth    *bool   `path:"enable-ntp-auth" module:"openconfig-access-points"`
	Enabled          *bool   `path:"enabled" module:"openconfig-access-points"`
	NtpSourceAddress *string `path:"ntp-source-address" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State represents the /openconfig-access-points/access-points/access-point/system/ntp/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Ntp_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes struct {
	Process map[uint64]*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process `path:"process" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes represents the /openconfig-access-points/access-points/access-point/system/processes YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) NewProcess 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) NewProcess(Pid uint64) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process, error)

NewProcess creates a new entry in the Process list of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes struct. The keys of the list are populated from the input arguments.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process struct {
	Pid   *uint64                                                                         `path:"pid" module:"openconfig-access-points"`
	State *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process represents the /openconfig-access-points/access-points/access-point/system/processes/process YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) ΛListKeyMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process struct, which is a YANG list entry.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State struct {
	Args              []string `path:"args" module:"openconfig-access-points"`
	CpuUsageSystem    *uint64  `path:"cpu-usage-system" module:"openconfig-access-points"`
	CpuUsageUser      *uint64  `path:"cpu-usage-user" module:"openconfig-access-points"`
	CpuUtilization    *uint8   `path:"cpu-utilization" module:"openconfig-access-points"`
	MemoryUsage       *uint64  `path:"memory-usage" module:"openconfig-access-points"`
	MemoryUtilization *uint8   `path:"memory-utilization" module:"openconfig-access-points"`
	Name              *string  `path:"name" module:"openconfig-access-points"`
	Pid               *uint64  `path:"pid" module:"openconfig-access-points"`
	StartTime         *uint64  `path:"start-time" module:"openconfig-access-points"`
	Uptime            *uint64  `path:"uptime" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State represents the /openconfig-access-points/access-points/access-point/system/processes/process/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_Processes_Process_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer represents the /openconfig-access-points/access-points/access-point/system/ssh-server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config struct {
	Enable          *bool                                                                                     `path:"enable" module:"openconfig-access-points"`
	ProtocolVersion E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion `path:"protocol-version" module:"openconfig-access-points"`
	RateLimit       *uint16                                                                                   `path:"rate-limit" module:"openconfig-access-points"`
	SessionLimit    *uint16                                                                                   `path:"session-limit" module:"openconfig-access-points"`
	Timeout         *uint16                                                                                   `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config represents the /openconfig-access-points/access-points/access-point/system/ssh-server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State struct {
	Enable          *bool                                                                                     `path:"enable" module:"openconfig-access-points"`
	ProtocolVersion E_OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_Config_ProtocolVersion `path:"protocol-version" module:"openconfig-access-points"`
	RateLimit       *uint16                                                                                   `path:"rate-limit" module:"openconfig-access-points"`
	SessionLimit    *uint16                                                                                   `path:"session-limit" module:"openconfig-access-points"`
	Timeout         *uint16                                                                                   `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State represents the /openconfig-access-points/access-points/access-point/system/ssh-server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_SshServer_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State struct {
	BootTime        *uint64 `path:"boot-time" module:"openconfig-access-points"`
	CurrentDatetime *string `path:"current-datetime" module:"openconfig-access-points"`
	DomainName      *string `path:"domain-name" module:"openconfig-access-points"`
	Hostname        *string `path:"hostname" module:"openconfig-access-points"`
	LoginBanner     *string `path:"login-banner" module:"openconfig-access-points"`
	MotdBanner      *string `path:"motd-banner" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State represents the /openconfig-access-points/access-points/access-point/system/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer struct {
	Config *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config `path:"config" module:"openconfig-access-points"`
	State  *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State  `path:"state" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer represents the /openconfig-access-points/access-points/access-point/system/telnet-server YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config struct {
	Enable       *bool   `path:"enable" module:"openconfig-access-points"`
	RateLimit    *uint16 `path:"rate-limit" module:"openconfig-access-points"`
	SessionLimit *uint16 `path:"session-limit" module:"openconfig-access-points"`
	Timeout      *uint16 `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config represents the /openconfig-access-points/access-points/access-point/system/telnet-server/config YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_Config) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State 

type OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State struct {
	Enable       *bool   `path:"enable" module:"openconfig-access-points"`
	RateLimit    *uint16 `path:"rate-limit" module:"openconfig-access-points"`
	SessionLimit *uint16 `path:"session-limit" module:"openconfig-access-points"`
	Timeout      *uint16 `path:"timeout" module:"openconfig-access-points"`
}

OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State represents the /openconfig-access-points/access-points/access-point/system/telnet-server/state YANG schema element.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) IsYANGGoStruct 

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) Validate 

func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) ΛEnumTypeMap 

func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_System_TelnetServer_State) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OpenconfigGasket_Gasket 

type OpenconfigGasket_Gasket struct {
	CtrlInterface   *string `path:"ctrl-interface" module:"openconfig-gasket"`
	RadiusAttribute *string `path:"radius-attribute" module:"openconfig-gasket"`
}

OpenconfigGasket_Gasket represents the /openconfig-gasket/gasket YANG schema element.

func (*OpenconfigGasket_Gasket) IsYANGGoStruct 

func (*OpenconfigGasket_Gasket) IsYANGGoStruct()

IsYANGGoStruct ensures that OpenconfigGasket_Gasket implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OpenconfigGasket_Gasket) Validate 

func (s *OpenconfigGasket_Gasket) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OpenconfigGasket_Gasket) ΛEnumTypeMap 

func (t *OpenconfigGasket_Gasket) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type YANGEmpty 

type YANGEmpty bool

YANGEmpty is a type that is used for fields that have a YANG type of empty. It is used such that empty fields can be distinguished from boolean fields in the generated code.

Source Files

  • ocstruct.go

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.