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
}
Validate validates s against the YANG schema corresponding to its type.
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() {
}