func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) NewBssid(RadioId uint8, Bssid string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid, error) {
	if t.Bssid == nil {
		t.Bssid = make(map[OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid)
	}
	key := OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key{
		RadioId: RadioId,
		Bssid:   Bssid,
	}
	if _, ok := t.Bssid[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Bssid", key)
	}
	t.Bssid[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid{
		RadioId: &RadioId,
		Bssid:   &Bssid,
	}
	return t.Bssid[key], nil
}
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.
package ocstruct
import (
	"encoding/json"
	"fmt"
	"reflect"
	"github.com/openconfig/goyang/pkg/yang"
	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/ygot/ytypes"
)
type Binary []byte
type YANGEmpty bool
var (
	SchemaTree map[string]*yang.Entry
)
func init() {
	var err error
	if SchemaTree, err = ygot.GzipToSchema(ySchema); err != nil {
		panic("schema error: " + err.Error())
	}
}
func Unmarshal(data []byte, destStruct ygot.GoStruct, opts ...ytypes.UnmarshalOpt) error {
	tn := reflect.TypeOf(destStruct).Elem().Name()
	schema, ok := SchemaTree[tn]
	if !ok {
		return fmt.Errorf("could not find schema for type %s", tn)
	}
	var jsonTree interface{}
	if err := json.Unmarshal([]byte(data), &jsonTree); err != nil {
		return err
	}
	return ytypes.Unmarshal(schema, destStruct, jsonTree, opts...)
}
type Device struct {
	AccessPoints *OpenconfigAccessPoints_AccessPoints `path:"access-points" module:"openconfig-access-points"`
	Gasket       *OpenconfigGasket_Gasket             `path:"gasket" module:"openconfig-gasket"`
}
func (*Device) IsYANGGoStruct() {}
func (s *Device) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Device"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *Device) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }
type OpenconfigAccessPoints_AccessPoints struct {
	AccessPoint map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint `path:"access-point" module:"openconfig-access-points"`
}
func (*OpenconfigAccessPoints_AccessPoints) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints) NewAccessPoint(Hostname string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint, error) {
	if t.AccessPoint == nil {
		t.AccessPoint = make(map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint)
	}
	key := Hostname
	if _, ok := t.AccessPoint[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list AccessPoint", key)
	}
	t.AccessPoint[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint{
		Hostname: &Hostname,
	}
	return t.AccessPoint[key], nil
}
func (s *OpenconfigAccessPoints_AccessPoints) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Hostname == nil {
		return nil, fmt.Errorf("nil value for key Hostname")
	}
	return map[string]interface{}{
		"hostname": *t.Hostname,
	}, nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
type OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers struct {
	ApManager map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager `path:"ap-manager" module:"openconfig-access-points"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) NewApManager(Id string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager, error) {
	if t.ApManager == nil {
		t.ApManager = make(map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager)
	}
	key := Id
	if _, ok := t.ApManager[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list ApManager", key)
	}
	t.ApManager[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager{
		Id: &Id,
	}
	return t.ApManager[key], nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) IsYANGGoStruct() {
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Id == nil {
		return nil, fmt.Errorf("nil value for key Id")
	}
	return map[string]interface{}{
		"id": *t.Id,
	}, nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) IsYANGGoStruct() {
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) IsYANGGoStruct() {
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_AssignedApManagers_ApManager_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios struct {
	Radio map[uint8]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio `path:"radio" module:"openconfig-access-points"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) NewRadio(Id uint8) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio, error) {
	if t.Radio == nil {
		t.Radio = make(map[uint8]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio)
	}
	key := Id
	if _, ok := t.Radio[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Radio", key)
	}
	t.Radio[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio{
		Id: &Id,
	}
	return t.Radio[key], nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Id == nil {
		return nil, fmt.Errorf("nil value for key Id")
	}
	return map[string]interface{}{
		"id": *t.Id,
	}, nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) IsYANGGoStruct() {}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
type OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors struct {
	Neighbor map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor `path:"neighbor" module:"openconfig-access-points"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) NewNeighbor(Bssid string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor, error) {
	if t.Neighbor == nil {
		t.Neighbor = make(map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor)
	}
	key := Bssid
	if _, ok := t.Neighbor[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Neighbor", key)
	}
	t.Neighbor[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor{
		Bssid: &Bssid,
	}
	return t.Neighbor[key], nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) IsYANGGoStruct() {
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Bssid == nil {
		return nil, fmt.Errorf("nil value for key Bssid")
	}
	return map[string]interface{}{
		"bssid": *t.Bssid,
	}, nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) IsYANGGoStruct() {
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_Neighbors_Neighbor_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) IsYANGGoStruct() {}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) IsYANGGoStruct() {}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Radios_Radio_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids struct {
	Ssid map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid `path:"ssid" module:"openconfig-access-points"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) NewSsid(Name string) (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid, error) {
	if t.Ssid == nil {
		t.Ssid = make(map[string]*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid)
	}
	key := Name
	if _, ok := t.Ssid[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Ssid", key)
	}
	t.Ssid[key] = &OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid{
		Name: &Name,
	}
	return t.Ssid[key], nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) IsYANGGoStruct() {}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Name == nil {
		return nil, fmt.Errorf("nil value for key Name")
	}
	return map[string]interface{}{
		"name": *t.Name,
	}, nil
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) IsYANGGoStruct() {}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) IsYANGGoStruct() {
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) IsYANGGoStruct() {
}
func (s *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State"], s, opts...); err != nil {
		return err
	}
	return nil
}
func (t *OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_BandSteering_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}
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"`
}
func (*OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids) IsYANGGoStruct() {}
type OpenconfigAccessPoints_AccessPoints_AccessPoint_Ssids_Ssid_Bssids_Bssid_Key struct {
	RadioId uint8  `path:"radio-id"`
	Bssid   string `path:"bssid"`
}