// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// GENERATED FILE: Do not edit!
//
// To rebuild this file, invoke third_party/go/regen-fidl.

// +build fuchsia

package io

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiamem "syscall/zx/mem"
)

const (
	OpenRightReadable                 uint32 = 0x00000001
	OpenRightWritable                 uint32 = 0x00000002
	OpenRightAdmin                    uint32 = 0x00000004
	OpenFlagCreate                    uint32 = 0x00010000
	OpenFlagCreateIfAbsent            uint32 = 0x00020000
	OpenFlagTruncate                  uint32 = 0x00040000
	OpenFlagDirectory                 uint32 = 0x00080000
	OpenFlagAppend                    uint32 = 0x00100000
	OpenFlagNoRemote                  uint32 = 0x00200000
	OpenFlagNodeReference             uint32 = 0x00400000
	OpenFlagDescribe                  uint32 = 0x00800000
	ModeProtectionMask                uint32 = 0x00FFF
	ModeTypeMask                      uint32 = 0xFF000
	ModeTypeDirectory                 uint32 = 0x04000
	ModeTypeBlockDevice               uint32 = 0x06000
	ModeTypeFile                      uint32 = 0x08000
	ModeTypeSocket                    uint32 = 0x0C000
	ModeTypeService                   uint32 = 0x10000
	MaxIoctlHandles                   uint64 = 2
	MaxBuf                            uint64 = 8192
	MaxPath                           uint64 = 4096
	MaxFilename                       uint64 = 255
	NodeAttributeFlagCreationTime     uint32 = 0x00000001
	NodeAttributeFlagModificationTime uint32 = 0x00000002
	VmoFlagRead                       uint32 = 0x00000001
	VmoFlagWrite                      uint32 = 0x00000002
	VmoFlagExec                       uint32 = 0x00000004
	VmoFlagPrivate                    uint32 = 0x00010000
	VmoFlagExact                      uint32 = 0x00020000
	DirentTypeUnknown                 uint8  = 0
	DirentTypeDirectory               uint8  = 4
	DirentTypeBlockDevice             uint8  = 6
	DirentTypeFile                    uint8  = 8
	DirentTypeSocket                  uint8  = 12
	DirentTypeService                 uint8  = 16
	InoUnknown                        uint64 = 0xFFFFFFFFFFFFFFFF
	WatchEventDeleted                 uint8  = 0
	WatchEventAdded                   uint8  = 1
	WatchEventRemoved                 uint8  = 2
	WatchEventExisting                uint8  = 3
	WatchEventIdle                    uint8  = 4
	WatchMaskDeleted                  uint32 = 0x00000001
	WatchMaskAdded                    uint32 = 0x00000002
	WatchMaskRemoved                  uint32 = 0x00000004
	WatchMaskExisting                 uint32 = 0x00000008
	WatchMaskIdle                     uint32 = 0x00000010
	WatchMaskAll                      uint32 = 0x0000001F
	MountCreateFlagReplace            uint32 = 0x00000001
	MaxFsNameBuffer                   uint64 = 32
)

type SeekOrigin uint32

const (
	SeekOriginStart   SeekOrigin = 0
	SeekOriginCurrent SeekOrigin = 1
	SeekOriginEnd     SeekOrigin = 2
)

func (x SeekOrigin) String() string {
	switch x {
	case 0:
		return "Start"
	case 1:
		return "Current"
	case 2:
		return "End"
	}
	return "Unknown"
}

type Service struct {
	_        struct{} `fidl2:"s,1,1"`
	Reserved uint8
}

var _mService = _bindings.CreateLazyMarshaler(Service{})

func (msg *Service) Marshaler() _bindings.Marshaler {
	return _mService
}

// Implements Payload.
func (_ *Service) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *Service) InlineSize() int {
	return 1
}

type FileObject struct {
	_     struct{}  `fidl2:"s,4,4"`
	Event _zx.Event `fidl:"*" fidl2:"1"`
}

var _mFileObject = _bindings.CreateLazyMarshaler(FileObject{})

func (msg *FileObject) Marshaler() _bindings.Marshaler {
	return _mFileObject
}

// Implements Payload.
func (_ *FileObject) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *FileObject) InlineSize() int {
	return 4
}

type DirectoryObject struct {
	_        struct{} `fidl2:"s,1,1"`
	Reserved uint8
}

var _mDirectoryObject = _bindings.CreateLazyMarshaler(DirectoryObject{})

func (msg *DirectoryObject) Marshaler() _bindings.Marshaler {
	return _mDirectoryObject
}

// Implements Payload.
func (_ *DirectoryObject) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *DirectoryObject) InlineSize() int {
	return 1
}

type Pipe struct {
	_      struct{}   `fidl2:"s,4,4"`
	Socket _zx.Socket `fidl2:"0"`
}

var _mPipe = _bindings.CreateLazyMarshaler(Pipe{})

func (msg *Pipe) Marshaler() _bindings.Marshaler {
	return _mPipe
}

// Implements Payload.
func (_ *Pipe) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *Pipe) InlineSize() int {
	return 4
}

type Vmofile struct {
	_      struct{} `fidl2:"s,24,8"`
	Vmo    _zx.VMO  `fidl2:"0"`
	Offset uint64
	Length uint64
}

var _mVmofile = _bindings.CreateLazyMarshaler(Vmofile{})

func (msg *Vmofile) Marshaler() _bindings.Marshaler {
	return _mVmofile
}

// Implements Payload.
func (_ *Vmofile) InlineAlignment() int {
	return 8
}

// Implements Payload.
func (_ *Vmofile) InlineSize() int {
	return 24
}

type Device struct {
	_     struct{}  `fidl2:"s,4,4"`
	Event _zx.Event `fidl:"*" fidl2:"1"`
}

var _mDevice = _bindings.CreateLazyMarshaler(Device{})

func (msg *Device) Marshaler() _bindings.Marshaler {
	return _mDevice
}

// Implements Payload.
func (_ *Device) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *Device) InlineSize() int {
	return 4
}

type NodeAttributes struct {
	_                struct{} `fidl2:"s,56,8"`
	Mode             uint32
	Id               uint64
	ContentSize      uint64
	StorageSize      uint64
	LinkCount        uint64
	CreationTime     uint64
	ModificationTime uint64
}

var _mNodeAttributes = _bindings.CreateLazyMarshaler(NodeAttributes{})

func (msg *NodeAttributes) Marshaler() _bindings.Marshaler {
	return _mNodeAttributes
}

// Implements Payload.
func (_ *NodeAttributes) InlineAlignment() int {
	return 8
}

// Implements Payload.
func (_ *NodeAttributes) InlineSize() int {
	return 56
}

type WatchedEvent struct {
	_     struct{} `fidl2:"s,24,8"`
	Event uint8
	Len   uint8
	Name  []uint8 `fidl:"255" fidl2:"255"`
}

var _mWatchedEvent = _bindings.CreateLazyMarshaler(WatchedEvent{})

func (msg *WatchedEvent) Marshaler() _bindings.Marshaler {
	return _mWatchedEvent
}

// Implements Payload.
func (_ *WatchedEvent) InlineAlignment() int {
	return 8
}

// Implements Payload.
func (_ *WatchedEvent) InlineSize() int {
	return 24
}

type FilesystemInfo struct {
	_                   struct{} `fidl2:"s,96,8"`
	TotalBytes          uint64
	UsedBytes           uint64
	TotalNodes          uint64
	UsedNodes           uint64
	FreeSharedPoolBytes uint64
	FsId                uint64
	BlockSize           uint32
	MaxFilenameSize     uint32
	FsType              uint32
	Padding             uint32
	Name                [32]int8
}

var _mFilesystemInfo = _bindings.CreateLazyMarshaler(FilesystemInfo{})

func (msg *FilesystemInfo) Marshaler() _bindings.Marshaler {
	return _mFilesystemInfo
}

// Implements Payload.
func (_ *FilesystemInfo) InlineAlignment() int {
	return 8
}

// Implements Payload.
func (_ *FilesystemInfo) InlineSize() int {
	return 96
}

type NodeInfoTag uint32

const (
	_ NodeInfoTag = iota
	NodeInfoService
	NodeInfoFile
	NodeInfoDirectory
	NodeInfoPipe
	NodeInfoVmofile
	NodeInfoDevice
)

type NodeInfo struct {
	NodeInfoTag `fidl:"tag" fidl2:"u,32,8"`
	Service     Service
	File        FileObject
	Directory   DirectoryObject
	Pipe        Pipe
	Vmofile     Vmofile
	Device      Device
}

// Implements Payload.
func (_ *NodeInfo) InlineAlignment() int {
	return 8
}

// Implements Payload.
func (_ *NodeInfo) InlineSize() int {
	return 32
}

func (u *NodeInfo) Which() NodeInfoTag {
	return u.NodeInfoTag
}

func (u *NodeInfo) SetService(service Service) {
	u.NodeInfoTag = NodeInfoService
	u.Service = service
}

func (u *NodeInfo) SetFile(file FileObject) {
	u.NodeInfoTag = NodeInfoFile
	u.File = file
}

func (u *NodeInfo) SetDirectory(directory DirectoryObject) {
	u.NodeInfoTag = NodeInfoDirectory
	u.Directory = directory
}

func (u *NodeInfo) SetPipe(pipe Pipe) {
	u.NodeInfoTag = NodeInfoPipe
	u.Pipe = pipe
}

func (u *NodeInfo) SetVmofile(vmofile Vmofile) {
	u.NodeInfoTag = NodeInfoVmofile
	u.Vmofile = vmofile
}

func (u *NodeInfo) SetDevice(device Device) {
	u.NodeInfoTag = NodeInfoDevice
	u.Device = device
}

const (
	NodeCloneOrdinal       uint32 = 402549324
	NodeCloneGenOrdinal    uint32 = 402549324
	NodeCloseOrdinal       uint32 = 1387878023
	NodeCloseGenOrdinal    uint32 = 1387878023
	NodeDescribeOrdinal    uint32 = 526573406
	NodeDescribeGenOrdinal uint32 = 526573406
	NodeOnOpenOrdinal      uint32 = 1191225277
	NodeOnOpenGenOrdinal   uint32 = 1191225277
	NodeSyncOrdinal        uint32 = 1648508842
	NodeSyncGenOrdinal     uint32 = 1648508842
	NodeGetAttrOrdinal     uint32 = 1166403528
	NodeGetAttrGenOrdinal  uint32 = 1166403528
	NodeSetAttrOrdinal     uint32 = 198530458
	NodeSetAttrGenOrdinal  uint32 = 198530458
	NodeIoctlOrdinal       uint32 = 905161895
	NodeIoctlGenOrdinal    uint32 = 905161895
)

type NodeCloneRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Flags  uint32
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mNodeCloneRequest = _bindings.CreateLazyMarshaler(NodeCloneRequest{})

func (msg *NodeCloneRequest) Marshaler() _bindings.Marshaler {
	return _mNodeCloneRequest
}

// Implements Payload.
func (_ *NodeCloneRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeCloneRequest) InlineSize() int {
	return 8
}

type NodeCloseRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mNodeCloseRequest = _bindings.CreateLazyMarshaler(NodeCloseRequest{})

func (msg *NodeCloseRequest) Marshaler() _bindings.Marshaler {
	return _mNodeCloseRequest
}

// Implements Payload.
func (_ *NodeCloseRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeCloseRequest) InlineSize() int {
	return 0
}

type NodeCloseResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mNodeCloseResponse = _bindings.CreateLazyMarshaler(NodeCloseResponse{})

func (msg *NodeCloseResponse) Marshaler() _bindings.Marshaler {
	return _mNodeCloseResponse
}

// Implements Payload.
func (_ *NodeCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeCloseResponse) InlineSize() int {
	return 8
}

type NodeDescribeRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mNodeDescribeRequest = _bindings.CreateLazyMarshaler(NodeDescribeRequest{})

func (msg *NodeDescribeRequest) Marshaler() _bindings.Marshaler {
	return _mNodeDescribeRequest
}

// Implements Payload.
func (_ *NodeDescribeRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeDescribeRequest) InlineSize() int {
	return 0
}

type NodeDescribeResponse struct {
	_    struct{} `fidl2:"s,32,0"`
	Info NodeInfo
}

var _mNodeDescribeResponse = _bindings.CreateLazyMarshaler(NodeDescribeResponse{})

func (msg *NodeDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mNodeDescribeResponse
}

// Implements Payload.
func (_ *NodeDescribeResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeDescribeResponse) InlineSize() int {
	return 32
}

type NodeOnOpenResponse struct {
	_    struct{} `fidl2:"s,16,0"`
	S    int32
	Info *NodeInfo
}

var _mNodeOnOpenResponse = _bindings.CreateLazyMarshaler(NodeOnOpenResponse{})

func (msg *NodeOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mNodeOnOpenResponse
}

// Implements Payload.
func (_ *NodeOnOpenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeOnOpenResponse) InlineSize() int {
	return 16
}

type NodeSyncRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mNodeSyncRequest = _bindings.CreateLazyMarshaler(NodeSyncRequest{})

func (msg *NodeSyncRequest) Marshaler() _bindings.Marshaler {
	return _mNodeSyncRequest
}

// Implements Payload.
func (_ *NodeSyncRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeSyncRequest) InlineSize() int {
	return 0
}

type NodeSyncResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mNodeSyncResponse = _bindings.CreateLazyMarshaler(NodeSyncResponse{})

func (msg *NodeSyncResponse) Marshaler() _bindings.Marshaler {
	return _mNodeSyncResponse
}

// Implements Payload.
func (_ *NodeSyncResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeSyncResponse) InlineSize() int {
	return 8
}

type NodeGetAttrRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mNodeGetAttrRequest = _bindings.CreateLazyMarshaler(NodeGetAttrRequest{})

func (msg *NodeGetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mNodeGetAttrRequest
}

// Implements Payload.
func (_ *NodeGetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeGetAttrRequest) InlineSize() int {
	return 0
}

type NodeGetAttrResponse struct {
	_          struct{} `fidl2:"s,64,0"`
	S          int32
	Attributes NodeAttributes
}

var _mNodeGetAttrResponse = _bindings.CreateLazyMarshaler(NodeGetAttrResponse{})

func (msg *NodeGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mNodeGetAttrResponse
}

// Implements Payload.
func (_ *NodeGetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeGetAttrResponse) InlineSize() int {
	return 64
}

type NodeSetAttrRequest struct {
	_          struct{} `fidl2:"s,64,0"`
	Flags      uint32
	Attributes NodeAttributes
}

var _mNodeSetAttrRequest = _bindings.CreateLazyMarshaler(NodeSetAttrRequest{})

func (msg *NodeSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mNodeSetAttrRequest
}

// Implements Payload.
func (_ *NodeSetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeSetAttrRequest) InlineSize() int {
	return 64
}

type NodeSetAttrResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mNodeSetAttrResponse = _bindings.CreateLazyMarshaler(NodeSetAttrResponse{})

func (msg *NodeSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mNodeSetAttrResponse
}

// Implements Payload.
func (_ *NodeSetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeSetAttrResponse) InlineSize() int {
	return 8
}

type NodeIoctlRequest struct {
	_       struct{} `fidl2:"s,48,0"`
	Opcode  uint32
	MaxOut  uint64
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	In      []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mNodeIoctlRequest = _bindings.CreateLazyMarshaler(NodeIoctlRequest{})

func (msg *NodeIoctlRequest) Marshaler() _bindings.Marshaler {
	return _mNodeIoctlRequest
}

// Implements Payload.
func (_ *NodeIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeIoctlRequest) InlineSize() int {
	return 48
}

type NodeIoctlResponse struct {
	_       struct{} `fidl2:"s,40,0"`
	S       int32
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	Out     []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mNodeIoctlResponse = _bindings.CreateLazyMarshaler(NodeIoctlResponse{})

func (msg *NodeIoctlResponse) Marshaler() _bindings.Marshaler {
	return _mNodeIoctlResponse
}

// Implements Payload.
func (_ *NodeIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *NodeIoctlResponse) InlineSize() int {
	return 40
}

type NodeInterface _bindings.ChannelProxy

func (p *NodeInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
	req_ := NodeCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(NodeCloneOrdinal, &req_)
	return err
}

func (p *NodeInterface) Close() (int32, error) {
	req_ := NodeCloseRequest{}
	resp_ := NodeCloseResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeCloseOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *NodeInterface) Describe() (NodeInfo, error) {
	req_ := NodeDescribeRequest{}
	resp_ := NodeDescribeResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeDescribeOrdinal, &req_, &resp_)
	return resp_.Info, err
}

func (p *NodeInterface) ExpectOnOpen() (int32, *NodeInfo, error) {
	resp_ := NodeOnOpenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(NodeOnOpenOrdinal, &resp_)
	return resp_.S, resp_.Info, err
}

func (p *NodeInterface) Sync() (int32, error) {
	req_ := NodeSyncRequest{}
	resp_ := NodeSyncResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeSyncOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *NodeInterface) GetAttr() (int32, NodeAttributes, error) {
	req_ := NodeGetAttrRequest{}
	resp_ := NodeGetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeGetAttrOrdinal, &req_, &resp_)
	return resp_.S, resp_.Attributes, err
}

func (p *NodeInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) {
	req_ := NodeSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := NodeSetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeSetAttrOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *NodeInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) {
	req_ := NodeIoctlRequest{
		Opcode:  opcode,
		MaxOut:  maxOut,
		Handles: handles,
		In:      in,
	}
	resp_ := NodeIoctlResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(NodeIoctlOrdinal, &req_, &resp_)
	return resp_.S, resp_.Handles, resp_.Out, err
}

type Node interface {
	Clone(flags uint32, object NodeInterfaceRequest) error
	Close() (int32, error)
	Describe() (NodeInfo, error)
	Sync() (int32, error)
	GetAttr() (int32, NodeAttributes, error)
	SetAttr(flags uint32, attributes NodeAttributes) (int32, error)
	Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error)
}

type NodeTransitionalBase struct{}

type NodeInterfaceRequest _bindings.InterfaceRequest

func NewNodeInterfaceRequest() (NodeInterfaceRequest, *NodeInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return NodeInterfaceRequest(req), (*NodeInterface)(cli), err
}

type NodeStub struct {
	Impl Node
}

func (s *NodeStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case NodeCloneOrdinal:
		in_ := NodeCloneRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Clone(in_.Flags, in_.Object)
		return nil, err_
	case NodeCloseOrdinal:
		in_ := NodeCloseRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeCloseResponse{}
		s, err_ := s.Impl.Close()
		out_.S = s
		return &out_, err_
	case NodeDescribeOrdinal:
		in_ := NodeDescribeRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeDescribeResponse{}
		info, err_ := s.Impl.Describe()
		out_.Info = info
		return &out_, err_
	case NodeSyncOrdinal:
		in_ := NodeSyncRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeSyncResponse{}
		s, err_ := s.Impl.Sync()
		out_.S = s
		return &out_, err_
	case NodeGetAttrOrdinal:
		in_ := NodeGetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeGetAttrResponse{}
		s, attributes, err_ := s.Impl.GetAttr()
		out_.S = s
		out_.Attributes = attributes
		return &out_, err_
	case NodeSetAttrOrdinal:
		in_ := NodeSetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeSetAttrResponse{}
		s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes)
		out_.S = s
		return &out_, err_
	case NodeIoctlOrdinal:
		in_ := NodeIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := NodeIoctlResponse{}
		s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In)
		out_.S = s
		out_.Handles = handles
		out_.Out = out
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type NodeService struct {
	_bindings.BindingSet
}

func (s *NodeService) Add(impl Node, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&NodeStub{Impl: impl}, c, onError)
}

func (s *NodeService) EventProxyFor(key _bindings.BindingKey) (*NodeEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*NodeEventProxy)(pxy), err
}

type NodeEventProxy _bindings.ChannelProxy

func (p *NodeEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := NodeOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(NodeOnOpenOrdinal, &event_)
}

const (
	FileCloneOrdinal        uint32 = 402549324
	FileCloneGenOrdinal     uint32 = 402549324
	FileCloseOrdinal        uint32 = 1387878023
	FileCloseGenOrdinal     uint32 = 1387878023
	FileDescribeOrdinal     uint32 = 526573406
	FileDescribeGenOrdinal  uint32 = 526573406
	FileOnOpenOrdinal       uint32 = 1191225277
	FileOnOpenGenOrdinal    uint32 = 1191225277
	FileSyncOrdinal         uint32 = 1648508842
	FileSyncGenOrdinal      uint32 = 1648508842
	FileGetAttrOrdinal      uint32 = 1166403528
	FileGetAttrGenOrdinal   uint32 = 1166403528
	FileSetAttrOrdinal      uint32 = 198530458
	FileSetAttrGenOrdinal   uint32 = 198530458
	FileIoctlOrdinal        uint32 = 905161895
	FileIoctlGenOrdinal     uint32 = 905161895
	FileReadOrdinal         uint32 = 636961156
	FileReadGenOrdinal      uint32 = 636961156
	FileReadAtOrdinal       uint32 = 2087865796
	FileReadAtGenOrdinal    uint32 = 2087865796
	FileWriteOrdinal        uint32 = 85125024
	FileWriteGenOrdinal     uint32 = 85125024
	FileWriteAtOrdinal      uint32 = 1045766885
	FileWriteAtGenOrdinal   uint32 = 1045766885
	FileSeekOrdinal         uint32 = 2016048965
	FileSeekGenOrdinal      uint32 = 2016048965
	FileTruncateOrdinal     uint32 = 1118517818
	FileTruncateGenOrdinal  uint32 = 1118517818
	FileGetFlagsOrdinal     uint32 = 1679205366
	FileGetFlagsGenOrdinal  uint32 = 1679205366
	FileSetFlagsOrdinal     uint32 = 1059310710
	FileSetFlagsGenOrdinal  uint32 = 1059310710
	FileGetBufferOrdinal    uint32 = 1958938995
	FileGetBufferGenOrdinal uint32 = 1958938995
)

type FileCloneRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Flags  uint32
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mFileCloneRequest = _bindings.CreateLazyMarshaler(FileCloneRequest{})

func (msg *FileCloneRequest) Marshaler() _bindings.Marshaler {
	return _mFileCloneRequest
}

// Implements Payload.
func (_ *FileCloneRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileCloneRequest) InlineSize() int {
	return 8
}

type FileCloseRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mFileCloseRequest = _bindings.CreateLazyMarshaler(FileCloseRequest{})

func (msg *FileCloseRequest) Marshaler() _bindings.Marshaler {
	return _mFileCloseRequest
}

// Implements Payload.
func (_ *FileCloseRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileCloseRequest) InlineSize() int {
	return 0
}

type FileCloseResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mFileCloseResponse = _bindings.CreateLazyMarshaler(FileCloseResponse{})

func (msg *FileCloseResponse) Marshaler() _bindings.Marshaler {
	return _mFileCloseResponse
}

// Implements Payload.
func (_ *FileCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileCloseResponse) InlineSize() int {
	return 8
}

type FileDescribeRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mFileDescribeRequest = _bindings.CreateLazyMarshaler(FileDescribeRequest{})

func (msg *FileDescribeRequest) Marshaler() _bindings.Marshaler {
	return _mFileDescribeRequest
}

// Implements Payload.
func (_ *FileDescribeRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileDescribeRequest) InlineSize() int {
	return 0
}

type FileDescribeResponse struct {
	_    struct{} `fidl2:"s,32,0"`
	Info NodeInfo
}

var _mFileDescribeResponse = _bindings.CreateLazyMarshaler(FileDescribeResponse{})

func (msg *FileDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mFileDescribeResponse
}

// Implements Payload.
func (_ *FileDescribeResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileDescribeResponse) InlineSize() int {
	return 32
}

type FileOnOpenResponse struct {
	_    struct{} `fidl2:"s,16,0"`
	S    int32
	Info *NodeInfo
}

var _mFileOnOpenResponse = _bindings.CreateLazyMarshaler(FileOnOpenResponse{})

func (msg *FileOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mFileOnOpenResponse
}

// Implements Payload.
func (_ *FileOnOpenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileOnOpenResponse) InlineSize() int {
	return 16
}

type FileSyncRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mFileSyncRequest = _bindings.CreateLazyMarshaler(FileSyncRequest{})

func (msg *FileSyncRequest) Marshaler() _bindings.Marshaler {
	return _mFileSyncRequest
}

// Implements Payload.
func (_ *FileSyncRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSyncRequest) InlineSize() int {
	return 0
}

type FileSyncResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mFileSyncResponse = _bindings.CreateLazyMarshaler(FileSyncResponse{})

func (msg *FileSyncResponse) Marshaler() _bindings.Marshaler {
	return _mFileSyncResponse
}

// Implements Payload.
func (_ *FileSyncResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSyncResponse) InlineSize() int {
	return 8
}

type FileGetAttrRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mFileGetAttrRequest = _bindings.CreateLazyMarshaler(FileGetAttrRequest{})

func (msg *FileGetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mFileGetAttrRequest
}

// Implements Payload.
func (_ *FileGetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetAttrRequest) InlineSize() int {
	return 0
}

type FileGetAttrResponse struct {
	_          struct{} `fidl2:"s,64,0"`
	S          int32
	Attributes NodeAttributes
}

var _mFileGetAttrResponse = _bindings.CreateLazyMarshaler(FileGetAttrResponse{})

func (msg *FileGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mFileGetAttrResponse
}

// Implements Payload.
func (_ *FileGetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetAttrResponse) InlineSize() int {
	return 64
}

type FileSetAttrRequest struct {
	_          struct{} `fidl2:"s,64,0"`
	Flags      uint32
	Attributes NodeAttributes
}

var _mFileSetAttrRequest = _bindings.CreateLazyMarshaler(FileSetAttrRequest{})

func (msg *FileSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mFileSetAttrRequest
}

// Implements Payload.
func (_ *FileSetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSetAttrRequest) InlineSize() int {
	return 64
}

type FileSetAttrResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mFileSetAttrResponse = _bindings.CreateLazyMarshaler(FileSetAttrResponse{})

func (msg *FileSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mFileSetAttrResponse
}

// Implements Payload.
func (_ *FileSetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSetAttrResponse) InlineSize() int {
	return 8
}

type FileIoctlRequest struct {
	_       struct{} `fidl2:"s,48,0"`
	Opcode  uint32
	MaxOut  uint64
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	In      []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mFileIoctlRequest = _bindings.CreateLazyMarshaler(FileIoctlRequest{})

func (msg *FileIoctlRequest) Marshaler() _bindings.Marshaler {
	return _mFileIoctlRequest
}

// Implements Payload.
func (_ *FileIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileIoctlRequest) InlineSize() int {
	return 48
}

type FileIoctlResponse struct {
	_       struct{} `fidl2:"s,40,0"`
	S       int32
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	Out     []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mFileIoctlResponse = _bindings.CreateLazyMarshaler(FileIoctlResponse{})

func (msg *FileIoctlResponse) Marshaler() _bindings.Marshaler {
	return _mFileIoctlResponse
}

// Implements Payload.
func (_ *FileIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileIoctlResponse) InlineSize() int {
	return 40
}

type FileReadRequest struct {
	_     struct{} `fidl2:"s,8,0"`
	Count uint64
}

var _mFileReadRequest = _bindings.CreateLazyMarshaler(FileReadRequest{})

func (msg *FileReadRequest) Marshaler() _bindings.Marshaler {
	return _mFileReadRequest
}

// Implements Payload.
func (_ *FileReadRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileReadRequest) InlineSize() int {
	return 8
}

type FileReadResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	S    int32
	Data []uint8 `fidl:"8192" fidl2:"8192"`
}

var _mFileReadResponse = _bindings.CreateLazyMarshaler(FileReadResponse{})

func (msg *FileReadResponse) Marshaler() _bindings.Marshaler {
	return _mFileReadResponse
}

// Implements Payload.
func (_ *FileReadResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileReadResponse) InlineSize() int {
	return 24
}

type FileReadAtRequest struct {
	_      struct{} `fidl2:"s,16,0"`
	Count  uint64
	Offset uint64
}

var _mFileReadAtRequest = _bindings.CreateLazyMarshaler(FileReadAtRequest{})

func (msg *FileReadAtRequest) Marshaler() _bindings.Marshaler {
	return _mFileReadAtRequest
}

// Implements Payload.
func (_ *FileReadAtRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileReadAtRequest) InlineSize() int {
	return 16
}

type FileReadAtResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	S    int32
	Data []uint8 `fidl:"8192" fidl2:"8192"`
}

var _mFileReadAtResponse = _bindings.CreateLazyMarshaler(FileReadAtResponse{})

func (msg *FileReadAtResponse) Marshaler() _bindings.Marshaler {
	return _mFileReadAtResponse
}

// Implements Payload.
func (_ *FileReadAtResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileReadAtResponse) InlineSize() int {
	return 24
}

type FileWriteRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Data []uint8  `fidl:"8192" fidl2:"8192"`
}

var _mFileWriteRequest = _bindings.CreateLazyMarshaler(FileWriteRequest{})

func (msg *FileWriteRequest) Marshaler() _bindings.Marshaler {
	return _mFileWriteRequest
}

// Implements Payload.
func (_ *FileWriteRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileWriteRequest) InlineSize() int {
	return 16
}

type FileWriteResponse struct {
	_      struct{} `fidl2:"s,16,0"`
	S      int32
	Actual uint64
}

var _mFileWriteResponse = _bindings.CreateLazyMarshaler(FileWriteResponse{})

func (msg *FileWriteResponse) Marshaler() _bindings.Marshaler {
	return _mFileWriteResponse
}

// Implements Payload.
func (_ *FileWriteResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileWriteResponse) InlineSize() int {
	return 16
}

type FileWriteAtRequest struct {
	_      struct{} `fidl2:"s,24,0"`
	Data   []uint8  `fidl:"8192" fidl2:"8192"`
	Offset uint64
}

var _mFileWriteAtRequest = _bindings.CreateLazyMarshaler(FileWriteAtRequest{})

func (msg *FileWriteAtRequest) Marshaler() _bindings.Marshaler {
	return _mFileWriteAtRequest
}

// Implements Payload.
func (_ *FileWriteAtRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileWriteAtRequest) InlineSize() int {
	return 24
}

type FileWriteAtResponse struct {
	_      struct{} `fidl2:"s,16,0"`
	S      int32
	Actual uint64
}

var _mFileWriteAtResponse = _bindings.CreateLazyMarshaler(FileWriteAtResponse{})

func (msg *FileWriteAtResponse) Marshaler() _bindings.Marshaler {
	return _mFileWriteAtResponse
}

// Implements Payload.
func (_ *FileWriteAtResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileWriteAtResponse) InlineSize() int {
	return 16
}

type FileSeekRequest struct {
	_      struct{} `fidl2:"s,16,0"`
	Offset int64
	Start  SeekOrigin
}

var _mFileSeekRequest = _bindings.CreateLazyMarshaler(FileSeekRequest{})

func (msg *FileSeekRequest) Marshaler() _bindings.Marshaler {
	return _mFileSeekRequest
}

// Implements Payload.
func (_ *FileSeekRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSeekRequest) InlineSize() int {
	return 16
}

type FileSeekResponse struct {
	_      struct{} `fidl2:"s,16,0"`
	S      int32
	Offset uint64
}

var _mFileSeekResponse = _bindings.CreateLazyMarshaler(FileSeekResponse{})

func (msg *FileSeekResponse) Marshaler() _bindings.Marshaler {
	return _mFileSeekResponse
}

// Implements Payload.
func (_ *FileSeekResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSeekResponse) InlineSize() int {
	return 16
}

type FileTruncateRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Length uint64
}

var _mFileTruncateRequest = _bindings.CreateLazyMarshaler(FileTruncateRequest{})

func (msg *FileTruncateRequest) Marshaler() _bindings.Marshaler {
	return _mFileTruncateRequest
}

// Implements Payload.
func (_ *FileTruncateRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileTruncateRequest) InlineSize() int {
	return 8
}

type FileTruncateResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mFileTruncateResponse = _bindings.CreateLazyMarshaler(FileTruncateResponse{})

func (msg *FileTruncateResponse) Marshaler() _bindings.Marshaler {
	return _mFileTruncateResponse
}

// Implements Payload.
func (_ *FileTruncateResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileTruncateResponse) InlineSize() int {
	return 8
}

type FileGetFlagsRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mFileGetFlagsRequest = _bindings.CreateLazyMarshaler(FileGetFlagsRequest{})

func (msg *FileGetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mFileGetFlagsRequest
}

// Implements Payload.
func (_ *FileGetFlagsRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetFlagsRequest) InlineSize() int {
	return 0
}

type FileGetFlagsResponse struct {
	_     struct{} `fidl2:"s,8,0"`
	S     int32
	Flags uint32
}

var _mFileGetFlagsResponse = _bindings.CreateLazyMarshaler(FileGetFlagsResponse{})

func (msg *FileGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mFileGetFlagsResponse
}

// Implements Payload.
func (_ *FileGetFlagsResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetFlagsResponse) InlineSize() int {
	return 8
}

type FileSetFlagsRequest struct {
	_     struct{} `fidl2:"s,8,0"`
	Flags uint32
}

var _mFileSetFlagsRequest = _bindings.CreateLazyMarshaler(FileSetFlagsRequest{})

func (msg *FileSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mFileSetFlagsRequest
}

// Implements Payload.
func (_ *FileSetFlagsRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSetFlagsRequest) InlineSize() int {
	return 8
}

type FileSetFlagsResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mFileSetFlagsResponse = _bindings.CreateLazyMarshaler(FileSetFlagsResponse{})

func (msg *FileSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mFileSetFlagsResponse
}

// Implements Payload.
func (_ *FileSetFlagsResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileSetFlagsResponse) InlineSize() int {
	return 8
}

type FileGetBufferRequest struct {
	_     struct{} `fidl2:"s,8,0"`
	Flags uint32
}

var _mFileGetBufferRequest = _bindings.CreateLazyMarshaler(FileGetBufferRequest{})

func (msg *FileGetBufferRequest) Marshaler() _bindings.Marshaler {
	return _mFileGetBufferRequest
}

// Implements Payload.
func (_ *FileGetBufferRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetBufferRequest) InlineSize() int {
	return 8
}

type FileGetBufferResponse struct {
	_      struct{} `fidl2:"s,16,0"`
	S      int32
	Buffer *fuchsiamem.Buffer
}

var _mFileGetBufferResponse = _bindings.CreateLazyMarshaler(FileGetBufferResponse{})

func (msg *FileGetBufferResponse) Marshaler() _bindings.Marshaler {
	return _mFileGetBufferResponse
}

// Implements Payload.
func (_ *FileGetBufferResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *FileGetBufferResponse) InlineSize() int {
	return 16
}

type FileInterface _bindings.ChannelProxy

func (p *FileInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
	req_ := FileCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(FileCloneOrdinal, &req_)
	return err
}

func (p *FileInterface) Close() (int32, error) {
	req_ := FileCloseRequest{}
	resp_ := FileCloseResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileCloseOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *FileInterface) Describe() (NodeInfo, error) {
	req_ := FileDescribeRequest{}
	resp_ := FileDescribeResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileDescribeOrdinal, &req_, &resp_)
	return resp_.Info, err
}

func (p *FileInterface) ExpectOnOpen() (int32, *NodeInfo, error) {
	resp_ := FileOnOpenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(FileOnOpenOrdinal, &resp_)
	return resp_.S, resp_.Info, err
}

func (p *FileInterface) Sync() (int32, error) {
	req_ := FileSyncRequest{}
	resp_ := FileSyncResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileSyncOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *FileInterface) GetAttr() (int32, NodeAttributes, error) {
	req_ := FileGetAttrRequest{}
	resp_ := FileGetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileGetAttrOrdinal, &req_, &resp_)
	return resp_.S, resp_.Attributes, err
}

func (p *FileInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) {
	req_ := FileSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := FileSetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileSetAttrOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *FileInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) {
	req_ := FileIoctlRequest{
		Opcode:  opcode,
		MaxOut:  maxOut,
		Handles: handles,
		In:      in,
	}
	resp_ := FileIoctlResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileIoctlOrdinal, &req_, &resp_)
	return resp_.S, resp_.Handles, resp_.Out, err
}

func (p *FileInterface) Read(count uint64) (int32, []uint8, error) {
	req_ := FileReadRequest{
		Count: count,
	}
	resp_ := FileReadResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileReadOrdinal, &req_, &resp_)
	return resp_.S, resp_.Data, err
}

func (p *FileInterface) ReadAt(count uint64, offset uint64) (int32, []uint8, error) {
	req_ := FileReadAtRequest{
		Count:  count,
		Offset: offset,
	}
	resp_ := FileReadAtResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileReadAtOrdinal, &req_, &resp_)
	return resp_.S, resp_.Data, err
}

func (p *FileInterface) Write(data []uint8) (int32, uint64, error) {
	req_ := FileWriteRequest{
		Data: data,
	}
	resp_ := FileWriteResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteOrdinal, &req_, &resp_)
	return resp_.S, resp_.Actual, err
}

func (p *FileInterface) WriteAt(data []uint8, offset uint64) (int32, uint64, error) {
	req_ := FileWriteAtRequest{
		Data:   data,
		Offset: offset,
	}
	resp_ := FileWriteAtResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteAtOrdinal, &req_, &resp_)
	return resp_.S, resp_.Actual, err
}

func (p *FileInterface) Seek(offset int64, start SeekOrigin) (int32, uint64, error) {
	req_ := FileSeekRequest{
		Offset: offset,
		Start:  start,
	}
	resp_ := FileSeekResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileSeekOrdinal, &req_, &resp_)
	return resp_.S, resp_.Offset, err
}

func (p *FileInterface) Truncate(length uint64) (int32, error) {
	req_ := FileTruncateRequest{
		Length: length,
	}
	resp_ := FileTruncateResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileTruncateOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *FileInterface) GetFlags() (int32, uint32, error) {
	req_ := FileGetFlagsRequest{}
	resp_ := FileGetFlagsResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileGetFlagsOrdinal, &req_, &resp_)
	return resp_.S, resp_.Flags, err
}

func (p *FileInterface) SetFlags(flags uint32) (int32, error) {
	req_ := FileSetFlagsRequest{
		Flags: flags,
	}
	resp_ := FileSetFlagsResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileSetFlagsOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *FileInterface) GetBuffer(flags uint32) (int32, *fuchsiamem.Buffer, error) {
	req_ := FileGetBufferRequest{
		Flags: flags,
	}
	resp_ := FileGetBufferResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(FileGetBufferOrdinal, &req_, &resp_)
	return resp_.S, resp_.Buffer, err
}

type File interface {
	Clone(flags uint32, object NodeInterfaceRequest) error
	Close() (int32, error)
	Describe() (NodeInfo, error)
	Sync() (int32, error)
	GetAttr() (int32, NodeAttributes, error)
	SetAttr(flags uint32, attributes NodeAttributes) (int32, error)
	Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error)
	Read(count uint64) (int32, []uint8, error)
	ReadAt(count uint64, offset uint64) (int32, []uint8, error)
	Write(data []uint8) (int32, uint64, error)
	WriteAt(data []uint8, offset uint64) (int32, uint64, error)
	Seek(offset int64, start SeekOrigin) (int32, uint64, error)
	Truncate(length uint64) (int32, error)
	GetFlags() (int32, uint32, error)
	SetFlags(flags uint32) (int32, error)
	GetBuffer(flags uint32) (int32, *fuchsiamem.Buffer, error)
}

type FileTransitionalBase struct{}

type FileInterfaceRequest _bindings.InterfaceRequest

func NewFileInterfaceRequest() (FileInterfaceRequest, *FileInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return FileInterfaceRequest(req), (*FileInterface)(cli), err
}

type FileStub struct {
	Impl File
}

func (s *FileStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case FileCloneOrdinal:
		in_ := FileCloneRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Clone(in_.Flags, in_.Object)
		return nil, err_
	case FileCloseOrdinal:
		in_ := FileCloseRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileCloseResponse{}
		s, err_ := s.Impl.Close()
		out_.S = s
		return &out_, err_
	case FileDescribeOrdinal:
		in_ := FileDescribeRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileDescribeResponse{}
		info, err_ := s.Impl.Describe()
		out_.Info = info
		return &out_, err_
	case FileSyncOrdinal:
		in_ := FileSyncRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileSyncResponse{}
		s, err_ := s.Impl.Sync()
		out_.S = s
		return &out_, err_
	case FileGetAttrOrdinal:
		in_ := FileGetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileGetAttrResponse{}
		s, attributes, err_ := s.Impl.GetAttr()
		out_.S = s
		out_.Attributes = attributes
		return &out_, err_
	case FileSetAttrOrdinal:
		in_ := FileSetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileSetAttrResponse{}
		s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes)
		out_.S = s
		return &out_, err_
	case FileIoctlOrdinal:
		in_ := FileIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileIoctlResponse{}
		s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In)
		out_.S = s
		out_.Handles = handles
		out_.Out = out
		return &out_, err_
	case FileReadOrdinal:
		in_ := FileReadRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileReadResponse{}
		s, data, err_ := s.Impl.Read(in_.Count)
		out_.S = s
		out_.Data = data
		return &out_, err_
	case FileReadAtOrdinal:
		in_ := FileReadAtRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileReadAtResponse{}
		s, data, err_ := s.Impl.ReadAt(in_.Count, in_.Offset)
		out_.S = s
		out_.Data = data
		return &out_, err_
	case FileWriteOrdinal:
		in_ := FileWriteRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileWriteResponse{}
		s, actual, err_ := s.Impl.Write(in_.Data)
		out_.S = s
		out_.Actual = actual
		return &out_, err_
	case FileWriteAtOrdinal:
		in_ := FileWriteAtRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileWriteAtResponse{}
		s, actual, err_ := s.Impl.WriteAt(in_.Data, in_.Offset)
		out_.S = s
		out_.Actual = actual
		return &out_, err_
	case FileSeekOrdinal:
		in_ := FileSeekRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileSeekResponse{}
		s, offset, err_ := s.Impl.Seek(in_.Offset, in_.Start)
		out_.S = s
		out_.Offset = offset
		return &out_, err_
	case FileTruncateOrdinal:
		in_ := FileTruncateRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileTruncateResponse{}
		s, err_ := s.Impl.Truncate(in_.Length)
		out_.S = s
		return &out_, err_
	case FileGetFlagsOrdinal:
		in_ := FileGetFlagsRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileGetFlagsResponse{}
		s, flags, err_ := s.Impl.GetFlags()
		out_.S = s
		out_.Flags = flags
		return &out_, err_
	case FileSetFlagsOrdinal:
		in_ := FileSetFlagsRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileSetFlagsResponse{}
		s, err_ := s.Impl.SetFlags(in_.Flags)
		out_.S = s
		return &out_, err_
	case FileGetBufferOrdinal:
		in_ := FileGetBufferRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := FileGetBufferResponse{}
		s, buffer, err_ := s.Impl.GetBuffer(in_.Flags)
		out_.S = s
		out_.Buffer = buffer
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type FileService struct {
	_bindings.BindingSet
}

func (s *FileService) Add(impl File, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&FileStub{Impl: impl}, c, onError)
}

func (s *FileService) EventProxyFor(key _bindings.BindingKey) (*FileEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*FileEventProxy)(pxy), err
}

type FileEventProxy _bindings.ChannelProxy

func (p *FileEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := FileOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(FileOnOpenOrdinal, &event_)
}

const (
	DirectoryWatcherOnEventOrdinal    uint32 = 546032797
	DirectoryWatcherOnEventGenOrdinal uint32 = 546032797
)

type DirectoryWatcherOnEventRequest struct {
	_      struct{} `fidl2:"s,16,0"`
	Events []uint8  `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryWatcherOnEventRequest = _bindings.CreateLazyMarshaler(DirectoryWatcherOnEventRequest{})

func (msg *DirectoryWatcherOnEventRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryWatcherOnEventRequest
}

// Implements Payload.
func (_ *DirectoryWatcherOnEventRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryWatcherOnEventRequest) InlineSize() int {
	return 16
}

type DirectoryWatcherInterface _bindings.ChannelProxy

func (p *DirectoryWatcherInterface) OnEvent(events []uint8) error {
	req_ := DirectoryWatcherOnEventRequest{
		Events: events,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryWatcherOnEventOrdinal, &req_)
	return err
}

type DirectoryWatcher interface {
	OnEvent(events []uint8) error
}

type DirectoryWatcherTransitionalBase struct{}

type DirectoryWatcherInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryWatcherInterfaceRequest() (DirectoryWatcherInterfaceRequest, *DirectoryWatcherInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryWatcherInterfaceRequest(req), (*DirectoryWatcherInterface)(cli), err
}

type DirectoryWatcherStub struct {
	Impl DirectoryWatcher
}

func (s *DirectoryWatcherStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case DirectoryWatcherOnEventOrdinal:
		in_ := DirectoryWatcherOnEventRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.OnEvent(in_.Events)
		return nil, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type DirectoryWatcherService struct {
	_bindings.BindingSet
}

func (s *DirectoryWatcherService) Add(impl DirectoryWatcher, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&DirectoryWatcherStub{Impl: impl}, c, onError)
}

func (s *DirectoryWatcherService) EventProxyFor(key _bindings.BindingKey) (*DirectoryWatcherEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*DirectoryWatcherEventProxy)(pxy), err
}

type DirectoryWatcherEventProxy _bindings.ChannelProxy

const (
	DirectoryCloneOrdinal          uint32 = 402549324
	DirectoryCloneGenOrdinal       uint32 = 402549324
	DirectoryCloseOrdinal          uint32 = 1387878023
	DirectoryCloseGenOrdinal       uint32 = 1387878023
	DirectoryDescribeOrdinal       uint32 = 526573406
	DirectoryDescribeGenOrdinal    uint32 = 526573406
	DirectoryOnOpenOrdinal         uint32 = 1191225277
	DirectoryOnOpenGenOrdinal      uint32 = 1191225277
	DirectorySyncOrdinal           uint32 = 1648508842
	DirectorySyncGenOrdinal        uint32 = 1648508842
	DirectoryGetAttrOrdinal        uint32 = 1166403528
	DirectoryGetAttrGenOrdinal     uint32 = 1166403528
	DirectorySetAttrOrdinal        uint32 = 198530458
	DirectorySetAttrGenOrdinal     uint32 = 198530458
	DirectoryIoctlOrdinal          uint32 = 905161895
	DirectoryIoctlGenOrdinal       uint32 = 905161895
	DirectoryOpenOrdinal           uint32 = 2011483371
	DirectoryOpenGenOrdinal        uint32 = 2011483371
	DirectoryUnlinkOrdinal         uint32 = 750443289
	DirectoryUnlinkGenOrdinal      uint32 = 750443289
	DirectoryReadDirentsOrdinal    uint32 = 782580781
	DirectoryReadDirentsGenOrdinal uint32 = 782580781
	DirectoryRewindOrdinal         uint32 = 1886584199
	DirectoryRewindGenOrdinal      uint32 = 1886584199
	DirectoryGetTokenOrdinal       uint32 = 840416493
	DirectoryGetTokenGenOrdinal    uint32 = 840416493
	DirectoryRenameOrdinal         uint32 = 1251258540
	DirectoryRenameGenOrdinal      uint32 = 1251258540
	DirectoryLinkOrdinal           uint32 = 462052964
	DirectoryLinkGenOrdinal        uint32 = 462052964
	DirectoryWatchOrdinal          uint32 = 1522700084
	DirectoryWatchGenOrdinal       uint32 = 1522700084
)

type DirectoryCloneRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Flags  uint32
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mDirectoryCloneRequest = _bindings.CreateLazyMarshaler(DirectoryCloneRequest{})

func (msg *DirectoryCloneRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryCloneRequest
}

// Implements Payload.
func (_ *DirectoryCloneRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryCloneRequest) InlineSize() int {
	return 8
}

type DirectoryCloseRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryCloseRequest = _bindings.CreateLazyMarshaler(DirectoryCloseRequest{})

func (msg *DirectoryCloseRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryCloseRequest
}

// Implements Payload.
func (_ *DirectoryCloseRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryCloseRequest) InlineSize() int {
	return 0
}

type DirectoryCloseResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryCloseResponse = _bindings.CreateLazyMarshaler(DirectoryCloseResponse{})

func (msg *DirectoryCloseResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryCloseResponse
}

// Implements Payload.
func (_ *DirectoryCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryCloseResponse) InlineSize() int {
	return 8
}

type DirectoryDescribeRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryDescribeRequest = _bindings.CreateLazyMarshaler(DirectoryDescribeRequest{})

func (msg *DirectoryDescribeRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryDescribeRequest
}

// Implements Payload.
func (_ *DirectoryDescribeRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryDescribeRequest) InlineSize() int {
	return 0
}

type DirectoryDescribeResponse struct {
	_    struct{} `fidl2:"s,32,0"`
	Info NodeInfo
}

var _mDirectoryDescribeResponse = _bindings.CreateLazyMarshaler(DirectoryDescribeResponse{})

func (msg *DirectoryDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryDescribeResponse
}

// Implements Payload.
func (_ *DirectoryDescribeResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryDescribeResponse) InlineSize() int {
	return 32
}

type DirectoryOnOpenResponse struct {
	_    struct{} `fidl2:"s,16,0"`
	S    int32
	Info *NodeInfo
}

var _mDirectoryOnOpenResponse = _bindings.CreateLazyMarshaler(DirectoryOnOpenResponse{})

func (msg *DirectoryOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryOnOpenResponse
}

// Implements Payload.
func (_ *DirectoryOnOpenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryOnOpenResponse) InlineSize() int {
	return 16
}

type DirectorySyncRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectorySyncRequest = _bindings.CreateLazyMarshaler(DirectorySyncRequest{})

func (msg *DirectorySyncRequest) Marshaler() _bindings.Marshaler {
	return _mDirectorySyncRequest
}

// Implements Payload.
func (_ *DirectorySyncRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectorySyncRequest) InlineSize() int {
	return 0
}

type DirectorySyncResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectorySyncResponse = _bindings.CreateLazyMarshaler(DirectorySyncResponse{})

func (msg *DirectorySyncResponse) Marshaler() _bindings.Marshaler {
	return _mDirectorySyncResponse
}

// Implements Payload.
func (_ *DirectorySyncResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectorySyncResponse) InlineSize() int {
	return 8
}

type DirectoryGetAttrRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryGetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryGetAttrRequest{})

func (msg *DirectoryGetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryGetAttrRequest
}

// Implements Payload.
func (_ *DirectoryGetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryGetAttrRequest) InlineSize() int {
	return 0
}

type DirectoryGetAttrResponse struct {
	_          struct{} `fidl2:"s,64,0"`
	S          int32
	Attributes NodeAttributes
}

var _mDirectoryGetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryGetAttrResponse{})

func (msg *DirectoryGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryGetAttrResponse
}

// Implements Payload.
func (_ *DirectoryGetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryGetAttrResponse) InlineSize() int {
	return 64
}

type DirectorySetAttrRequest struct {
	_          struct{} `fidl2:"s,64,0"`
	Flags      uint32
	Attributes NodeAttributes
}

var _mDirectorySetAttrRequest = _bindings.CreateLazyMarshaler(DirectorySetAttrRequest{})

func (msg *DirectorySetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mDirectorySetAttrRequest
}

// Implements Payload.
func (_ *DirectorySetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectorySetAttrRequest) InlineSize() int {
	return 64
}

type DirectorySetAttrResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectorySetAttrResponse = _bindings.CreateLazyMarshaler(DirectorySetAttrResponse{})

func (msg *DirectorySetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mDirectorySetAttrResponse
}

// Implements Payload.
func (_ *DirectorySetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectorySetAttrResponse) InlineSize() int {
	return 8
}

type DirectoryIoctlRequest struct {
	_       struct{} `fidl2:"s,48,0"`
	Opcode  uint32
	MaxOut  uint64
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	In      []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryIoctlRequest = _bindings.CreateLazyMarshaler(DirectoryIoctlRequest{})

func (msg *DirectoryIoctlRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryIoctlRequest
}

// Implements Payload.
func (_ *DirectoryIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryIoctlRequest) InlineSize() int {
	return 48
}

type DirectoryIoctlResponse struct {
	_       struct{} `fidl2:"s,40,0"`
	S       int32
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	Out     []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryIoctlResponse = _bindings.CreateLazyMarshaler(DirectoryIoctlResponse{})

func (msg *DirectoryIoctlResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryIoctlResponse
}

// Implements Payload.
func (_ *DirectoryIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryIoctlResponse) InlineSize() int {
	return 40
}

type DirectoryOpenRequest struct {
	_      struct{} `fidl2:"s,32,0"`
	Flags  uint32
	Mode   uint32
	Path   string               `fidl:"4096" fidl2:"4096"`
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mDirectoryOpenRequest = _bindings.CreateLazyMarshaler(DirectoryOpenRequest{})

func (msg *DirectoryOpenRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryOpenRequest
}

// Implements Payload.
func (_ *DirectoryOpenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryOpenRequest) InlineSize() int {
	return 32
}

type DirectoryUnlinkRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Path string   `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryUnlinkRequest = _bindings.CreateLazyMarshaler(DirectoryUnlinkRequest{})

func (msg *DirectoryUnlinkRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryUnlinkRequest
}

// Implements Payload.
func (_ *DirectoryUnlinkRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryUnlinkRequest) InlineSize() int {
	return 16
}

type DirectoryUnlinkResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryUnlinkResponse = _bindings.CreateLazyMarshaler(DirectoryUnlinkResponse{})

func (msg *DirectoryUnlinkResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryUnlinkResponse
}

// Implements Payload.
func (_ *DirectoryUnlinkResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryUnlinkResponse) InlineSize() int {
	return 8
}

type DirectoryReadDirentsRequest struct {
	_        struct{} `fidl2:"s,8,0"`
	MaxBytes uint64
}

var _mDirectoryReadDirentsRequest = _bindings.CreateLazyMarshaler(DirectoryReadDirentsRequest{})

func (msg *DirectoryReadDirentsRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryReadDirentsRequest
}

// Implements Payload.
func (_ *DirectoryReadDirentsRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryReadDirentsRequest) InlineSize() int {
	return 8
}

type DirectoryReadDirentsResponse struct {
	_       struct{} `fidl2:"s,24,0"`
	S       int32
	Dirents []uint8 `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryReadDirentsResponse = _bindings.CreateLazyMarshaler(DirectoryReadDirentsResponse{})

func (msg *DirectoryReadDirentsResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryReadDirentsResponse
}

// Implements Payload.
func (_ *DirectoryReadDirentsResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryReadDirentsResponse) InlineSize() int {
	return 24
}

type DirectoryRewindRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryRewindRequest = _bindings.CreateLazyMarshaler(DirectoryRewindRequest{})

func (msg *DirectoryRewindRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryRewindRequest
}

// Implements Payload.
func (_ *DirectoryRewindRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryRewindRequest) InlineSize() int {
	return 0
}

type DirectoryRewindResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryRewindResponse = _bindings.CreateLazyMarshaler(DirectoryRewindResponse{})

func (msg *DirectoryRewindResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryRewindResponse
}

// Implements Payload.
func (_ *DirectoryRewindResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryRewindResponse) InlineSize() int {
	return 8
}

type DirectoryGetTokenRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryGetTokenRequest = _bindings.CreateLazyMarshaler(DirectoryGetTokenRequest{})

func (msg *DirectoryGetTokenRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryGetTokenRequest
}

// Implements Payload.
func (_ *DirectoryGetTokenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryGetTokenRequest) InlineSize() int {
	return 0
}

type DirectoryGetTokenResponse struct {
	_     struct{} `fidl2:"s,8,0"`
	S     int32
	Token _zx.Handle `fidl:"*" fidl2:"1"`
}

var _mDirectoryGetTokenResponse = _bindings.CreateLazyMarshaler(DirectoryGetTokenResponse{})

func (msg *DirectoryGetTokenResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryGetTokenResponse
}

// Implements Payload.
func (_ *DirectoryGetTokenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryGetTokenResponse) InlineSize() int {
	return 8
}

type DirectoryRenameRequest struct {
	_              struct{}   `fidl2:"s,40,0"`
	Src            string     `fidl:"4096" fidl2:"4096"`
	DstParentToken _zx.Handle `fidl2:"0"`
	Dst            string     `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryRenameRequest = _bindings.CreateLazyMarshaler(DirectoryRenameRequest{})

func (msg *DirectoryRenameRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryRenameRequest
}

// Implements Payload.
func (_ *DirectoryRenameRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryRenameRequest) InlineSize() int {
	return 40
}

type DirectoryRenameResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryRenameResponse = _bindings.CreateLazyMarshaler(DirectoryRenameResponse{})

func (msg *DirectoryRenameResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryRenameResponse
}

// Implements Payload.
func (_ *DirectoryRenameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryRenameResponse) InlineSize() int {
	return 8
}

type DirectoryLinkRequest struct {
	_              struct{}   `fidl2:"s,40,0"`
	Src            string     `fidl:"4096" fidl2:"4096"`
	DstParentToken _zx.Handle `fidl2:"0"`
	Dst            string     `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryLinkRequest = _bindings.CreateLazyMarshaler(DirectoryLinkRequest{})

func (msg *DirectoryLinkRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryLinkRequest
}

// Implements Payload.
func (_ *DirectoryLinkRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryLinkRequest) InlineSize() int {
	return 40
}

type DirectoryLinkResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryLinkResponse = _bindings.CreateLazyMarshaler(DirectoryLinkResponse{})

func (msg *DirectoryLinkResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryLinkResponse
}

// Implements Payload.
func (_ *DirectoryLinkResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryLinkResponse) InlineSize() int {
	return 8
}

type DirectoryWatchRequest struct {
	_       struct{} `fidl2:"s,16,0"`
	Mask    uint32
	Options uint32
	Watcher _zx.Channel `fidl2:"0"`
}

var _mDirectoryWatchRequest = _bindings.CreateLazyMarshaler(DirectoryWatchRequest{})

func (msg *DirectoryWatchRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryWatchRequest
}

// Implements Payload.
func (_ *DirectoryWatchRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryWatchRequest) InlineSize() int {
	return 16
}

type DirectoryWatchResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryWatchResponse = _bindings.CreateLazyMarshaler(DirectoryWatchResponse{})

func (msg *DirectoryWatchResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryWatchResponse
}

// Implements Payload.
func (_ *DirectoryWatchResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryWatchResponse) InlineSize() int {
	return 8
}

type DirectoryInterface _bindings.ChannelProxy

func (p *DirectoryInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
	req_ := DirectoryCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryCloneOrdinal, &req_)
	return err
}

func (p *DirectoryInterface) Close() (int32, error) {
	req_ := DirectoryCloseRequest{}
	resp_ := DirectoryCloseResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryCloseOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) Describe() (NodeInfo, error) {
	req_ := DirectoryDescribeRequest{}
	resp_ := DirectoryDescribeResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryDescribeOrdinal, &req_, &resp_)
	return resp_.Info, err
}

func (p *DirectoryInterface) ExpectOnOpen() (int32, *NodeInfo, error) {
	resp_ := DirectoryOnOpenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryOnOpenOrdinal, &resp_)
	return resp_.S, resp_.Info, err
}

func (p *DirectoryInterface) Sync() (int32, error) {
	req_ := DirectorySyncRequest{}
	resp_ := DirectorySyncResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySyncOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) GetAttr() (int32, NodeAttributes, error) {
	req_ := DirectoryGetAttrRequest{}
	resp_ := DirectoryGetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetAttrOrdinal, &req_, &resp_)
	return resp_.S, resp_.Attributes, err
}

func (p *DirectoryInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) {
	req_ := DirectorySetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := DirectorySetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySetAttrOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) {
	req_ := DirectoryIoctlRequest{
		Opcode:  opcode,
		MaxOut:  maxOut,
		Handles: handles,
		In:      in,
	}
	resp_ := DirectoryIoctlResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryIoctlOrdinal, &req_, &resp_)
	return resp_.S, resp_.Handles, resp_.Out, err
}

func (p *DirectoryInterface) Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error {
	req_ := DirectoryOpenRequest{
		Flags:  flags,
		Mode:   mode,
		Path:   path,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryOpenOrdinal, &req_)
	return err
}

func (p *DirectoryInterface) Unlink(path string) (int32, error) {
	req_ := DirectoryUnlinkRequest{
		Path: path,
	}
	resp_ := DirectoryUnlinkResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryUnlinkOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) ReadDirents(maxBytes uint64) (int32, []uint8, error) {
	req_ := DirectoryReadDirentsRequest{
		MaxBytes: maxBytes,
	}
	resp_ := DirectoryReadDirentsResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryReadDirentsOrdinal, &req_, &resp_)
	return resp_.S, resp_.Dirents, err
}

func (p *DirectoryInterface) Rewind() (int32, error) {
	req_ := DirectoryRewindRequest{}
	resp_ := DirectoryRewindResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRewindOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) GetToken() (int32, _zx.Handle, error) {
	req_ := DirectoryGetTokenRequest{}
	resp_ := DirectoryGetTokenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetTokenOrdinal, &req_, &resp_)
	return resp_.S, resp_.Token, err
}

func (p *DirectoryInterface) Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := DirectoryRenameRequest{
		Src:            src,
		DstParentToken: dstParentToken,
		Dst:            dst,
	}
	resp_ := DirectoryRenameResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRenameOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := DirectoryLinkRequest{
		Src:            src,
		DstParentToken: dstParentToken,
		Dst:            dst,
	}
	resp_ := DirectoryLinkResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryLinkOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryInterface) Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) {
	req_ := DirectoryWatchRequest{
		Mask:    mask,
		Options: options,
		Watcher: watcher,
	}
	resp_ := DirectoryWatchResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryWatchOrdinal, &req_, &resp_)
	return resp_.S, err
}

type Directory interface {
	Clone(flags uint32, object NodeInterfaceRequest) error
	Close() (int32, error)
	Describe() (NodeInfo, error)
	Sync() (int32, error)
	GetAttr() (int32, NodeAttributes, error)
	SetAttr(flags uint32, attributes NodeAttributes) (int32, error)
	Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error)
	Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error
	Unlink(path string) (int32, error)
	ReadDirents(maxBytes uint64) (int32, []uint8, error)
	Rewind() (int32, error)
	GetToken() (int32, _zx.Handle, error)
	Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error)
	Link(src string, dstParentToken _zx.Handle, dst string) (int32, error)
	Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error)
}

type DirectoryTransitionalBase struct{}

type DirectoryInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryInterfaceRequest() (DirectoryInterfaceRequest, *DirectoryInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryInterfaceRequest(req), (*DirectoryInterface)(cli), err
}

type DirectoryStub struct {
	Impl Directory
}

func (s *DirectoryStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case DirectoryCloneOrdinal:
		in_ := DirectoryCloneRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Clone(in_.Flags, in_.Object)
		return nil, err_
	case DirectoryCloseOrdinal:
		in_ := DirectoryCloseRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryCloseResponse{}
		s, err_ := s.Impl.Close()
		out_.S = s
		return &out_, err_
	case DirectoryDescribeOrdinal:
		in_ := DirectoryDescribeRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryDescribeResponse{}
		info, err_ := s.Impl.Describe()
		out_.Info = info
		return &out_, err_
	case DirectorySyncOrdinal:
		in_ := DirectorySyncRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectorySyncResponse{}
		s, err_ := s.Impl.Sync()
		out_.S = s
		return &out_, err_
	case DirectoryGetAttrOrdinal:
		in_ := DirectoryGetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryGetAttrResponse{}
		s, attributes, err_ := s.Impl.GetAttr()
		out_.S = s
		out_.Attributes = attributes
		return &out_, err_
	case DirectorySetAttrOrdinal:
		in_ := DirectorySetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectorySetAttrResponse{}
		s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes)
		out_.S = s
		return &out_, err_
	case DirectoryIoctlOrdinal:
		in_ := DirectoryIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryIoctlResponse{}
		s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In)
		out_.S = s
		out_.Handles = handles
		out_.Out = out
		return &out_, err_
	case DirectoryOpenOrdinal:
		in_ := DirectoryOpenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Open(in_.Flags, in_.Mode, in_.Path, in_.Object)
		return nil, err_
	case DirectoryUnlinkOrdinal:
		in_ := DirectoryUnlinkRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryUnlinkResponse{}
		s, err_ := s.Impl.Unlink(in_.Path)
		out_.S = s
		return &out_, err_
	case DirectoryReadDirentsOrdinal:
		in_ := DirectoryReadDirentsRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryReadDirentsResponse{}
		s, dirents, err_ := s.Impl.ReadDirents(in_.MaxBytes)
		out_.S = s
		out_.Dirents = dirents
		return &out_, err_
	case DirectoryRewindOrdinal:
		in_ := DirectoryRewindRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryRewindResponse{}
		s, err_ := s.Impl.Rewind()
		out_.S = s
		return &out_, err_
	case DirectoryGetTokenOrdinal:
		in_ := DirectoryGetTokenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryGetTokenResponse{}
		s, token, err_ := s.Impl.GetToken()
		out_.S = s
		out_.Token = token
		return &out_, err_
	case DirectoryRenameOrdinal:
		in_ := DirectoryRenameRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryRenameResponse{}
		s, err_ := s.Impl.Rename(in_.Src, in_.DstParentToken, in_.Dst)
		out_.S = s
		return &out_, err_
	case DirectoryLinkOrdinal:
		in_ := DirectoryLinkRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryLinkResponse{}
		s, err_ := s.Impl.Link(in_.Src, in_.DstParentToken, in_.Dst)
		out_.S = s
		return &out_, err_
	case DirectoryWatchOrdinal:
		in_ := DirectoryWatchRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryWatchResponse{}
		s, err_ := s.Impl.Watch(in_.Mask, in_.Options, in_.Watcher)
		out_.S = s
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type DirectoryService struct {
	_bindings.BindingSet
}

func (s *DirectoryService) Add(impl Directory, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&DirectoryStub{Impl: impl}, c, onError)
}

func (s *DirectoryService) EventProxyFor(key _bindings.BindingKey) (*DirectoryEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*DirectoryEventProxy)(pxy), err
}

type DirectoryEventProxy _bindings.ChannelProxy

func (p *DirectoryEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := DirectoryOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(DirectoryOnOpenOrdinal, &event_)
}

const (
	DirectoryAdminCloneOrdinal              uint32 = 402549324
	DirectoryAdminCloneGenOrdinal           uint32 = 402549324
	DirectoryAdminCloseOrdinal              uint32 = 1387878023
	DirectoryAdminCloseGenOrdinal           uint32 = 1387878023
	DirectoryAdminDescribeOrdinal           uint32 = 526573406
	DirectoryAdminDescribeGenOrdinal        uint32 = 526573406
	DirectoryAdminOnOpenOrdinal             uint32 = 1191225277
	DirectoryAdminOnOpenGenOrdinal          uint32 = 1191225277
	DirectoryAdminSyncOrdinal               uint32 = 1648508842
	DirectoryAdminSyncGenOrdinal            uint32 = 1648508842
	DirectoryAdminGetAttrOrdinal            uint32 = 1166403528
	DirectoryAdminGetAttrGenOrdinal         uint32 = 1166403528
	DirectoryAdminSetAttrOrdinal            uint32 = 198530458
	DirectoryAdminSetAttrGenOrdinal         uint32 = 198530458
	DirectoryAdminIoctlOrdinal              uint32 = 905161895
	DirectoryAdminIoctlGenOrdinal           uint32 = 905161895
	DirectoryAdminOpenOrdinal               uint32 = 2011483371
	DirectoryAdminOpenGenOrdinal            uint32 = 2011483371
	DirectoryAdminUnlinkOrdinal             uint32 = 750443289
	DirectoryAdminUnlinkGenOrdinal          uint32 = 750443289
	DirectoryAdminReadDirentsOrdinal        uint32 = 782580781
	DirectoryAdminReadDirentsGenOrdinal     uint32 = 782580781
	DirectoryAdminRewindOrdinal             uint32 = 1886584199
	DirectoryAdminRewindGenOrdinal          uint32 = 1886584199
	DirectoryAdminGetTokenOrdinal           uint32 = 840416493
	DirectoryAdminGetTokenGenOrdinal        uint32 = 840416493
	DirectoryAdminRenameOrdinal             uint32 = 1251258540
	DirectoryAdminRenameGenOrdinal          uint32 = 1251258540
	DirectoryAdminLinkOrdinal               uint32 = 462052964
	DirectoryAdminLinkGenOrdinal            uint32 = 462052964
	DirectoryAdminWatchOrdinal              uint32 = 1522700084
	DirectoryAdminWatchGenOrdinal           uint32 = 1522700084
	DirectoryAdminMountOrdinal              uint32 = 2120159974
	DirectoryAdminMountGenOrdinal           uint32 = 2120159974
	DirectoryAdminMountAndCreateOrdinal     uint32 = 841348753
	DirectoryAdminMountAndCreateGenOrdinal  uint32 = 841348753
	DirectoryAdminUnmountOrdinal            uint32 = 620898132
	DirectoryAdminUnmountGenOrdinal         uint32 = 620898132
	DirectoryAdminUnmountNodeOrdinal        uint32 = 383400103
	DirectoryAdminUnmountNodeGenOrdinal     uint32 = 383400103
	DirectoryAdminQueryFilesystemOrdinal    uint32 = 1713999250
	DirectoryAdminQueryFilesystemGenOrdinal uint32 = 1713999250
	DirectoryAdminGetDevicePathOrdinal      uint32 = 787943096
	DirectoryAdminGetDevicePathGenOrdinal   uint32 = 787943096
)

type DirectoryAdminCloneRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Flags  uint32
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mDirectoryAdminCloneRequest = _bindings.CreateLazyMarshaler(DirectoryAdminCloneRequest{})

func (msg *DirectoryAdminCloneRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminCloneRequest
}

// Implements Payload.
func (_ *DirectoryAdminCloneRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminCloneRequest) InlineSize() int {
	return 8
}

type DirectoryAdminCloseRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminCloseRequest = _bindings.CreateLazyMarshaler(DirectoryAdminCloseRequest{})

func (msg *DirectoryAdminCloseRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminCloseRequest
}

// Implements Payload.
func (_ *DirectoryAdminCloseRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminCloseRequest) InlineSize() int {
	return 0
}

type DirectoryAdminCloseResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminCloseResponse = _bindings.CreateLazyMarshaler(DirectoryAdminCloseResponse{})

func (msg *DirectoryAdminCloseResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminCloseResponse
}

// Implements Payload.
func (_ *DirectoryAdminCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminCloseResponse) InlineSize() int {
	return 8
}

type DirectoryAdminDescribeRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminDescribeRequest = _bindings.CreateLazyMarshaler(DirectoryAdminDescribeRequest{})

func (msg *DirectoryAdminDescribeRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminDescribeRequest
}

// Implements Payload.
func (_ *DirectoryAdminDescribeRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminDescribeRequest) InlineSize() int {
	return 0
}

type DirectoryAdminDescribeResponse struct {
	_    struct{} `fidl2:"s,32,0"`
	Info NodeInfo
}

var _mDirectoryAdminDescribeResponse = _bindings.CreateLazyMarshaler(DirectoryAdminDescribeResponse{})

func (msg *DirectoryAdminDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminDescribeResponse
}

// Implements Payload.
func (_ *DirectoryAdminDescribeResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminDescribeResponse) InlineSize() int {
	return 32
}

type DirectoryAdminOnOpenResponse struct {
	_    struct{} `fidl2:"s,16,0"`
	S    int32
	Info *NodeInfo
}

var _mDirectoryAdminOnOpenResponse = _bindings.CreateLazyMarshaler(DirectoryAdminOnOpenResponse{})

func (msg *DirectoryAdminOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminOnOpenResponse
}

// Implements Payload.
func (_ *DirectoryAdminOnOpenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminOnOpenResponse) InlineSize() int {
	return 16
}

type DirectoryAdminSyncRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminSyncRequest = _bindings.CreateLazyMarshaler(DirectoryAdminSyncRequest{})

func (msg *DirectoryAdminSyncRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminSyncRequest
}

// Implements Payload.
func (_ *DirectoryAdminSyncRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminSyncRequest) InlineSize() int {
	return 0
}

type DirectoryAdminSyncResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminSyncResponse = _bindings.CreateLazyMarshaler(DirectoryAdminSyncResponse{})

func (msg *DirectoryAdminSyncResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminSyncResponse
}

// Implements Payload.
func (_ *DirectoryAdminSyncResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminSyncResponse) InlineSize() int {
	return 8
}

type DirectoryAdminGetAttrRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminGetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetAttrRequest{})

func (msg *DirectoryAdminGetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetAttrRequest
}

// Implements Payload.
func (_ *DirectoryAdminGetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetAttrRequest) InlineSize() int {
	return 0
}

type DirectoryAdminGetAttrResponse struct {
	_          struct{} `fidl2:"s,64,0"`
	S          int32
	Attributes NodeAttributes
}

var _mDirectoryAdminGetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetAttrResponse{})

func (msg *DirectoryAdminGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetAttrResponse
}

// Implements Payload.
func (_ *DirectoryAdminGetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetAttrResponse) InlineSize() int {
	return 64
}

type DirectoryAdminSetAttrRequest struct {
	_          struct{} `fidl2:"s,64,0"`
	Flags      uint32
	Attributes NodeAttributes
}

var _mDirectoryAdminSetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryAdminSetAttrRequest{})

func (msg *DirectoryAdminSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminSetAttrRequest
}

// Implements Payload.
func (_ *DirectoryAdminSetAttrRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminSetAttrRequest) InlineSize() int {
	return 64
}

type DirectoryAdminSetAttrResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminSetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryAdminSetAttrResponse{})

func (msg *DirectoryAdminSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminSetAttrResponse
}

// Implements Payload.
func (_ *DirectoryAdminSetAttrResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminSetAttrResponse) InlineSize() int {
	return 8
}

type DirectoryAdminIoctlRequest struct {
	_       struct{} `fidl2:"s,48,0"`
	Opcode  uint32
	MaxOut  uint64
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	In      []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryAdminIoctlRequest = _bindings.CreateLazyMarshaler(DirectoryAdminIoctlRequest{})

func (msg *DirectoryAdminIoctlRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminIoctlRequest
}

// Implements Payload.
func (_ *DirectoryAdminIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminIoctlRequest) InlineSize() int {
	return 48
}

type DirectoryAdminIoctlResponse struct {
	_       struct{} `fidl2:"s,40,0"`
	S       int32
	Handles []_zx.Handle `fidl:"2" fidl2:"2,0"`
	Out     []uint8      `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryAdminIoctlResponse = _bindings.CreateLazyMarshaler(DirectoryAdminIoctlResponse{})

func (msg *DirectoryAdminIoctlResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminIoctlResponse
}

// Implements Payload.
func (_ *DirectoryAdminIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminIoctlResponse) InlineSize() int {
	return 40
}

type DirectoryAdminOpenRequest struct {
	_      struct{} `fidl2:"s,32,0"`
	Flags  uint32
	Mode   uint32
	Path   string               `fidl:"4096" fidl2:"4096"`
	Object NodeInterfaceRequest `fidl2:"0"`
}

var _mDirectoryAdminOpenRequest = _bindings.CreateLazyMarshaler(DirectoryAdminOpenRequest{})

func (msg *DirectoryAdminOpenRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminOpenRequest
}

// Implements Payload.
func (_ *DirectoryAdminOpenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminOpenRequest) InlineSize() int {
	return 32
}

type DirectoryAdminUnlinkRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Path string   `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryAdminUnlinkRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnlinkRequest{})

func (msg *DirectoryAdminUnlinkRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnlinkRequest
}

// Implements Payload.
func (_ *DirectoryAdminUnlinkRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnlinkRequest) InlineSize() int {
	return 16
}

type DirectoryAdminUnlinkResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminUnlinkResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnlinkResponse{})

func (msg *DirectoryAdminUnlinkResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnlinkResponse
}

// Implements Payload.
func (_ *DirectoryAdminUnlinkResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnlinkResponse) InlineSize() int {
	return 8
}

type DirectoryAdminReadDirentsRequest struct {
	_        struct{} `fidl2:"s,8,0"`
	MaxBytes uint64
}

var _mDirectoryAdminReadDirentsRequest = _bindings.CreateLazyMarshaler(DirectoryAdminReadDirentsRequest{})

func (msg *DirectoryAdminReadDirentsRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminReadDirentsRequest
}

// Implements Payload.
func (_ *DirectoryAdminReadDirentsRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminReadDirentsRequest) InlineSize() int {
	return 8
}

type DirectoryAdminReadDirentsResponse struct {
	_       struct{} `fidl2:"s,24,0"`
	S       int32
	Dirents []uint8 `fidl:"8192" fidl2:"8192"`
}

var _mDirectoryAdminReadDirentsResponse = _bindings.CreateLazyMarshaler(DirectoryAdminReadDirentsResponse{})

func (msg *DirectoryAdminReadDirentsResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminReadDirentsResponse
}

// Implements Payload.
func (_ *DirectoryAdminReadDirentsResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminReadDirentsResponse) InlineSize() int {
	return 24
}

type DirectoryAdminRewindRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminRewindRequest = _bindings.CreateLazyMarshaler(DirectoryAdminRewindRequest{})

func (msg *DirectoryAdminRewindRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminRewindRequest
}

// Implements Payload.
func (_ *DirectoryAdminRewindRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminRewindRequest) InlineSize() int {
	return 0
}

type DirectoryAdminRewindResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminRewindResponse = _bindings.CreateLazyMarshaler(DirectoryAdminRewindResponse{})

func (msg *DirectoryAdminRewindResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminRewindResponse
}

// Implements Payload.
func (_ *DirectoryAdminRewindResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminRewindResponse) InlineSize() int {
	return 8
}

type DirectoryAdminGetTokenRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminGetTokenRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetTokenRequest{})

func (msg *DirectoryAdminGetTokenRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetTokenRequest
}

// Implements Payload.
func (_ *DirectoryAdminGetTokenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetTokenRequest) InlineSize() int {
	return 0
}

type DirectoryAdminGetTokenResponse struct {
	_     struct{} `fidl2:"s,8,0"`
	S     int32
	Token _zx.Handle `fidl:"*" fidl2:"1"`
}

var _mDirectoryAdminGetTokenResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetTokenResponse{})

func (msg *DirectoryAdminGetTokenResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetTokenResponse
}

// Implements Payload.
func (_ *DirectoryAdminGetTokenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetTokenResponse) InlineSize() int {
	return 8
}

type DirectoryAdminRenameRequest struct {
	_              struct{}   `fidl2:"s,40,0"`
	Src            string     `fidl:"4096" fidl2:"4096"`
	DstParentToken _zx.Handle `fidl2:"0"`
	Dst            string     `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryAdminRenameRequest = _bindings.CreateLazyMarshaler(DirectoryAdminRenameRequest{})

func (msg *DirectoryAdminRenameRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminRenameRequest
}

// Implements Payload.
func (_ *DirectoryAdminRenameRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminRenameRequest) InlineSize() int {
	return 40
}

type DirectoryAdminRenameResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminRenameResponse = _bindings.CreateLazyMarshaler(DirectoryAdminRenameResponse{})

func (msg *DirectoryAdminRenameResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminRenameResponse
}

// Implements Payload.
func (_ *DirectoryAdminRenameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminRenameResponse) InlineSize() int {
	return 8
}

type DirectoryAdminLinkRequest struct {
	_              struct{}   `fidl2:"s,40,0"`
	Src            string     `fidl:"4096" fidl2:"4096"`
	DstParentToken _zx.Handle `fidl2:"0"`
	Dst            string     `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryAdminLinkRequest = _bindings.CreateLazyMarshaler(DirectoryAdminLinkRequest{})

func (msg *DirectoryAdminLinkRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminLinkRequest
}

// Implements Payload.
func (_ *DirectoryAdminLinkRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminLinkRequest) InlineSize() int {
	return 40
}

type DirectoryAdminLinkResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminLinkResponse = _bindings.CreateLazyMarshaler(DirectoryAdminLinkResponse{})

func (msg *DirectoryAdminLinkResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminLinkResponse
}

// Implements Payload.
func (_ *DirectoryAdminLinkResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminLinkResponse) InlineSize() int {
	return 8
}

type DirectoryAdminWatchRequest struct {
	_       struct{} `fidl2:"s,16,0"`
	Mask    uint32
	Options uint32
	Watcher _zx.Channel `fidl2:"0"`
}

var _mDirectoryAdminWatchRequest = _bindings.CreateLazyMarshaler(DirectoryAdminWatchRequest{})

func (msg *DirectoryAdminWatchRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminWatchRequest
}

// Implements Payload.
func (_ *DirectoryAdminWatchRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminWatchRequest) InlineSize() int {
	return 16
}

type DirectoryAdminWatchResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminWatchResponse = _bindings.CreateLazyMarshaler(DirectoryAdminWatchResponse{})

func (msg *DirectoryAdminWatchResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminWatchResponse
}

// Implements Payload.
func (_ *DirectoryAdminWatchResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminWatchResponse) InlineSize() int {
	return 8
}

type DirectoryAdminMountRequest struct {
	_      struct{} `fidl2:"s,8,0"`
	Remote DirectoryInterface
}

var _mDirectoryAdminMountRequest = _bindings.CreateLazyMarshaler(DirectoryAdminMountRequest{})

func (msg *DirectoryAdminMountRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminMountRequest
}

// Implements Payload.
func (_ *DirectoryAdminMountRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminMountRequest) InlineSize() int {
	return 8
}

type DirectoryAdminMountResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminMountResponse = _bindings.CreateLazyMarshaler(DirectoryAdminMountResponse{})

func (msg *DirectoryAdminMountResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminMountResponse
}

// Implements Payload.
func (_ *DirectoryAdminMountResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminMountResponse) InlineSize() int {
	return 8
}

type DirectoryAdminMountAndCreateRequest struct {
	_      struct{} `fidl2:"s,32,0"`
	Remote DirectoryInterface
	Name   string `fidl:"255" fidl2:"255"`
	Flags  uint32
}

var _mDirectoryAdminMountAndCreateRequest = _bindings.CreateLazyMarshaler(DirectoryAdminMountAndCreateRequest{})

func (msg *DirectoryAdminMountAndCreateRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminMountAndCreateRequest
}

// Implements Payload.
func (_ *DirectoryAdminMountAndCreateRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminMountAndCreateRequest) InlineSize() int {
	return 32
}

type DirectoryAdminMountAndCreateResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminMountAndCreateResponse = _bindings.CreateLazyMarshaler(DirectoryAdminMountAndCreateResponse{})

func (msg *DirectoryAdminMountAndCreateResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminMountAndCreateResponse
}

// Implements Payload.
func (_ *DirectoryAdminMountAndCreateResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminMountAndCreateResponse) InlineSize() int {
	return 8
}

type DirectoryAdminUnmountRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminUnmountRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountRequest{})

func (msg *DirectoryAdminUnmountRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnmountRequest
}

// Implements Payload.
func (_ *DirectoryAdminUnmountRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnmountRequest) InlineSize() int {
	return 0
}

type DirectoryAdminUnmountResponse struct {
	_ struct{} `fidl2:"s,8,0"`
	S int32
}

var _mDirectoryAdminUnmountResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountResponse{})

func (msg *DirectoryAdminUnmountResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnmountResponse
}

// Implements Payload.
func (_ *DirectoryAdminUnmountResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnmountResponse) InlineSize() int {
	return 8
}

type DirectoryAdminUnmountNodeRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminUnmountNodeRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountNodeRequest{})

func (msg *DirectoryAdminUnmountNodeRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnmountNodeRequest
}

// Implements Payload.
func (_ *DirectoryAdminUnmountNodeRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnmountNodeRequest) InlineSize() int {
	return 0
}

type DirectoryAdminUnmountNodeResponse struct {
	_      struct{} `fidl2:"s,8,0"`
	S      int32
	Remote DirectoryInterface `fidl:"*"`
}

var _mDirectoryAdminUnmountNodeResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountNodeResponse{})

func (msg *DirectoryAdminUnmountNodeResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminUnmountNodeResponse
}

// Implements Payload.
func (_ *DirectoryAdminUnmountNodeResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminUnmountNodeResponse) InlineSize() int {
	return 8
}

type DirectoryAdminQueryFilesystemRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminQueryFilesystemRequest = _bindings.CreateLazyMarshaler(DirectoryAdminQueryFilesystemRequest{})

func (msg *DirectoryAdminQueryFilesystemRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminQueryFilesystemRequest
}

// Implements Payload.
func (_ *DirectoryAdminQueryFilesystemRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminQueryFilesystemRequest) InlineSize() int {
	return 0
}

type DirectoryAdminQueryFilesystemResponse struct {
	_    struct{} `fidl2:"s,16,0"`
	S    int32
	Info *FilesystemInfo
}

var _mDirectoryAdminQueryFilesystemResponse = _bindings.CreateLazyMarshaler(DirectoryAdminQueryFilesystemResponse{})

func (msg *DirectoryAdminQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminQueryFilesystemResponse
}

// Implements Payload.
func (_ *DirectoryAdminQueryFilesystemResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminQueryFilesystemResponse) InlineSize() int {
	return 16
}

type DirectoryAdminGetDevicePathRequest struct {
	_ struct{} `fidl2:"s,0,0"`
}

var _mDirectoryAdminGetDevicePathRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetDevicePathRequest{})

func (msg *DirectoryAdminGetDevicePathRequest) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetDevicePathRequest
}

// Implements Payload.
func (_ *DirectoryAdminGetDevicePathRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetDevicePathRequest) InlineSize() int {
	return 0
}

type DirectoryAdminGetDevicePathResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	S    int32
	Path *string `fidl:"4096" fidl2:"4096"`
}

var _mDirectoryAdminGetDevicePathResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetDevicePathResponse{})

func (msg *DirectoryAdminGetDevicePathResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryAdminGetDevicePathResponse
}

// Implements Payload.
func (_ *DirectoryAdminGetDevicePathResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *DirectoryAdminGetDevicePathResponse) InlineSize() int {
	return 24
}

type DirectoryAdminInterface _bindings.ChannelProxy

func (p *DirectoryAdminInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
	req_ := DirectoryAdminCloneRequest{
		Flags:  flags,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminCloneOrdinal, &req_)
	return err
}

func (p *DirectoryAdminInterface) Close() (int32, error) {
	req_ := DirectoryAdminCloseRequest{}
	resp_ := DirectoryAdminCloseResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminCloseOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Describe() (NodeInfo, error) {
	req_ := DirectoryAdminDescribeRequest{}
	resp_ := DirectoryAdminDescribeResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminDescribeOrdinal, &req_, &resp_)
	return resp_.Info, err
}

func (p *DirectoryAdminInterface) ExpectOnOpen() (int32, *NodeInfo, error) {
	resp_ := DirectoryAdminOnOpenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryAdminOnOpenOrdinal, &resp_)
	return resp_.S, resp_.Info, err
}

func (p *DirectoryAdminInterface) Sync() (int32, error) {
	req_ := DirectoryAdminSyncRequest{}
	resp_ := DirectoryAdminSyncResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSyncOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) GetAttr() (int32, NodeAttributes, error) {
	req_ := DirectoryAdminGetAttrRequest{}
	resp_ := DirectoryAdminGetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetAttrOrdinal, &req_, &resp_)
	return resp_.S, resp_.Attributes, err
}

func (p *DirectoryAdminInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) {
	req_ := DirectoryAdminSetAttrRequest{
		Flags:      flags,
		Attributes: attributes,
	}
	resp_ := DirectoryAdminSetAttrResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSetAttrOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) {
	req_ := DirectoryAdminIoctlRequest{
		Opcode:  opcode,
		MaxOut:  maxOut,
		Handles: handles,
		In:      in,
	}
	resp_ := DirectoryAdminIoctlResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminIoctlOrdinal, &req_, &resp_)
	return resp_.S, resp_.Handles, resp_.Out, err
}

func (p *DirectoryAdminInterface) Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error {
	req_ := DirectoryAdminOpenRequest{
		Flags:  flags,
		Mode:   mode,
		Path:   path,
		Object: object,
	}
	err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOpenOrdinal, &req_)
	return err
}

func (p *DirectoryAdminInterface) Unlink(path string) (int32, error) {
	req_ := DirectoryAdminUnlinkRequest{
		Path: path,
	}
	resp_ := DirectoryAdminUnlinkResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnlinkOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) ReadDirents(maxBytes uint64) (int32, []uint8, error) {
	req_ := DirectoryAdminReadDirentsRequest{
		MaxBytes: maxBytes,
	}
	resp_ := DirectoryAdminReadDirentsResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminReadDirentsOrdinal, &req_, &resp_)
	return resp_.S, resp_.Dirents, err
}

func (p *DirectoryAdminInterface) Rewind() (int32, error) {
	req_ := DirectoryAdminRewindRequest{}
	resp_ := DirectoryAdminRewindResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRewindOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) GetToken() (int32, _zx.Handle, error) {
	req_ := DirectoryAdminGetTokenRequest{}
	resp_ := DirectoryAdminGetTokenResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetTokenOrdinal, &req_, &resp_)
	return resp_.S, resp_.Token, err
}

func (p *DirectoryAdminInterface) Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := DirectoryAdminRenameRequest{
		Src:            src,
		DstParentToken: dstParentToken,
		Dst:            dst,
	}
	resp_ := DirectoryAdminRenameResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRenameOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := DirectoryAdminLinkRequest{
		Src:            src,
		DstParentToken: dstParentToken,
		Dst:            dst,
	}
	resp_ := DirectoryAdminLinkResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminLinkOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) {
	req_ := DirectoryAdminWatchRequest{
		Mask:    mask,
		Options: options,
		Watcher: watcher,
	}
	resp_ := DirectoryAdminWatchResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminWatchOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Mount(remote DirectoryInterface) (int32, error) {
	req_ := DirectoryAdminMountRequest{
		Remote: remote,
	}
	resp_ := DirectoryAdminMountResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) MountAndCreate(remote DirectoryInterface, name string, flags uint32) (int32, error) {
	req_ := DirectoryAdminMountAndCreateRequest{
		Remote: remote,
		Name:   name,
		Flags:  flags,
	}
	resp_ := DirectoryAdminMountAndCreateResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountAndCreateOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) Unmount() (int32, error) {
	req_ := DirectoryAdminUnmountRequest{}
	resp_ := DirectoryAdminUnmountResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountOrdinal, &req_, &resp_)
	return resp_.S, err
}

func (p *DirectoryAdminInterface) UnmountNode() (int32, DirectoryInterface, error) {
	req_ := DirectoryAdminUnmountNodeRequest{}
	resp_ := DirectoryAdminUnmountNodeResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountNodeOrdinal, &req_, &resp_)
	return resp_.S, resp_.Remote, err
}

func (p *DirectoryAdminInterface) QueryFilesystem() (int32, *FilesystemInfo, error) {
	req_ := DirectoryAdminQueryFilesystemRequest{}
	resp_ := DirectoryAdminQueryFilesystemResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminQueryFilesystemOrdinal, &req_, &resp_)
	return resp_.S, resp_.Info, err
}

func (p *DirectoryAdminInterface) GetDevicePath() (int32, *string, error) {
	req_ := DirectoryAdminGetDevicePathRequest{}
	resp_ := DirectoryAdminGetDevicePathResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetDevicePathOrdinal, &req_, &resp_)
	return resp_.S, resp_.Path, err
}

type DirectoryAdmin interface {
	Clone(flags uint32, object NodeInterfaceRequest) error
	Close() (int32, error)
	Describe() (NodeInfo, error)
	Sync() (int32, error)
	GetAttr() (int32, NodeAttributes, error)
	SetAttr(flags uint32, attributes NodeAttributes) (int32, error)
	Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error)
	Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error
	Unlink(path string) (int32, error)
	ReadDirents(maxBytes uint64) (int32, []uint8, error)
	Rewind() (int32, error)
	GetToken() (int32, _zx.Handle, error)
	Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error)
	Link(src string, dstParentToken _zx.Handle, dst string) (int32, error)
	Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error)
	Mount(remote DirectoryInterface) (int32, error)
	MountAndCreate(remote DirectoryInterface, name string, flags uint32) (int32, error)
	Unmount() (int32, error)
	UnmountNode() (int32, DirectoryInterface, error)
	QueryFilesystem() (int32, *FilesystemInfo, error)
	GetDevicePath() (int32, *string, error)
}

type DirectoryAdminTransitionalBase struct{}

type DirectoryAdminInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryAdminInterfaceRequest() (DirectoryAdminInterfaceRequest, *DirectoryAdminInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryAdminInterfaceRequest(req), (*DirectoryAdminInterface)(cli), err
}

type DirectoryAdminStub struct {
	Impl DirectoryAdmin
}

func (s *DirectoryAdminStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case DirectoryAdminCloneOrdinal:
		in_ := DirectoryAdminCloneRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Clone(in_.Flags, in_.Object)
		return nil, err_
	case DirectoryAdminCloseOrdinal:
		in_ := DirectoryAdminCloseRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminCloseResponse{}
		s, err_ := s.Impl.Close()
		out_.S = s
		return &out_, err_
	case DirectoryAdminDescribeOrdinal:
		in_ := DirectoryAdminDescribeRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminDescribeResponse{}
		info, err_ := s.Impl.Describe()
		out_.Info = info
		return &out_, err_
	case DirectoryAdminSyncOrdinal:
		in_ := DirectoryAdminSyncRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminSyncResponse{}
		s, err_ := s.Impl.Sync()
		out_.S = s
		return &out_, err_
	case DirectoryAdminGetAttrOrdinal:
		in_ := DirectoryAdminGetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminGetAttrResponse{}
		s, attributes, err_ := s.Impl.GetAttr()
		out_.S = s
		out_.Attributes = attributes
		return &out_, err_
	case DirectoryAdminSetAttrOrdinal:
		in_ := DirectoryAdminSetAttrRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminSetAttrResponse{}
		s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes)
		out_.S = s
		return &out_, err_
	case DirectoryAdminIoctlOrdinal:
		in_ := DirectoryAdminIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminIoctlResponse{}
		s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In)
		out_.S = s
		out_.Handles = handles
		out_.Out = out
		return &out_, err_
	case DirectoryAdminOpenOrdinal:
		in_ := DirectoryAdminOpenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		err_ := s.Impl.Open(in_.Flags, in_.Mode, in_.Path, in_.Object)
		return nil, err_
	case DirectoryAdminUnlinkOrdinal:
		in_ := DirectoryAdminUnlinkRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminUnlinkResponse{}
		s, err_ := s.Impl.Unlink(in_.Path)
		out_.S = s
		return &out_, err_
	case DirectoryAdminReadDirentsOrdinal:
		in_ := DirectoryAdminReadDirentsRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminReadDirentsResponse{}
		s, dirents, err_ := s.Impl.ReadDirents(in_.MaxBytes)
		out_.S = s
		out_.Dirents = dirents
		return &out_, err_
	case DirectoryAdminRewindOrdinal:
		in_ := DirectoryAdminRewindRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminRewindResponse{}
		s, err_ := s.Impl.Rewind()
		out_.S = s
		return &out_, err_
	case DirectoryAdminGetTokenOrdinal:
		in_ := DirectoryAdminGetTokenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminGetTokenResponse{}
		s, token, err_ := s.Impl.GetToken()
		out_.S = s
		out_.Token = token
		return &out_, err_
	case DirectoryAdminRenameOrdinal:
		in_ := DirectoryAdminRenameRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminRenameResponse{}
		s, err_ := s.Impl.Rename(in_.Src, in_.DstParentToken, in_.Dst)
		out_.S = s
		return &out_, err_
	case DirectoryAdminLinkOrdinal:
		in_ := DirectoryAdminLinkRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminLinkResponse{}
		s, err_ := s.Impl.Link(in_.Src, in_.DstParentToken, in_.Dst)
		out_.S = s
		return &out_, err_
	case DirectoryAdminWatchOrdinal:
		in_ := DirectoryAdminWatchRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminWatchResponse{}
		s, err_ := s.Impl.Watch(in_.Mask, in_.Options, in_.Watcher)
		out_.S = s
		return &out_, err_
	case DirectoryAdminMountOrdinal:
		in_ := DirectoryAdminMountRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminMountResponse{}
		s, err_ := s.Impl.Mount(in_.Remote)
		out_.S = s
		return &out_, err_
	case DirectoryAdminMountAndCreateOrdinal:
		in_ := DirectoryAdminMountAndCreateRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminMountAndCreateResponse{}
		s, err_ := s.Impl.MountAndCreate(in_.Remote, in_.Name, in_.Flags)
		out_.S = s
		return &out_, err_
	case DirectoryAdminUnmountOrdinal:
		in_ := DirectoryAdminUnmountRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminUnmountResponse{}
		s, err_ := s.Impl.Unmount()
		out_.S = s
		return &out_, err_
	case DirectoryAdminUnmountNodeOrdinal:
		in_ := DirectoryAdminUnmountNodeRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminUnmountNodeResponse{}
		s, remote, err_ := s.Impl.UnmountNode()
		out_.S = s
		out_.Remote = remote
		return &out_, err_
	case DirectoryAdminQueryFilesystemOrdinal:
		in_ := DirectoryAdminQueryFilesystemRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminQueryFilesystemResponse{}
		s, info, err_ := s.Impl.QueryFilesystem()
		out_.S = s
		out_.Info = info
		return &out_, err_
	case DirectoryAdminGetDevicePathOrdinal:
		in_ := DirectoryAdminGetDevicePathRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := DirectoryAdminGetDevicePathResponse{}
		s, path, err_ := s.Impl.GetDevicePath()
		out_.S = s
		out_.Path = path
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type DirectoryAdminService struct {
	_bindings.BindingSet
}

func (s *DirectoryAdminService) Add(impl DirectoryAdmin, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&DirectoryAdminStub{Impl: impl}, c, onError)
}

func (s *DirectoryAdminService) EventProxyFor(key _bindings.BindingKey) (*DirectoryAdminEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*DirectoryAdminEventProxy)(pxy), err
}

type DirectoryAdminEventProxy _bindings.ChannelProxy

func (p *DirectoryAdminEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := DirectoryAdminOnOpenResponse{
		S:    s,
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOnOpenOrdinal, &event_)
}