exampleocpath.go

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/*
Package exampleocpath is a generated package which contains definitions
of structs which generate gNMI paths for a YANG schema.

This package was generated by ygnmi version: (devel): (ygot: v0.29.20)
using the following YANG input files:
  - ../pathgen/testdata/yang/openconfig-simple.yang
  - ../pathgen/testdata/yang/openconfig-withlistval.yang
  - ../pathgen/testdata/yang/openconfig-nested.yang

Imported modules were sourced from:
*/
package exampleocpath

import (
	"reflect"

	oc "github.com/openconfig/ygnmi/exampleoc"
	"github.com/openconfig/ygnmi/exampleoc/a"
	"github.com/openconfig/ygnmi/exampleoc/modelb"
	"github.com/openconfig/ygnmi/ygnmi"
	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/ygot/ytypes"
)

// APath represents the /openconfig-nested/a YANG schema element.
type APath struct {
	*ygnmi.NodePath
}

// APathAny represents the wildcard version of the /openconfig-nested/a YANG schema element.
type APathAny struct {
	*ygnmi.NodePath
}

// B (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "b"
//	Path from root:       "/a/b"
func (n *APath) B() *A_BPath {
	ps := &A_BPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"b"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// B (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "b"
//	Path from root:       "/a/b"
func (n *APathAny) B() *A_BPathAny {
	ps := &A_BPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"b"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

func binarySliceToFloatSlice(in []oc.Binary) []float32 {
	converted := make([]float32, 0, len(in))
	for _, binary := range in {
		converted = append(converted, ygot.BinaryToFloat32(binary))
	}
	return converted
}

// State returns a Query that can be used in gNMI operations.
func (n *APath) State() ygnmi.SingletonQuery[*oc.A] {
	return ygnmi.NewSingletonQuery[*oc.A](
		"A",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *APathAny) State() ygnmi.WildcardQuery[*oc.A] {
	return ygnmi.NewWildcardQuery[*oc.A](
		"A",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *APath) Config() ygnmi.ConfigQuery[*oc.A] {
	return ygnmi.NewConfigQuery[*oc.A](
		"A",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *APathAny) Config() ygnmi.WildcardQuery[*oc.A] {
	return ygnmi.NewWildcardQuery[*oc.A](
		"A",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_BPath represents the /openconfig-nested/a/b YANG schema element.
type A_BPath struct {
	*ygnmi.NodePath
}

// A_BPathAny represents the wildcard version of the /openconfig-nested/a/b YANG schema element.
type A_BPathAny struct {
	*ygnmi.NodePath
}

// C (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "c"
//	Path from root:       "/a/b/c"
func (n *A_BPath) C() *A_B_CPath {
	ps := &A_B_CPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"c"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// C (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "c"
//	Path from root:       "/a/b/c"
func (n *A_BPathAny) C() *A_B_CPathAny {
	ps := &A_B_CPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"c"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_BPath) State() ygnmi.SingletonQuery[*oc.A_B] {
	return ygnmi.NewSingletonQuery[*oc.A_B](
		"A_B",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_BPathAny) State() ygnmi.WildcardQuery[*oc.A_B] {
	return ygnmi.NewWildcardQuery[*oc.A_B](
		"A_B",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_BPath) Config() ygnmi.ConfigQuery[*oc.A_B] {
	return ygnmi.NewConfigQuery[*oc.A_B](
		"A_B",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_BPathAny) Config() ygnmi.WildcardQuery[*oc.A_B] {
	return ygnmi.NewWildcardQuery[*oc.A_B](
		"A_B",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_CPath represents the /openconfig-nested/a/b/c YANG schema element.
type A_B_CPath struct {
	*ygnmi.NodePath
}

// A_B_CPathAny represents the wildcard version of the /openconfig-nested/a/b/c YANG schema element.
type A_B_CPathAny struct {
	*ygnmi.NodePath
}

// D (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "d"
//	Path from root:       "/a/b/c/d"
func (n *A_B_CPath) D() *A_B_C_DPath {
	ps := &A_B_C_DPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"d"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// D (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "d"
//	Path from root:       "/a/b/c/d"
func (n *A_B_CPathAny) D() *A_B_C_DPathAny {
	ps := &A_B_C_DPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"d"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_CPath) State() ygnmi.SingletonQuery[*oc.A_B_C] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C](
		"A_B_C",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_CPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C](
		"A_B_C",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_CPath) Config() ygnmi.ConfigQuery[*oc.A_B_C] {
	return ygnmi.NewConfigQuery[*oc.A_B_C](
		"A_B_C",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_CPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C](
		"A_B_C",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_DPath represents the /openconfig-nested/a/b/c/d YANG schema element.
type A_B_C_DPath struct {
	*ygnmi.NodePath
}

// A_B_C_DPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d YANG schema element.
type A_B_C_DPathAny struct {
	*ygnmi.NodePath
}

// E (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "e"
//	Path from root:       "/a/b/c/d/e"
func (n *A_B_C_DPath) E() *A_B_C_D_EPath {
	ps := &A_B_C_D_EPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"e"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// E (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "e"
//	Path from root:       "/a/b/c/d/e"
func (n *A_B_C_DPathAny) E() *A_B_C_D_EPathAny {
	ps := &A_B_C_D_EPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"e"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_DPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D](
		"A_B_C_D",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_DPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D](
		"A_B_C_D",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_DPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D](
		"A_B_C_D",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_DPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D](
		"A_B_C_D",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_EPath represents the /openconfig-nested/a/b/c/d/e YANG schema element.
type A_B_C_D_EPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_EPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e YANG schema element.
type A_B_C_D_EPathAny struct {
	*ygnmi.NodePath
}

// F (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "f"
//	Path from root:       "/a/b/c/d/e/f"
func (n *A_B_C_D_EPath) F() *A_B_C_D_E_FPath {
	ps := &A_B_C_D_E_FPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"f"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// F (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "f"
//	Path from root:       "/a/b/c/d/e/f"
func (n *A_B_C_D_EPathAny) F() *A_B_C_D_E_FPathAny {
	ps := &A_B_C_D_E_FPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"f"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_EPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E](
		"A_B_C_D_E",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_EPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E](
		"A_B_C_D_E",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_EPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E](
		"A_B_C_D_E",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_EPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E](
		"A_B_C_D_E",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_FPath represents the /openconfig-nested/a/b/c/d/e/f YANG schema element.
type A_B_C_D_E_FPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_FPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f YANG schema element.
type A_B_C_D_E_FPathAny struct {
	*ygnmi.NodePath
}

// G (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "g"
//	Path from root:       "/a/b/c/d/e/f/g"
func (n *A_B_C_D_E_FPath) G() *A_B_C_D_E_F_GPath {
	ps := &A_B_C_D_E_F_GPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"g"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// G (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "g"
//	Path from root:       "/a/b/c/d/e/f/g"
func (n *A_B_C_D_E_FPathAny) G() *A_B_C_D_E_F_GPathAny {
	ps := &A_B_C_D_E_F_GPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"g"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_FPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F](
		"A_B_C_D_E_F",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_FPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F](
		"A_B_C_D_E_F",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_FPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F](
		"A_B_C_D_E_F",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_FPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F](
		"A_B_C_D_E_F",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_GPath represents the /openconfig-nested/a/b/c/d/e/f/g YANG schema element.
type A_B_C_D_E_F_GPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_GPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g YANG schema element.
type A_B_C_D_E_F_GPathAny struct {
	*ygnmi.NodePath
}

// H (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "h"
//	Path from root:       "/a/b/c/d/e/f/g/h"
func (n *A_B_C_D_E_F_GPath) H() *A_B_C_D_E_F_G_HPath {
	ps := &A_B_C_D_E_F_G_HPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"h"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// H (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "h"
//	Path from root:       "/a/b/c/d/e/f/g/h"
func (n *A_B_C_D_E_F_GPathAny) H() *A_B_C_D_E_F_G_HPathAny {
	ps := &A_B_C_D_E_F_G_HPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"h"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_GPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G](
		"A_B_C_D_E_F_G",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_GPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G](
		"A_B_C_D_E_F_G",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_GPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G](
		"A_B_C_D_E_F_G",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_GPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G](
		"A_B_C_D_E_F_G",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_HPath represents the /openconfig-nested/a/b/c/d/e/f/g/h YANG schema element.
type A_B_C_D_E_F_G_HPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_HPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h YANG schema element.
type A_B_C_D_E_F_G_HPathAny struct {
	*ygnmi.NodePath
}

// I (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "i"
//	Path from root:       "/a/b/c/d/e/f/g/h/i"
func (n *A_B_C_D_E_F_G_HPath) I() *A_B_C_D_E_F_G_H_IPath {
	ps := &A_B_C_D_E_F_G_H_IPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"i"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// I (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "i"
//	Path from root:       "/a/b/c/d/e/f/g/h/i"
func (n *A_B_C_D_E_F_G_HPathAny) I() *A_B_C_D_E_F_G_H_IPathAny {
	ps := &A_B_C_D_E_F_G_H_IPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"i"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_HPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H](
		"A_B_C_D_E_F_G_H",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_HPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H](
		"A_B_C_D_E_F_G_H",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_HPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H](
		"A_B_C_D_E_F_G_H",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_HPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H](
		"A_B_C_D_E_F_G_H",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_IPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i YANG schema element.
type A_B_C_D_E_F_G_H_IPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_H_IPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i YANG schema element.
type A_B_C_D_E_F_G_H_IPathAny struct {
	*ygnmi.NodePath
}

// J (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "j"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j"
func (n *A_B_C_D_E_F_G_H_IPath) J() *A_B_C_D_E_F_G_H_I_JPath {
	ps := &A_B_C_D_E_F_G_H_I_JPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"j"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// J (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "j"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j"
func (n *A_B_C_D_E_F_G_H_IPathAny) J() *A_B_C_D_E_F_G_H_I_JPathAny {
	ps := &A_B_C_D_E_F_G_H_I_JPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"j"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_IPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H_I] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H_I](
		"A_B_C_D_E_F_G_H_I",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_IPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I](
		"A_B_C_D_E_F_G_H_I",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_IPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H_I] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H_I](
		"A_B_C_D_E_F_G_H_I",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_IPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I](
		"A_B_C_D_E_F_G_H_I",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_I_JPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j YANG schema element.
type A_B_C_D_E_F_G_H_I_JPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_H_I_JPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i/j YANG schema element.
type A_B_C_D_E_F_G_H_I_JPathAny struct {
	*ygnmi.NodePath
}

// K (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "k"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k"
func (n *A_B_C_D_E_F_G_H_I_JPath) K() *A_B_C_D_E_F_G_H_I_J_KPath {
	ps := &A_B_C_D_E_F_G_H_I_J_KPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"k"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// K (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "k"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k"
func (n *A_B_C_D_E_F_G_H_I_JPathAny) K() *A_B_C_D_E_F_G_H_I_J_KPathAny {
	ps := &A_B_C_D_E_F_G_H_I_J_KPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"k"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_JPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J](
		"A_B_C_D_E_F_G_H_I_J",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_JPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J](
		"A_B_C_D_E_F_G_H_I_J",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_JPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J](
		"A_B_C_D_E_F_G_H_I_J",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_JPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J](
		"A_B_C_D_E_F_G_H_I_J",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_I_J_KPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k YANG schema element.
type A_B_C_D_E_F_G_H_I_J_KPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_H_I_J_KPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k YANG schema element.
type A_B_C_D_E_F_G_H_I_J_KPathAny struct {
	*ygnmi.NodePath
}

// L (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "l"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l"
func (n *A_B_C_D_E_F_G_H_I_J_KPath) L() *A_B_C_D_E_F_G_H_I_J_K_LPath {
	ps := &A_B_C_D_E_F_G_H_I_J_K_LPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"l"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// L (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "l"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l"
func (n *A_B_C_D_E_F_G_H_I_J_KPathAny) L() *A_B_C_D_E_F_G_H_I_J_K_LPathAny {
	ps := &A_B_C_D_E_F_G_H_I_J_K_LPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"l"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_KPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K](
		"A_B_C_D_E_F_G_H_I_J_K",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_KPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K](
		"A_B_C_D_E_F_G_H_I_J_K",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_KPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K](
		"A_B_C_D_E_F_G_H_I_J_K",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_KPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K](
		"A_B_C_D_E_F_G_H_I_J_K",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_I_J_K_LPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_LPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_H_I_J_K_LPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_LPathAny struct {
	*ygnmi.NodePath
}

// M (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "m"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m"
func (n *A_B_C_D_E_F_G_H_I_J_K_LPath) M() *A_B_C_D_E_F_G_H_I_J_K_L_MPath {
	ps := &A_B_C_D_E_F_G_H_I_J_K_L_MPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"m"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// M (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "m"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m"
func (n *A_B_C_D_E_F_G_H_I_J_K_LPathAny) M() *A_B_C_D_E_F_G_H_I_J_K_L_MPathAny {
	ps := &A_B_C_D_E_F_G_H_I_J_K_L_MPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"m"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_LPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L](
		"A_B_C_D_E_F_G_H_I_J_K_L",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_LPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L](
		"A_B_C_D_E_F_G_H_I_J_K_L",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_LPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L](
		"A_B_C_D_E_F_G_H_I_J_K_L",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_LPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L](
		"A_B_C_D_E_F_G_H_I_J_K_L",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_I_J_K_L_M_FooPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L_M_FooPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// A_B_C_D_E_F_G_H_I_J_K_L_M_FooPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L_M_FooPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "state/foo"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo"
func (n *A_B_C_D_E_F_G_H_I_J_K_L_M_FooPath) State() ygnmi.SingletonQuery[string] {
	return ygnmi.NewSingletonQuery[string](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "foo"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.A_B_C_D_E_F_G_H_I_J_K_L_M).Foo
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.A_B_C_D_E_F_G_H_I_J_K_L_M) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "state/foo"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo"
func (n *A_B_C_D_E_F_G_H_I_J_K_L_M_FooPathAny) State() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "foo"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.A_B_C_D_E_F_G_H_I_J_K_L_M).Foo
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.A_B_C_D_E_F_G_H_I_J_K_L_M) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// A_B_C_D_E_F_G_H_I_J_K_L_MPath represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l/m YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L_MPath struct {
	*ygnmi.NodePath
}

// A_B_C_D_E_F_G_H_I_J_K_L_MPathAny represents the wildcard version of the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l/m YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L_MPathAny struct {
	*ygnmi.NodePath
}

// Foo (leaf):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "state/foo"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo"
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPath) Foo() *A_B_C_D_E_F_G_H_I_J_K_L_M_FooPath {
	ps := &A_B_C_D_E_F_G_H_I_J_K_L_M_FooPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "foo"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Foo (leaf):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "state/foo"
//	Path from root:       "/a/b/c/d/e/f/g/h/i/j/k/l/m/state/foo"
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPathAny) Foo() *A_B_C_D_E_F_G_H_I_J_K_L_M_FooPathAny {
	ps := &A_B_C_D_E_F_G_H_I_J_K_L_M_FooPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "foo"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPath) State() ygnmi.SingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M] {
	return ygnmi.NewSingletonQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPathAny) State() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPath) Config() ygnmi.ConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M] {
	return ygnmi.NewConfigQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *A_B_C_D_E_F_G_H_I_J_K_L_MPathAny) Config() ygnmi.WildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M] {
	return ygnmi.NewWildcardQuery[*oc.A_B_C_D_E_F_G_H_I_J_K_L_M](
		"A_B_C_D_E_F_G_H_I_J_K_L_M",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// ContainerPath represents the /openconfig-nested/container YANG schema element.
type ContainerPath struct {
	*ygnmi.NodePath
}

// ContainerPathAny represents the wildcard version of the /openconfig-nested/container YANG schema element.
type ContainerPathAny struct {
	*ygnmi.NodePath
}

// State returns a Query that can be used in gNMI operations.
func (n *ContainerPath) State() ygnmi.SingletonQuery[*oc.Container] {
	return ygnmi.NewSingletonQuery[*oc.Container](
		"Container",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *ContainerPathAny) State() ygnmi.WildcardQuery[*oc.Container] {
	return ygnmi.NewWildcardQuery[*oc.Container](
		"Container",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ContainerPath) Config() ygnmi.ConfigQuery[*oc.Container] {
	return ygnmi.NewConfigQuery[*oc.Container](
		"Container",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ContainerPathAny) Config() ygnmi.WildcardQuery[*oc.Container] {
	return ygnmi.NewWildcardQuery[*oc.Container](
		"Container",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// ModelPath represents the /openconfig-withlistval/model YANG schema element.
type ModelPath struct {
	*ygnmi.NodePath
}

// ModelPathAny represents the wildcard version of the /openconfig-withlistval/model YANG schema element.
type ModelPathAny struct {
	*ygnmi.NodePath
}

// MultiKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
func (n *ModelPath) MultiKeyAny() *modelb.Model_MultiKeyPathAny {
	ps := &modelb.Model_MultiKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"b", "multi-key"},
			map[string]interface{}{"key1": "*", "key2": "*"},
			n,
		),
	}
	return ps
}

// MultiKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
func (n *ModelPathAny) MultiKeyAny() *modelb.Model_MultiKeyPathAny {
	ps := &modelb.Model_MultiKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"b", "multi-key"},
			map[string]interface{}{"key1": "*", "key2": "*"},
			n,
		),
	}
	return ps
}

// MultiKey (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
//
//	Key1: uint32
//	Key2: uint64
func (n *ModelPath) MultiKey(Key1 uint32, Key2 uint64) *modelb.Model_MultiKeyPath {
	ps := &modelb.Model_MultiKeyPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"b", "multi-key"},
			map[string]interface{}{"key1": Key1, "key2": Key2},
			n,
		),
	}
	return ps
}

// MultiKey (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
//
//	Key1: uint32
//	Key2: uint64
func (n *ModelPathAny) MultiKey(Key1 uint32, Key2 uint64) *modelb.Model_MultiKeyPathAny {
	ps := &modelb.Model_MultiKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"b", "multi-key"},
			map[string]interface{}{"key1": Key1, "key2": Key2},
			n,
		),
	}
	return ps
}

// MultiKeyMap (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
func (n *ModelPath) MultiKeyMap() *modelb.Model_MultiKeyPathMap {
	ps := &modelb.Model_MultiKeyPathMap{
		NodePath: ygnmi.NewNodePath(
			[]string{"b"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// MultiKeyMap (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "b/multi-key"
//	Path from root:       "/model/b/multi-key"
func (n *ModelPathAny) MultiKeyMap() *modelb.Model_MultiKeyPathMapAny {
	ps := &modelb.Model_MultiKeyPathMapAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"b"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// NoKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "c/no-key"
//	Path from root:       "/model/c/no-key"
func (n *ModelPath) NoKeyAny() *Model_NoKeyPathAny {
	ps := &Model_NoKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"c", "no-key"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// NoKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "c/no-key"
//	Path from root:       "/model/c/no-key"
func (n *ModelPathAny) NoKeyAny() *Model_NoKeyPathAny {
	ps := &Model_NoKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"c", "no-key"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// SingleKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
func (n *ModelPath) SingleKeyAny() *a.Model_SingleKeyPathAny {
	ps := &a.Model_SingleKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"a", "single-key"},
			map[string]interface{}{"key": "*"},
			n,
		),
	}
	return ps
}

// SingleKeyAny (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
func (n *ModelPathAny) SingleKeyAny() *a.Model_SingleKeyPathAny {
	ps := &a.Model_SingleKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"a", "single-key"},
			map[string]interface{}{"key": "*"},
			n,
		),
	}
	return ps
}

// SingleKey (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
//
//	Key: string
func (n *ModelPath) SingleKey(Key string) *a.Model_SingleKeyPath {
	ps := &a.Model_SingleKeyPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"a", "single-key"},
			map[string]interface{}{"key": Key},
			n,
		),
	}
	return ps
}

// SingleKey (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
//
//	Key: string
func (n *ModelPathAny) SingleKey(Key string) *a.Model_SingleKeyPathAny {
	ps := &a.Model_SingleKeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"a", "single-key"},
			map[string]interface{}{"key": Key},
			n,
		),
	}
	return ps
}

// SingleKeyMap (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
func (n *ModelPath) SingleKeyMap() *a.Model_SingleKeyPathMap {
	ps := &a.Model_SingleKeyPathMap{
		NodePath: ygnmi.NewNodePath(
			[]string{"a"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// SingleKeyMap (list):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "a/single-key"
//	Path from root:       "/model/a/single-key"
func (n *ModelPathAny) SingleKeyMap() *a.Model_SingleKeyPathMapAny {
	ps := &a.Model_SingleKeyPathMapAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"a"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *ModelPath) State() ygnmi.SingletonQuery[*oc.Model] {
	return ygnmi.NewSingletonQuery[*oc.Model](
		"Model",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *ModelPathAny) State() ygnmi.WildcardQuery[*oc.Model] {
	return ygnmi.NewWildcardQuery[*oc.Model](
		"Model",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ModelPath) Config() ygnmi.ConfigQuery[*oc.Model] {
	return ygnmi.NewConfigQuery[*oc.Model](
		"Model",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ModelPathAny) Config() ygnmi.WildcardQuery[*oc.Model] {
	return ygnmi.NewWildcardQuery[*oc.Model](
		"Model",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Model_NoKeyPath represents the /openconfig-withlistval/model/c/no-key YANG schema element.
type Model_NoKeyPath struct {
	*ygnmi.NodePath
}

// Model_NoKeyPathAny represents the wildcard version of the /openconfig-withlistval/model/c/no-key YANG schema element.
type Model_NoKeyPathAny struct {
	*ygnmi.NodePath
}

// State returns a Query that can be used in gNMI operations.
func (n *Model_NoKeyPath) State() ygnmi.SingletonQuery[*oc.Model_NoKey] {
	return ygnmi.NewSingletonQuery[*oc.Model_NoKey](
		"Model_NoKey",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *Model_NoKeyPathAny) State() ygnmi.WildcardQuery[*oc.Model_NoKey] {
	return ygnmi.NewWildcardQuery[*oc.Model_NoKey](
		"Model_NoKey",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Model_NoKey_Foo_KeyPath represents the /openconfig-withlistval/model/c/no-key/foo/state/key YANG schema element.
type Model_NoKey_Foo_KeyPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Model_NoKey_Foo_KeyPathAny represents the wildcard version of the /openconfig-withlistval/model/c/no-key/foo/state/key YANG schema element.
type Model_NoKey_Foo_KeyPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/key"
//	Path from root:       "/model/c/no-key/foo/state/key"
func (n *Model_NoKey_Foo_KeyPath) State() ygnmi.SingletonQuery[string] {
	return ygnmi.NewSingletonQuery[string](
		"Model_NoKey_Foo",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "key"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Model_NoKey_Foo).Key
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Model_NoKey_Foo) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/key"
//	Path from root:       "/model/c/no-key/foo/state/key"
func (n *Model_NoKey_Foo_KeyPathAny) State() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"Model_NoKey_Foo",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "key"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Model_NoKey_Foo).Key
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Model_NoKey_Foo) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Model_NoKey_Foo_ValuePath represents the /openconfig-withlistval/model/c/no-key/foo/state/value YANG schema element.
type Model_NoKey_Foo_ValuePath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Model_NoKey_Foo_ValuePathAny represents the wildcard version of the /openconfig-withlistval/model/c/no-key/foo/state/value YANG schema element.
type Model_NoKey_Foo_ValuePathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/value"
//	Path from root:       "/model/c/no-key/foo/state/value"
func (n *Model_NoKey_Foo_ValuePath) State() ygnmi.SingletonQuery[int64] {
	return ygnmi.NewSingletonQuery[int64](
		"Model_NoKey_Foo",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "value"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (int64, bool) {
			ret := gs.(*oc.Model_NoKey_Foo).Value
			if ret == nil {
				var zero int64
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Model_NoKey_Foo) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/value"
//	Path from root:       "/model/c/no-key/foo/state/value"
func (n *Model_NoKey_Foo_ValuePathAny) State() ygnmi.WildcardQuery[int64] {
	return ygnmi.NewWildcardQuery[int64](
		"Model_NoKey_Foo",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "value"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (int64, bool) {
			ret := gs.(*oc.Model_NoKey_Foo).Value
			if ret == nil {
				var zero int64
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Model_NoKey_Foo) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Model_NoKey_FooPath represents the /openconfig-withlistval/model/c/no-key/foo YANG schema element.
type Model_NoKey_FooPath struct {
	*ygnmi.NodePath
}

// Model_NoKey_FooPathAny represents the wildcard version of the /openconfig-withlistval/model/c/no-key/foo YANG schema element.
type Model_NoKey_FooPathAny struct {
	*ygnmi.NodePath
}

// Key (leaf):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/key"
//	Path from root:       "/model/c/no-key/foo/state/key"
func (n *Model_NoKey_FooPath) Key() *Model_NoKey_Foo_KeyPath {
	ps := &Model_NoKey_Foo_KeyPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "key"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Key (leaf):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/key"
//	Path from root:       "/model/c/no-key/foo/state/key"
func (n *Model_NoKey_FooPathAny) Key() *Model_NoKey_Foo_KeyPathAny {
	ps := &Model_NoKey_Foo_KeyPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "key"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Value (leaf):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/value"
//	Path from root:       "/model/c/no-key/foo/state/value"
func (n *Model_NoKey_FooPath) Value() *Model_NoKey_Foo_ValuePath {
	ps := &Model_NoKey_Foo_ValuePath{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "value"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Value (leaf):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "state/value"
//	Path from root:       "/model/c/no-key/foo/state/value"
func (n *Model_NoKey_FooPathAny) Value() *Model_NoKey_Foo_ValuePathAny {
	ps := &Model_NoKey_Foo_ValuePathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "value"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *Model_NoKey_FooPath) State() ygnmi.SingletonQuery[*oc.Model_NoKey_Foo] {
	return ygnmi.NewSingletonQuery[*oc.Model_NoKey_Foo](
		"Model_NoKey_Foo",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *Model_NoKey_FooPathAny) State() ygnmi.WildcardQuery[*oc.Model_NoKey_Foo] {
	return ygnmi.NewWildcardQuery[*oc.Model_NoKey_Foo](
		"Model_NoKey_Foo",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// ParentPath represents the /openconfig-simple/parent YANG schema element.
type ParentPath struct {
	*ygnmi.NodePath
}

// ParentPathAny represents the wildcard version of the /openconfig-simple/parent YANG schema element.
type ParentPathAny struct {
	*ygnmi.NodePath
}

// Child (container):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "child"
//	Path from root:       "/parent/child"
func (n *ParentPath) Child() *Parent_ChildPath {
	ps := &Parent_ChildPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"child"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// Child (container):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "child"
//	Path from root:       "/parent/child"
func (n *ParentPathAny) Child() *Parent_ChildPathAny {
	ps := &Parent_ChildPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"child"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *ParentPath) State() ygnmi.SingletonQuery[*oc.Parent] {
	return ygnmi.NewSingletonQuery[*oc.Parent](
		"Parent",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *ParentPathAny) State() ygnmi.WildcardQuery[*oc.Parent] {
	return ygnmi.NewWildcardQuery[*oc.Parent](
		"Parent",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ParentPath) Config() ygnmi.ConfigQuery[*oc.Parent] {
	return ygnmi.NewConfigQuery[*oc.Parent](
		"Parent",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *ParentPathAny) Config() ygnmi.WildcardQuery[*oc.Parent] {
	return ygnmi.NewWildcardQuery[*oc.Parent](
		"Parent",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_FivePath represents the /openconfig-simple/parent/child/state/five YANG schema element.
type Parent_Child_FivePath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_FivePathAny represents the wildcard version of the /openconfig-simple/parent/child/state/five YANG schema element.
type Parent_Child_FivePathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/five"
//	Path from root:       "/parent/child/state/five"
func (n *Parent_Child_FivePath) State() ygnmi.SingletonQuery[float32] {
	return ygnmi.NewSingletonQuery[float32](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "five"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (float32, bool) {
			ret := gs.(*oc.Parent_Child).Five
			return ygot.BinaryToFloat32(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/five"
//	Path from root:       "/parent/child/state/five"
func (n *Parent_Child_FivePathAny) State() ygnmi.WildcardQuery[float32] {
	return ygnmi.NewWildcardQuery[float32](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "five"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (float32, bool) {
			ret := gs.(*oc.Parent_Child).Five
			return ygot.BinaryToFloat32(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/five"
//	Path from root:       "/parent/child/config/five"
func (n *Parent_Child_FivePath) Config() ygnmi.ConfigQuery[float32] {
	return ygnmi.NewConfigQuery[float32](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "five"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (float32, bool) {
			ret := gs.(*oc.Parent_Child).Five
			return ygot.BinaryToFloat32(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/five"
//	Path from root:       "/parent/child/config/five"
func (n *Parent_Child_FivePathAny) Config() ygnmi.WildcardQuery[float32] {
	return ygnmi.NewWildcardQuery[float32](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "five"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (float32, bool) {
			ret := gs.(*oc.Parent_Child).Five
			return ygot.BinaryToFloat32(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_FourPath represents the /openconfig-simple/parent/child/state/four YANG schema element.
type Parent_Child_FourPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_FourPathAny represents the wildcard version of the /openconfig-simple/parent/child/state/four YANG schema element.
type Parent_Child_FourPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/four"
//	Path from root:       "/parent/child/state/four"
func (n *Parent_Child_FourPath) State() ygnmi.SingletonQuery[oc.Binary] {
	return ygnmi.NewSingletonQuery[oc.Binary](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "four"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.Binary, bool) {
			ret := gs.(*oc.Parent_Child).Four
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/four"
//	Path from root:       "/parent/child/state/four"
func (n *Parent_Child_FourPathAny) State() ygnmi.WildcardQuery[oc.Binary] {
	return ygnmi.NewWildcardQuery[oc.Binary](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "four"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.Binary, bool) {
			ret := gs.(*oc.Parent_Child).Four
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/four"
//	Path from root:       "/parent/child/config/four"
func (n *Parent_Child_FourPath) Config() ygnmi.ConfigQuery[oc.Binary] {
	return ygnmi.NewConfigQuery[oc.Binary](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "four"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.Binary, bool) {
			ret := gs.(*oc.Parent_Child).Four
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/four"
//	Path from root:       "/parent/child/config/four"
func (n *Parent_Child_FourPathAny) Config() ygnmi.WildcardQuery[oc.Binary] {
	return ygnmi.NewWildcardQuery[oc.Binary](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "four"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.Binary, bool) {
			ret := gs.(*oc.Parent_Child).Four
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_OnePath represents the /openconfig-simple/parent/child/state/one YANG schema element.
type Parent_Child_OnePath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_OnePathAny represents the wildcard version of the /openconfig-simple/parent/child/state/one YANG schema element.
type Parent_Child_OnePathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/one"
//	Path from root:       "/parent/child/state/one"
func (n *Parent_Child_OnePath) State() ygnmi.SingletonQuery[string] {
	return ygnmi.NewSingletonQuery[string](
		"Parent_Child",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "one"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).One
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/one"
//	Path from root:       "/parent/child/state/one"
func (n *Parent_Child_OnePathAny) State() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"Parent_Child",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "one"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).One
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/one"
//	Path from root:       "/parent/child/config/one"
func (n *Parent_Child_OnePath) Config() ygnmi.ConfigQuery[string] {
	return ygnmi.NewConfigQuery[string](
		"Parent_Child",
		false,
		true,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "one"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).One
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/one"
//	Path from root:       "/parent/child/config/one"
func (n *Parent_Child_OnePathAny) Config() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"Parent_Child",
		false,
		true,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "one"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).One
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_SixPath represents the /openconfig-simple/parent/child/state/six YANG schema element.
type Parent_Child_SixPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_SixPathAny represents the wildcard version of the /openconfig-simple/parent/child/state/six YANG schema element.
type Parent_Child_SixPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/six"
//	Path from root:       "/parent/child/state/six"
func (n *Parent_Child_SixPath) State() ygnmi.SingletonQuery[[]float32] {
	return ygnmi.NewSingletonQuery[[]float32](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "six"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) ([]float32, bool) {
			ret := gs.(*oc.Parent_Child).Six
			return binarySliceToFloatSlice(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/six"
//	Path from root:       "/parent/child/state/six"
func (n *Parent_Child_SixPathAny) State() ygnmi.WildcardQuery[[]float32] {
	return ygnmi.NewWildcardQuery[[]float32](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "six"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) ([]float32, bool) {
			ret := gs.(*oc.Parent_Child).Six
			return binarySliceToFloatSlice(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/six"
//	Path from root:       "/parent/child/config/six"
func (n *Parent_Child_SixPath) Config() ygnmi.ConfigQuery[[]float32] {
	return ygnmi.NewConfigQuery[[]float32](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "six"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) ([]float32, bool) {
			ret := gs.(*oc.Parent_Child).Six
			return binarySliceToFloatSlice(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/six"
//	Path from root:       "/parent/child/config/six"
func (n *Parent_Child_SixPathAny) Config() ygnmi.WildcardQuery[[]float32] {
	return ygnmi.NewWildcardQuery[[]float32](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "six"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) ([]float32, bool) {
			ret := gs.(*oc.Parent_Child).Six
			return binarySliceToFloatSlice(ret), !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_ThreePath represents the /openconfig-simple/parent/child/state/three YANG schema element.
type Parent_Child_ThreePath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_ThreePathAny represents the wildcard version of the /openconfig-simple/parent/child/state/three YANG schema element.
type Parent_Child_ThreePathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/three"
//	Path from root:       "/parent/child/state/three"
func (n *Parent_Child_ThreePath) State() ygnmi.SingletonQuery[oc.E_Child_Three] {
	return ygnmi.NewSingletonQuery[oc.E_Child_Three](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "three"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.E_Child_Three, bool) {
			ret := gs.(*oc.Parent_Child).Three
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/three"
//	Path from root:       "/parent/child/state/three"
func (n *Parent_Child_ThreePathAny) State() ygnmi.WildcardQuery[oc.E_Child_Three] {
	return ygnmi.NewWildcardQuery[oc.E_Child_Three](
		"Parent_Child",
		true,
		false,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "three"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.E_Child_Three, bool) {
			ret := gs.(*oc.Parent_Child).Three
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/three"
//	Path from root:       "/parent/child/config/three"
func (n *Parent_Child_ThreePath) Config() ygnmi.ConfigQuery[oc.E_Child_Three] {
	return ygnmi.NewConfigQuery[oc.E_Child_Three](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "three"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.E_Child_Three, bool) {
			ret := gs.(*oc.Parent_Child).Three
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/three"
//	Path from root:       "/parent/child/config/three"
func (n *Parent_Child_ThreePathAny) Config() ygnmi.WildcardQuery[oc.E_Child_Three] {
	return ygnmi.NewWildcardQuery[oc.E_Child_Three](
		"Parent_Child",
		false,
		true,
		true,
		false,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "three"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (oc.E_Child_Three, bool) {
			ret := gs.(*oc.Parent_Child).Three
			return ret, !reflect.ValueOf(ret).IsZero()
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_Child_TwoPath represents the /openconfig-simple/parent/child/state/two YANG schema element.
type Parent_Child_TwoPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// Parent_Child_TwoPathAny represents the wildcard version of the /openconfig-simple/parent/child/state/two YANG schema element.
type Parent_Child_TwoPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/two"
//	Path from root:       "/parent/child/state/two"
func (n *Parent_Child_TwoPath) State() ygnmi.SingletonQuery[string] {
	return ygnmi.NewSingletonQuery[string](
		"Parent_Child",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "two"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).Two
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/two"
//	Path from root:       "/parent/child/state/two"
func (n *Parent_Child_TwoPathAny) State() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"Parent_Child",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "two"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.Parent_Child).Two
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.Parent_Child) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Parent_ChildPath represents the /openconfig-simple/parent/child YANG schema element.
type Parent_ChildPath struct {
	*ygnmi.NodePath
}

// Parent_ChildPathAny represents the wildcard version of the /openconfig-simple/parent/child YANG schema element.
type Parent_ChildPathAny struct {
	*ygnmi.NodePath
}

// Five (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/five"
//	Path from root:       "/parent/child/*/five"
func (n *Parent_ChildPath) Five() *Parent_Child_FivePath {
	ps := &Parent_Child_FivePath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "five"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Five (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/five"
//	Path from root:       "/parent/child/*/five"
func (n *Parent_ChildPathAny) Five() *Parent_Child_FivePathAny {
	ps := &Parent_Child_FivePathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "five"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Four (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/four"
//	Path from root:       "/parent/child/*/four"
func (n *Parent_ChildPath) Four() *Parent_Child_FourPath {
	ps := &Parent_Child_FourPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "four"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Four (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/four"
//	Path from root:       "/parent/child/*/four"
func (n *Parent_ChildPathAny) Four() *Parent_Child_FourPathAny {
	ps := &Parent_Child_FourPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "four"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// One (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/one"
//	Path from root:       "/parent/child/*/one"
func (n *Parent_ChildPath) One() *Parent_Child_OnePath {
	ps := &Parent_Child_OnePath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "one"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// One (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/one"
//	Path from root:       "/parent/child/*/one"
func (n *Parent_ChildPathAny) One() *Parent_Child_OnePathAny {
	ps := &Parent_Child_OnePathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "one"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Six (leaf-list):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/six"
//	Path from root:       "/parent/child/*/six"
func (n *Parent_ChildPath) Six() *Parent_Child_SixPath {
	ps := &Parent_Child_SixPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "six"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Six (leaf-list):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/six"
//	Path from root:       "/parent/child/*/six"
func (n *Parent_ChildPathAny) Six() *Parent_Child_SixPathAny {
	ps := &Parent_Child_SixPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "six"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Three (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/three"
//	Path from root:       "/parent/child/*/three"
func (n *Parent_ChildPath) Three() *Parent_Child_ThreePath {
	ps := &Parent_Child_ThreePath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "three"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Three (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/three"
//	Path from root:       "/parent/child/*/three"
func (n *Parent_ChildPathAny) Three() *Parent_Child_ThreePathAny {
	ps := &Parent_Child_ThreePathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "three"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Two (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/two"
//	Path from root:       "/parent/child/state/two"
func (n *Parent_ChildPath) Two() *Parent_Child_TwoPath {
	ps := &Parent_Child_TwoPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "two"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// Two (leaf):
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/two"
//	Path from root:       "/parent/child/state/two"
func (n *Parent_ChildPathAny) Two() *Parent_Child_TwoPathAny {
	ps := &Parent_Child_TwoPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"state", "two"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *Parent_ChildPath) State() ygnmi.SingletonQuery[*oc.Parent_Child] {
	return ygnmi.NewSingletonQuery[*oc.Parent_Child](
		"Parent_Child",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *Parent_ChildPathAny) State() ygnmi.WildcardQuery[*oc.Parent_Child] {
	return ygnmi.NewWildcardQuery[*oc.Parent_Child](
		"Parent_Child",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *Parent_ChildPath) Config() ygnmi.ConfigQuery[*oc.Parent_Child] {
	return ygnmi.NewConfigQuery[*oc.Parent_Child](
		"Parent_Child",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *Parent_ChildPathAny) Config() ygnmi.WildcardQuery[*oc.Parent_Child] {
	return ygnmi.NewWildcardQuery[*oc.Parent_Child](
		"Parent_Child",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// RemoteContainer_ALeafPath represents the /openconfig-simple/remote-container/state/a-leaf YANG schema element.
type RemoteContainer_ALeafPath struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// RemoteContainer_ALeafPathAny represents the wildcard version of the /openconfig-simple/remote-container/state/a-leaf YANG schema element.
type RemoteContainer_ALeafPathAny struct {
	*ygnmi.NodePath
	parent ygnmi.PathStruct
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/a-leaf"
//	Path from root:       "/remote-container/state/a-leaf"
func (n *RemoteContainer_ALeafPath) State() ygnmi.SingletonQuery[string] {
	return ygnmi.NewSingletonQuery[string](
		"RemoteContainer",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "a-leaf"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.RemoteContainer).ALeaf
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.RemoteContainer) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "state/a-leaf"
//	Path from root:       "/remote-container/state/a-leaf"
func (n *RemoteContainer_ALeafPathAny) State() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"RemoteContainer",
		true,
		false,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"state", "a-leaf"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.RemoteContainer).ALeaf
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.RemoteContainer) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/a-leaf"
//	Path from root:       "/remote-container/config/a-leaf"
func (n *RemoteContainer_ALeafPath) Config() ygnmi.ConfigQuery[string] {
	return ygnmi.NewConfigQuery[string](
		"RemoteContainer",
		false,
		true,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "a-leaf"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.RemoteContainer).ALeaf
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.RemoteContainer) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "config/a-leaf"
//	Path from root:       "/remote-container/config/a-leaf"
func (n *RemoteContainer_ALeafPathAny) Config() ygnmi.WildcardQuery[string] {
	return ygnmi.NewWildcardQuery[string](
		"RemoteContainer",
		false,
		true,
		true,
		true,
		true,
		false,
		ygnmi.NewNodePath(
			[]string{"config", "a-leaf"},
			nil,
			n.parent,
		),
		func(gs ygot.ValidatedGoStruct) (string, bool) {
			ret := gs.(*oc.RemoteContainer).ALeaf
			if ret == nil {
				var zero string
				return zero, false
			}
			return *ret, true
		},
		func() ygot.ValidatedGoStruct { return new(oc.RemoteContainer) },
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// RemoteContainerPath represents the /openconfig-simple/remote-container YANG schema element.
type RemoteContainerPath struct {
	*ygnmi.NodePath
}

// RemoteContainerPathAny represents the wildcard version of the /openconfig-simple/remote-container YANG schema element.
type RemoteContainerPathAny struct {
	*ygnmi.NodePath
}

// ALeaf (leaf):
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/a-leaf"
//	Path from root:       "/remote-container/*/a-leaf"
func (n *RemoteContainerPath) ALeaf() *RemoteContainer_ALeafPath {
	ps := &RemoteContainer_ALeafPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "a-leaf"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// ALeaf (leaf):
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "*/a-leaf"
//	Path from root:       "/remote-container/*/a-leaf"
func (n *RemoteContainerPathAny) ALeaf() *RemoteContainer_ALeafPathAny {
	ps := &RemoteContainer_ALeafPathAny{
		NodePath: ygnmi.NewNodePath(
			[]string{"*", "a-leaf"},
			map[string]interface{}{},
			n,
		),
		parent: n,
	}
	return ps
}

// State returns a Query that can be used in gNMI operations.
func (n *RemoteContainerPath) State() ygnmi.SingletonQuery[*oc.RemoteContainer] {
	return ygnmi.NewSingletonQuery[*oc.RemoteContainer](
		"RemoteContainer",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *RemoteContainerPathAny) State() ygnmi.WildcardQuery[*oc.RemoteContainer] {
	return ygnmi.NewWildcardQuery[*oc.RemoteContainer](
		"RemoteContainer",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *RemoteContainerPath) Config() ygnmi.ConfigQuery[*oc.RemoteContainer] {
	return ygnmi.NewConfigQuery[*oc.RemoteContainer](
		"RemoteContainer",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *RemoteContainerPathAny) Config() ygnmi.WildcardQuery[*oc.RemoteContainer] {
	return ygnmi.NewWildcardQuery[*oc.RemoteContainer](
		"RemoteContainer",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// RootPath represents the /root YANG schema element.
type RootPath struct {
	*ygnmi.DeviceRootBase
}

// Root returns a root path object from which YANG paths can be constructed.
func Root() *RootPath {
	return &RootPath{ygnmi.NewDeviceRootBase()}
}

// A (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "a"
//	Path from root:       "/a"
func (n *RootPath) A() *APath {
	ps := &APath{
		NodePath: ygnmi.NewNodePath(
			[]string{"a"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// Container (container):
//
//	Defining module:      "openconfig-nested"
//	Instantiating module: "openconfig-nested"
//	Path from parent:     "container"
//	Path from root:       "/container"
func (n *RootPath) Container() *ContainerPath {
	ps := &ContainerPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"container"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// Model (container):
//
//	Defining module:      "openconfig-withlistval"
//	Instantiating module: "openconfig-withlistval"
//	Path from parent:     "model"
//	Path from root:       "/model"
func (n *RootPath) Model() *ModelPath {
	ps := &ModelPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"model"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// Parent (container): I am a parent container
// that has 4 children.
//
//	Defining module:      "openconfig-simple"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "parent"
//	Path from root:       "/parent"
func (n *RootPath) Parent() *ParentPath {
	ps := &ParentPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"parent"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// RemoteContainer (container):
//
//	Defining module:      "openconfig-remote"
//	Instantiating module: "openconfig-simple"
//	Path from parent:     "remote-container"
//	Path from root:       "/remote-container"
func (n *RootPath) RemoteContainer() *RemoteContainerPath {
	ps := &RemoteContainerPath{
		NodePath: ygnmi.NewNodePath(
			[]string{"remote-container"},
			map[string]interface{}{},
			n,
		),
	}
	return ps
}

// Batch contains a collection of paths.
// Use batch to call Lookup, Watch, etc. on multiple paths at once.
type Batch struct {
	paths []ygnmi.PathStruct
}

// AddPaths adds the paths to the batch.
func (b *Batch) AddPaths(paths ...ygnmi.PathStruct) *Batch {
	b.paths = append(b.paths, paths...)
	return b
}

// State returns a Query that can be used in gNMI operations.
// The returned query is immutable, adding paths does not modify existing queries.
func (b *Batch) State() ygnmi.SingletonQuery[*oc.Root] {
	queryPaths := make([]ygnmi.PathStruct, len(b.paths))
	copy(queryPaths, b.paths)
	return ygnmi.NewSingletonQuery[*oc.Root](
		"Root",
		true,
		false,
		false,
		false,
		true,
		false,
		ygnmi.NewDeviceRootBase(),
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		queryPaths,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
// The returned query is immutable, adding paths does not modify existing queries.
func (b *Batch) Config() ygnmi.SingletonQuery[*oc.Root] {
	queryPaths := make([]ygnmi.PathStruct, len(b.paths))
	copy(queryPaths, b.paths)
	return ygnmi.NewSingletonQuery[*oc.Root](
		"Root",
		false,
		true,
		false,
		false,
		true,
		false,
		ygnmi.NewDeviceRootBase(),
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		queryPaths,
		nil,
	)
}

// State returns a Query that can be used in gNMI operations.
func (n *RootPath) State() ygnmi.SingletonQuery[*oc.Root] {
	return ygnmi.NewSingletonQuery[*oc.Root](
		"Root",
		true,
		false,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}

// Config returns a Query that can be used in gNMI operations.
func (n *RootPath) Config() ygnmi.ConfigQuery[*oc.Root] {
	return ygnmi.NewConfigQuery[*oc.Root](
		"Root",
		false,
		true,
		false,
		false,
		true,
		false,
		n,
		nil,
		nil,
		func() *ytypes.Schema {
			return &ytypes.Schema{
				Root:       &oc.Root{},
				SchemaTree: oc.SchemaTree,
				Unmarshal:  oc.Unmarshal,
			}
		},
		nil,
		nil,
	)
}