src/syscall/zx/io/impl.go

// 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.
//
// Code generated by third_party/go/regen-fidl; DO NOT EDIT.

package io

import (
	_strings "strings"
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiaunknown "syscall/zx/unknown"
)

const (
	CloseAll InotifyWatchMask = 24
	// Nodes which do not have ino values should return this value
	// from Readdir and GetAttr.
	InoUnknown uint64 = 18446744073709551615
	// The maximal buffer size which can be transmitted for buffered operations.
	// This capacity is currently set somewhat arbitrarily.
	MaxBuf uint64 = 8192
	// The maximum length, in bytes, of a single filesystem component.
	MaxFilename     uint64 = 255
	MaxFsNameBuffer uint64 = 32
	// The maximum length, in bytes, of a single filesystem component.
	MaxNameLength uint64 = 255
	// The maximum length, in bytes, of a filesystem string.
	MaxPath uint64 = 4096
	// The maximum length, in bytes, of a filesystem path.
	MaxPathLength uint64 = 4095
	// The maximum I/O size that is allowed for read/write operations using
	// byte vectors.
	MaxTransferSize uint64 = 8192
	// Bits reserved for posix protections. Native fuchsia filesystems
	// are not required to set bits contained within `MODE_PROTECTION_MASK`,
	// but filesystems that wish to do so may refer to sys/stat.h for their
	// definitions.
	ModeProtectionMask  uint32 = 4095
	ModeTypeBlockDevice uint32 = 24576
	ModeTypeDirectory   uint32 = 16384
	ModeTypeFile        uint32 = 32768
	// Bits indicating node type. The canonical mechanism to check
	// for a node type is to take 'mode', bitwise AND it with the
	// `MODE_TYPE_MASK`, and check exact equality against a mode type.
	ModeTypeMask    uint32           = 1044480
	ModeTypeService uint32           = 65536
	Move            InotifyWatchMask = 192
	// Flags used when opening a node reference must fall within this mask.
	OpenFlagsAllowedWithNodeReference OpenFlags = 46661632
	// All known rights.
	OpenRights OpenFlags = 11
	// Alias for directory permission alias rw*
	RwStarDir Operations = 503
	// Alias for directory permission alias rx*
	RxStarDir Operations = 219
	// Alias for directory permission alias r*
	RStarDir Operations = 211
	// Alias for directory permission alias w*
	WStarDir Operations = 485
	// Alias for directory permission alias x*
	XStarDir Operations = 201
)

var _ _bindings.Enum = AdvisoryLockType(0)

type AdvisoryLockType uint32

const (

	// Zero or more connections can hold read locks on a file simultaneously.
	AdvisoryLockTypeRead AdvisoryLockType = 1

	// At most one connection can hold a write lock on a file simultaneously.
	// When a write lock is held on a file, no other types of locks can be held
	// on that file.
	AdvisoryLockTypeWrite AdvisoryLockType = 2

	// The region specifies a region to be unlocked.
	AdvisoryLockTypeUnlock AdvisoryLockType = 3
)

func (_ AdvisoryLockType) I_EnumValues() []AdvisoryLockType {
	return []AdvisoryLockType{
		AdvisoryLockTypeRead,
		AdvisoryLockTypeWrite,
		AdvisoryLockTypeUnlock,
	}
}

func (_ AdvisoryLockType) I_EnumIsStrict() bool {
	return true
}

func (x AdvisoryLockType) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	}
	return true
}

func (x AdvisoryLockType) String() string {
	switch x {
	case 1:
		return "Read"
	case 2:
		return "Write"
	case 3:
		return "Unlock"
	}
	return "Unknown"
}

var _ _bindings.Enum = DirentType(0)

type DirentType uint8

const (

	// A dirent with an unknown type.
	DirentTypeUnknown DirentType = 0

	// A dirent representing a directory object.
	DirentTypeDirectory DirentType = 4

	// A dirent representing a block device object.
	DirentTypeBlockDevice DirentType = 6

	// A dirent representing a file object.
	DirentTypeFile DirentType = 8

	// A dirent representing a service object.
	DirentTypeService DirentType = 16
)

func (_ DirentType) I_EnumValues() []DirentType {
	return []DirentType{
		DirentTypeUnknown,
		DirentTypeDirectory,
		DirentTypeBlockDevice,
		DirentTypeFile,
		DirentTypeService,
	}
}

func (_ DirentType) I_EnumIsStrict() bool {
	return true
}

func (x DirentType) IsUnknown() bool {
	switch x {
	case 0:
		return false
	case 4:
		return false
	case 6:
		return false
	case 8:
		return false
	case 16:
		return false
	}
	return true
}

func (x DirentType) String() string {
	switch x {
	case 0:
		return "Unknown"
	case 4:
		return "Directory"
	case 6:
		return "BlockDevice"
	case 8:
		return "File"
	case 16:
		return "Service"
	}
	return "Unknown"
}

var _ _bindings.Enum = OpenMode(0)

type OpenMode uint32

const (

	// Only succeed if the object exists.
	OpenModeOpenExisting OpenMode = 1

	// Create the object if it does not exist, otherwise open
	// existing. The check and the creation are performed in
	// one atomic step.
	OpenModeMaybeCreate OpenMode = 2

	// Assert that the object does not exist, then create it.
	// The assertion and creation are performed in one atomic
	// step.
	OpenModeAlwaysCreate OpenMode = 3
)

func (_ OpenMode) I_EnumValues() []OpenMode {
	return []OpenMode{
		OpenModeOpenExisting,
		OpenModeMaybeCreate,
		OpenModeAlwaysCreate,
	}
}

func (_ OpenMode) I_EnumIsStrict() bool {
	return true
}

func (x OpenMode) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	}
	return true
}

func (x OpenMode) String() string {
	switch x {
	case 1:
		return "OpenExisting"
	case 2:
		return "MaybeCreate"
	case 3:
		return "AlwaysCreate"
	}
	return "Unknown"
}

var _ _bindings.Enum = RightsResolution(0)

type RightsResolution uint32

const (

	// The rights will be the intersection between [`RightsRequest.at_most`]
	// and the connection where the `Open`/`Reopen` request was received,
	// closing `object_request` with `ZX_ERR_ACCESS_DENIED` if it is empty.
	RightsResolutionMaximize RightsResolution = 1

	// The rights will be determined by the following rules:
	//
	// * If the negotiated protocol on the new connection is
	//   [`Directory`], the rules from the `MAXIMIZE` case applies.
	// * Otherwise, the rights will be [`RightsRequest.at_least`] if it
	//   does not exceed rights on the current connection.
	// * Otherwise, `object_request` should be closed with
	//   `ZX_ERR_ACCESS_DENIED`.
	//
	// The motivation for this enum is to facilitate implementing POSIX
	// compatibility layers. The POSIX file permission model relies on ambient
	// authority: access control on files are resolved based on the `mode` of
	// the file, and the current user. There is no concept of hierarchical
	// permissions. Fuchsia, on the other hand, restricts rights on file
	// connections to never exceed that of its containing directory connection.
	RightsResolutionPosix RightsResolution = 2
)

func (_ RightsResolution) I_EnumValues() []RightsResolution {
	return []RightsResolution{
		RightsResolutionMaximize,
		RightsResolutionPosix,
	}
}

func (_ RightsResolution) I_EnumIsStrict() bool {
	return true
}

func (x RightsResolution) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	}
	return true
}

func (x RightsResolution) String() string {
	switch x {
	case 1:
		return "Maximize"
	case 2:
		return "Posix"
	}
	return "Unknown"
}

var _ _bindings.Enum = SeekOrigin(0)

// The reference point for updating the seek offset. See [`File.Seek`].
//
// This enum matches the `zx_stream_seek_origin_t` enum.
type SeekOrigin uint32

const (

	// Seek from the start of the file.
	// The seek offset will be set to `offset` bytes.
	// The seek offset cannot be negative in this case.
	SeekOriginStart SeekOrigin = 0

	// Seek from the current position in the file.
	// The seek offset will be the current seek offset plus `offset` bytes.
	SeekOriginCurrent SeekOrigin = 1

	// Seek from the end of the file.
	// The seek offset will be the file size plus `offset` bytes.
	SeekOriginEnd SeekOrigin = 2
)

func (_ SeekOrigin) I_EnumValues() []SeekOrigin {
	return []SeekOrigin{
		SeekOriginStart,
		SeekOriginCurrent,
		SeekOriginEnd,
	}
}

func (_ SeekOrigin) I_EnumIsStrict() bool {
	return true
}

func (x SeekOrigin) IsUnknown() bool {
	switch x {
	case 0:
		return false
	case 1:
		return false
	case 2:
		return false
	}
	return true
}

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

var _ _bindings.Enum = WatchEvent(0)

type WatchEvent uint8

const (

	// Indicates the directory being watched has been deleted.
	WatchEventDeleted WatchEvent = 0

	// Indicates a node has been created (either new or moved) into a directory.
	WatchEventAdded WatchEvent = 1

	// Identifies a node has been removed (either deleted or moved) from the directory.
	WatchEventRemoved WatchEvent = 2

	// Identifies a node already existed in the directory when watching started.
	WatchEventExisting WatchEvent = 3

	// Identifies that no more `EXISTING` events will be sent.
	WatchEventIdle WatchEvent = 4
)

func (_ WatchEvent) I_EnumValues() []WatchEvent {
	return []WatchEvent{
		WatchEventDeleted,
		WatchEventAdded,
		WatchEventRemoved,
		WatchEventExisting,
		WatchEventIdle,
	}
}

func (_ WatchEvent) I_EnumIsStrict() bool {
	return true
}

func (x WatchEvent) IsUnknown() bool {
	switch x {
	case 0:
		return false
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	case 4:
		return false
	}
	return true
}

func (x WatchEvent) String() string {
	switch x {
	case 0:
		return "Deleted"
	case 1:
		return "Added"
	case 2:
		return "Removed"
	case 3:
		return "Existing"
	case 4:
		return "Idle"
	}
	return "Unknown"
}

var _ _bindings.Bits = ConnectorFlags(0)

type ConnectorFlags uint64

const (
	ConnectorFlags_Mask ConnectorFlags = 0
)

func (_ ConnectorFlags) I_BitsMask() ConnectorFlags {
	return ConnectorFlags_Mask
}

func (_ ConnectorFlags) I_BitsIsStrict() bool {
	return false
}

func (x ConnectorFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x ConnectorFlags) GetUnknownBits() uint64 {
	return uint64(^ConnectorFlags_Mask & x)
}

func (x ConnectorFlags) InvertBits() ConnectorFlags {
	return ConnectorFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x ConnectorFlags) HasBits(mask ConnectorFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x ConnectorFlags) ClearBits(mask ConnectorFlags) ConnectorFlags {
	return ^mask & x
}

func (x ConnectorFlags) String() string {
	var buf _strings.Builder
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = FileProtocolFlags(0)

type FileProtocolFlags uint64

const (
	FileProtocolFlagsAppend   FileProtocolFlags = 1
	FileProtocolFlagsTruncate FileProtocolFlags = 2
	FileProtocolFlags_Mask    FileProtocolFlags = 3
)

func (_ FileProtocolFlags) I_BitsMask() FileProtocolFlags {
	return FileProtocolFlags_Mask
}

func (_ FileProtocolFlags) I_BitsIsStrict() bool {
	return false
}

func (x FileProtocolFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x FileProtocolFlags) GetUnknownBits() uint64 {
	return uint64(^FileProtocolFlags_Mask & x)
}

func (x FileProtocolFlags) InvertBits() FileProtocolFlags {
	return FileProtocolFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x FileProtocolFlags) HasBits(mask FileProtocolFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x FileProtocolFlags) ClearBits(mask FileProtocolFlags) FileProtocolFlags {
	return ^mask & x
}

func (x FileProtocolFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Append")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Truncate")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = FileSignal(0)

type FileSignal uint32

const (
	FileSignalReadable FileSignal = 16777216
	FileSignalWritable FileSignal = 33554432
	FileSignal_Mask    FileSignal = 50331648
)

func (_ FileSignal) I_BitsMask() FileSignal {
	return FileSignal_Mask
}

func (_ FileSignal) I_BitsIsStrict() bool {
	return true
}

func (x FileSignal) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x FileSignal) GetUnknownBits() uint64 {
	return uint64(^FileSignal_Mask & x)
}

func (x FileSignal) InvertBits() FileSignal {
	return FileSignal_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x FileSignal) HasBits(mask FileSignal) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x FileSignal) ClearBits(mask FileSignal) FileSignal {
	return ^mask & x
}

func (x FileSignal) String() string {
	var buf _strings.Builder
	if 16777216&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Readable")
	}
	if 33554432&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Writable")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = InotifyWatchMask(0)

// Used by InotifyAddWatch to indicate the server the events to be watched on.
// Also used by [`Node.Inotify`] to indicate the types of events
// that occurred on server side, to be notified to clients. See InotifyEvent.
type InotifyWatchMask uint32

const (
	InotifyWatchMaskAccess       InotifyWatchMask = 1
	InotifyWatchMaskModify       InotifyWatchMask = 2
	InotifyWatchMaskAttrib       InotifyWatchMask = 4
	InotifyWatchMaskCloseWrite   InotifyWatchMask = 8
	InotifyWatchMaskCloseNowrite InotifyWatchMask = 16
	InotifyWatchMaskOpen         InotifyWatchMask = 32
	InotifyWatchMaskMovedFrom    InotifyWatchMask = 64
	InotifyWatchMaskMovedTo      InotifyWatchMask = 128
	InotifyWatchMaskCreate       InotifyWatchMask = 256
	InotifyWatchMaskDelete       InotifyWatchMask = 512
	InotifyWatchMaskDeleteSelf   InotifyWatchMask = 1024
	InotifyWatchMaskMoveSelf     InotifyWatchMask = 2048
	InotifyWatchMaskUnmount      InotifyWatchMask = 8192
	InotifyWatchMaskQOverflow    InotifyWatchMask = 16384
	InotifyWatchMaskIgnored      InotifyWatchMask = 32768
	InotifyWatchMaskOnlydir      InotifyWatchMask = 16777216
	InotifyWatchMaskDontFollow   InotifyWatchMask = 33554432
	InotifyWatchMaskExclUnlink   InotifyWatchMask = 67108864
	InotifyWatchMaskMaskCreate   InotifyWatchMask = 268435456
	InotifyWatchMaskMaskAdd      InotifyWatchMask = 536870912
	InotifyWatchMaskIsdirectory  InotifyWatchMask = 1073741824
	InotifyWatchMaskOneshot      InotifyWatchMask = 2147483648
	InotifyWatchMask_Mask        InotifyWatchMask = 4144033791
)

func (_ InotifyWatchMask) I_BitsMask() InotifyWatchMask {
	return InotifyWatchMask_Mask
}

func (_ InotifyWatchMask) I_BitsIsStrict() bool {
	return true
}

func (x InotifyWatchMask) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x InotifyWatchMask) GetUnknownBits() uint64 {
	return uint64(^InotifyWatchMask_Mask & x)
}

func (x InotifyWatchMask) InvertBits() InotifyWatchMask {
	return InotifyWatchMask_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x InotifyWatchMask) HasBits(mask InotifyWatchMask) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x InotifyWatchMask) ClearBits(mask InotifyWatchMask) InotifyWatchMask {
	return ^mask & x
}

func (x InotifyWatchMask) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Access")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Modify")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Attrib")
	}
	if 8&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CloseWrite")
	}
	if 16&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CloseNowrite")
	}
	if 32&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Open")
	}
	if 64&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MovedFrom")
	}
	if 128&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MovedTo")
	}
	if 256&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Create")
	}
	if 512&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Delete")
	}
	if 1024&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("DeleteSelf")
	}
	if 2048&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MoveSelf")
	}
	if 8192&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Unmount")
	}
	if 16384&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("QOverflow")
	}
	if 32768&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Ignored")
	}
	if 16777216&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Onlydir")
	}
	if 33554432&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("DontFollow")
	}
	if 67108864&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ExclUnlink")
	}
	if 268435456&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MaskCreate")
	}
	if 536870912&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MaskAdd")
	}
	if 1073741824&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Isdirectory")
	}
	if 2147483648&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Oneshot")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = NodeAttributeFlags(0)

// The fields of 'attributes' which are used to update the Node are indicated
// by the 'flags' argument.
type NodeAttributeFlags uint32

const (
	NodeAttributeFlagsCreationTime     NodeAttributeFlags = 1
	NodeAttributeFlagsModificationTime NodeAttributeFlags = 2
	NodeAttributeFlags_Mask            NodeAttributeFlags = 3
)

func (_ NodeAttributeFlags) I_BitsMask() NodeAttributeFlags {
	return NodeAttributeFlags_Mask
}

func (_ NodeAttributeFlags) I_BitsIsStrict() bool {
	return true
}

func (x NodeAttributeFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x NodeAttributeFlags) GetUnknownBits() uint64 {
	return uint64(^NodeAttributeFlags_Mask & x)
}

func (x NodeAttributeFlags) InvertBits() NodeAttributeFlags {
	return NodeAttributeFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x NodeAttributeFlags) HasBits(mask NodeAttributeFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeAttributeFlags) ClearBits(mask NodeAttributeFlags) NodeAttributeFlags {
	return ^mask & x
}

func (x NodeAttributeFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CreationTime")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ModificationTime")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = NodeAttributesQuery(0)

type NodeAttributesQuery uint64

const (
	NodeAttributesQueryProtocols        NodeAttributesQuery = 1
	NodeAttributesQueryAbilities        NodeAttributesQuery = 2
	NodeAttributesQueryContentSize      NodeAttributesQuery = 4
	NodeAttributesQueryStorageSize      NodeAttributesQuery = 8
	NodeAttributesQueryLinkCount        NodeAttributesQuery = 16
	NodeAttributesQueryId               NodeAttributesQuery = 32
	NodeAttributesQueryCreationTime     NodeAttributesQuery = 64
	NodeAttributesQueryModificationTime NodeAttributesQuery = 128
	NodeAttributesQuery_Mask            NodeAttributesQuery = 255
)

func (_ NodeAttributesQuery) I_BitsMask() NodeAttributesQuery {
	return NodeAttributesQuery_Mask
}

func (_ NodeAttributesQuery) I_BitsIsStrict() bool {
	return true
}

func (x NodeAttributesQuery) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x NodeAttributesQuery) GetUnknownBits() uint64 {
	return uint64(^NodeAttributesQuery_Mask & x)
}

func (x NodeAttributesQuery) InvertBits() NodeAttributesQuery {
	return NodeAttributesQuery_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x NodeAttributesQuery) HasBits(mask NodeAttributesQuery) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeAttributesQuery) ClearBits(mask NodeAttributesQuery) NodeAttributesQuery {
	return ^mask & x
}

func (x NodeAttributesQuery) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Protocols")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Abilities")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ContentSize")
	}
	if 8&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("StorageSize")
	}
	if 16&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("LinkCount")
	}
	if 32&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Id")
	}
	if 64&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CreationTime")
	}
	if 128&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ModificationTime")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = NodeFlags(0)

type NodeFlags uint64

const (
	NodeFlagsGetRepresentation NodeFlags = 1
	NodeFlags_Mask             NodeFlags = 1
)

func (_ NodeFlags) I_BitsMask() NodeFlags {
	return NodeFlags_Mask
}

func (_ NodeFlags) I_BitsIsStrict() bool {
	return false
}

func (x NodeFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x NodeFlags) GetUnknownBits() uint64 {
	return uint64(^NodeFlags_Mask & x)
}

func (x NodeFlags) InvertBits() NodeFlags {
	return NodeFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x NodeFlags) HasBits(mask NodeFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeFlags) ClearBits(mask NodeFlags) NodeFlags {
	return ^mask & x
}

func (x NodeFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("GetRepresentation")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = NodeProtocolKinds(0)

// A node may have multiple supported representations when opening, even though
// it may have a fixed underlying identity.
//
// Today, a file is accessed via the [`File`] protocol, and sends a
// [`Representation.FileInfo`] when opened with `GET_REPRESENTATION`. However,
// in the future we might introduce a more sophisticated `FileV2` protocol, or
// a more efficient `SuperFastFile` backed by a specialized kernel object. New
// clients can request the more advanced representations by specifying the
// corresponding bits in [`NodeProtocolKinds`], whereas existing clients would
// continue to talk to the node via the old representation.
//
// [`NodeProtocolKinds`] enables forward-compatibility through a form of protocol
// negotiation.
//
// The elements have one-to-one correspondence with the members of
// [`Representation`].
type NodeProtocolKinds uint64

const (
	NodeProtocolKindsConnector NodeProtocolKinds = 1
	NodeProtocolKindsDirectory NodeProtocolKinds = 2
	NodeProtocolKindsFile      NodeProtocolKinds = 4
	NodeProtocolKinds_Mask     NodeProtocolKinds = 7
)

func (_ NodeProtocolKinds) I_BitsMask() NodeProtocolKinds {
	return NodeProtocolKinds_Mask
}

func (_ NodeProtocolKinds) I_BitsIsStrict() bool {
	return false
}

func (x NodeProtocolKinds) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x NodeProtocolKinds) GetUnknownBits() uint64 {
	return uint64(^NodeProtocolKinds_Mask & x)
}

func (x NodeProtocolKinds) InvertBits() NodeProtocolKinds {
	return NodeProtocolKinds_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x NodeProtocolKinds) HasBits(mask NodeProtocolKinds) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeProtocolKinds) ClearBits(mask NodeProtocolKinds) NodeProtocolKinds {
	return ^mask & x
}

func (x NodeProtocolKinds) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Connector")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Directory")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("File")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = OpenFlags(0)

type OpenFlags uint32

const (
	OpenFlagsRightReadable   OpenFlags = 1
	OpenFlagsRightWritable   OpenFlags = 2
	OpenFlagsRightExecutable OpenFlags = 8
	OpenFlagsCreate          OpenFlags = 65536
	OpenFlagsCreateIfAbsent  OpenFlags = 131072
	OpenFlagsTruncate        OpenFlags = 262144
	OpenFlagsDirectory       OpenFlags = 524288
	OpenFlagsAppend          OpenFlags = 1048576
	OpenFlagsNodeReference   OpenFlags = 4194304
	OpenFlagsDescribe        OpenFlags = 8388608
	OpenFlagsPosixWritable   OpenFlags = 134217728
	OpenFlagsPosixExecutable OpenFlags = 268435456
	OpenFlagsNotDirectory    OpenFlags = 33554432
	OpenFlagsCloneSameRights OpenFlags = 67108864
	OpenFlags_Mask           OpenFlags = 517931019
)

func (_ OpenFlags) I_BitsMask() OpenFlags {
	return OpenFlags_Mask
}

func (_ OpenFlags) I_BitsIsStrict() bool {
	return true
}

func (x OpenFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x OpenFlags) GetUnknownBits() uint64 {
	return uint64(^OpenFlags_Mask & x)
}

func (x OpenFlags) InvertBits() OpenFlags {
	return OpenFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x OpenFlags) HasBits(mask OpenFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x OpenFlags) ClearBits(mask OpenFlags) OpenFlags {
	return ^mask & x
}

func (x OpenFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("RightReadable")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("RightWritable")
	}
	if 8&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("RightExecutable")
	}
	if 65536&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Create")
	}
	if 131072&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CreateIfAbsent")
	}
	if 262144&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Truncate")
	}
	if 524288&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Directory")
	}
	if 1048576&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Append")
	}
	if 4194304&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("NodeReference")
	}
	if 8388608&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Describe")
	}
	if 134217728&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("PosixWritable")
	}
	if 268435456&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("PosixExecutable")
	}
	if 33554432&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("NotDirectory")
	}
	if 67108864&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("CloneSameRights")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = Operations(0)

// The common members definition behind [`Rights`] and [`Abilities`].
// Note that Directory operations are distinct from File operations, with the
// exception of some common operations (e.g. `GET_ATTRIBUTES`) defined on the
// underlying [`Node`].
type Operations uint64

const (
	OperationsConnect          Operations = 1
	OperationsReadBytes        Operations = 2
	OperationsWriteBytes       Operations = 4
	OperationsExecute          Operations = 8
	OperationsGetAttributes    Operations = 16
	OperationsUpdateAttributes Operations = 32
	OperationsEnumerate        Operations = 64
	OperationsTraverse         Operations = 128
	OperationsModifyDirectory  Operations = 256
	Operations_Mask            Operations = 511
)

func (_ Operations) I_BitsMask() Operations {
	return Operations_Mask
}

func (_ Operations) I_BitsIsStrict() bool {
	return true
}

func (x Operations) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x Operations) GetUnknownBits() uint64 {
	return uint64(^Operations_Mask & x)
}

func (x Operations) InvertBits() Operations {
	return Operations_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x Operations) HasBits(mask Operations) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x Operations) ClearBits(mask Operations) Operations {
	return ^mask & x
}

func (x Operations) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Connect")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ReadBytes")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("WriteBytes")
	}
	if 8&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Execute")
	}
	if 16&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("GetAttributes")
	}
	if 32&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("UpdateAttributes")
	}
	if 64&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Enumerate")
	}
	if 128&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Traverse")
	}
	if 256&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("ModifyDirectory")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = UnlinkFlags(0)

type UnlinkFlags uint64

const (
	UnlinkFlagsMustBeDirectory UnlinkFlags = 1
	UnlinkFlags_Mask           UnlinkFlags = 1
)

func (_ UnlinkFlags) I_BitsMask() UnlinkFlags {
	return UnlinkFlags_Mask
}

func (_ UnlinkFlags) I_BitsIsStrict() bool {
	return true
}

func (x UnlinkFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x UnlinkFlags) GetUnknownBits() uint64 {
	return uint64(^UnlinkFlags_Mask & x)
}

func (x UnlinkFlags) InvertBits() UnlinkFlags {
	return UnlinkFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x UnlinkFlags) HasBits(mask UnlinkFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x UnlinkFlags) ClearBits(mask UnlinkFlags) UnlinkFlags {
	return ^mask & x
}

func (x UnlinkFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("MustBeDirectory")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = VmoFlags(0)

type VmoFlags uint32

const (
	VmoFlagsRead         VmoFlags = 1
	VmoFlagsWrite        VmoFlags = 2
	VmoFlagsExecute      VmoFlags = 4
	VmoFlagsPrivateClone VmoFlags = 65536
	VmoFlagsSharedBuffer VmoFlags = 131072
	VmoFlags_Mask        VmoFlags = 196615
)

func (_ VmoFlags) I_BitsMask() VmoFlags {
	return VmoFlags_Mask
}

func (_ VmoFlags) I_BitsIsStrict() bool {
	return true
}

func (x VmoFlags) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x VmoFlags) GetUnknownBits() uint64 {
	return uint64(^VmoFlags_Mask & x)
}

func (x VmoFlags) InvertBits() VmoFlags {
	return VmoFlags_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x VmoFlags) HasBits(mask VmoFlags) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x VmoFlags) ClearBits(mask VmoFlags) VmoFlags {
	return ^mask & x
}

func (x VmoFlags) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Read")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Write")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Execute")
	}
	if 65536&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("PrivateClone")
	}
	if 131072&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("SharedBuffer")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

var _ _bindings.Bits = WatchMask(0)

type WatchMask uint32

const (
	WatchMaskDeleted  WatchMask = 1
	WatchMaskAdded    WatchMask = 2
	WatchMaskRemoved  WatchMask = 4
	WatchMaskExisting WatchMask = 8
	WatchMaskIdle     WatchMask = 16
	WatchMask_Mask    WatchMask = 31
)

func (_ WatchMask) I_BitsMask() WatchMask {
	return WatchMask_Mask
}

func (_ WatchMask) I_BitsIsStrict() bool {
	return true
}

func (x WatchMask) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x WatchMask) GetUnknownBits() uint64 {
	return uint64(^WatchMask_Mask & x)
}

func (x WatchMask) InvertBits() WatchMask {
	return WatchMask_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x WatchMask) HasBits(mask WatchMask) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x WatchMask) ClearBits(mask WatchMask) WatchMask {
	return ^mask & x
}

func (x WatchMask) String() string {
	var buf _strings.Builder
	if 1&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Deleted")
	}
	if 2&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Added")
	}
	if 4&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Removed")
	}
	if 8&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Existing")
	}
	if 16&x != 0 {
		if buf.Len() != 0 {
			buf.WriteRune('|')
		}
		buf.WriteString("Idle")
	}
	if buf.Len() == 0 {
		buf.WriteString("<empty bits>")
	}
	return buf.String()
}

type AdvisoryLockRange struct {
	_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	// The location in the file from which [`offset`] is computed.
	Origin SeekOrigin `fidl_offset_v2:"0"`
	// The start of the byte range, expressed as an offset from [`origin`].
	// Cannot be negative if [`origin`] is [`SeekOrigin.START`].
	Offset int64 `fidl_offset_v2:"8"`
	// The length of the byte range in bytes.
	//
	// If the length is zero, then the byte range extends until the end of the
	// file, regardless of how large the file becomes.
	//
	// If the length is negative, the byte range includes the bytes `offset` +
	// `length` up to, and including, `offset` - 1, provided this range does
	// not extend beyond the beginning of the file.
	Length int64 `fidl_offset_v2:"16"`
}

var _mAdvisoryLockRange = _bindings.CreateLazyMarshaler(AdvisoryLockRange{})

func (msg *AdvisoryLockRange) Marshaler() _bindings.Marshaler {
	return _mAdvisoryLockRange
}

type AdvisoryLockingAdvisoryLockResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mAdvisoryLockingAdvisoryLockResponse = _bindings.CreateLazyMarshaler(AdvisoryLockingAdvisoryLockResponse{})

func (msg *AdvisoryLockingAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
	return _mAdvisoryLockingAdvisoryLockResponse
}

type DatagramSocket struct {
	_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	// See [`fuchsia.posix.socket.DatagramSocket`] for details.
	Socket _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"49166" fidl_bounds:"0"`
	// Size of the buffer used to receive Tx metadata.
	TxMetaBufSize uint64 `fidl_offset_v2:"8"`
	// Size of the buffer used to receive Rx metadata.
	RxMetaBufSize uint64 `fidl_offset_v2:"16"`
}

var _mDatagramSocket = _bindings.CreateLazyMarshaler(DatagramSocket{})

func (msg *DatagramSocket) Marshaler() _bindings.Marshaler {
	return _mDatagramSocket
}

type Directory2RenameResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mDirectory2RenameResponse = _bindings.CreateLazyMarshaler(Directory2RenameResponse{})

func (msg *Directory2RenameResponse) Marshaler() _bindings.Marshaler {
	return _mDirectory2RenameResponse
}

type Directory2UnlinkResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mDirectory2UnlinkResponse = _bindings.CreateLazyMarshaler(Directory2UnlinkResponse{})

func (msg *Directory2UnlinkResponse) Marshaler() _bindings.Marshaler {
	return _mDirectory2UnlinkResponse
}

type DirectoryIteratorGetNextResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Information about an immediate child node of a directory.
	//
	// If a particular attribute is not applicable or not supported,
	// implementations should leave the corresponding field absent.
	Entries []DirectoryEntry `fidl_offset_v2:"0" fidl_bounds:"8192"`
}

var _mDirectoryIteratorGetNextResponse = _bindings.CreateLazyMarshaler(DirectoryIteratorGetNextResponse{})

func (msg *DirectoryIteratorGetNextResponse) Marshaler() _bindings.Marshaler {
	return _mDirectoryIteratorGetNextResponse
}

type DirectoryObject struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mDirectoryObject = _bindings.CreateLazyMarshaler(DirectoryObject{})

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

type DirectoryProtocol struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mDirectoryProtocol = _bindings.CreateLazyMarshaler(DirectoryProtocol{})

func (msg *DirectoryProtocol) Marshaler() _bindings.Marshaler {
	return _mDirectoryProtocol
}

type File2GetBackingMemoryResponse struct {
	_   struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Vmo _zx.VMO  `fidl_offset_v2:"0" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mFile2GetBackingMemoryResponse = _bindings.CreateLazyMarshaler(File2GetBackingMemoryResponse{})

func (msg *File2GetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
	return _mFile2GetBackingMemoryResponse
}

type File2ReadAtResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Data []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
}

var _mFile2ReadAtResponse = _bindings.CreateLazyMarshaler(File2ReadAtResponse{})

func (msg *File2ReadAtResponse) Marshaler() _bindings.Marshaler {
	return _mFile2ReadAtResponse
}

type File2ReadResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Data []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
}

var _mFile2ReadResponse = _bindings.CreateLazyMarshaler(File2ReadResponse{})

func (msg *File2ReadResponse) Marshaler() _bindings.Marshaler {
	return _mFile2ReadResponse
}

type File2ResizeResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mFile2ResizeResponse = _bindings.CreateLazyMarshaler(File2ResizeResponse{})

func (msg *File2ResizeResponse) Marshaler() _bindings.Marshaler {
	return _mFile2ResizeResponse
}

type File2SeekResponse struct {
	_               struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	OffsetFromStart uint64   `fidl_offset_v2:"0"`
}

var _mFile2SeekResponse = _bindings.CreateLazyMarshaler(File2SeekResponse{})

func (msg *File2SeekResponse) Marshaler() _bindings.Marshaler {
	return _mFile2SeekResponse
}

type File2WriteAtResponse struct {
	_           struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ActualCount uint64   `fidl_offset_v2:"0"`
}

var _mFile2WriteAtResponse = _bindings.CreateLazyMarshaler(File2WriteAtResponse{})

func (msg *File2WriteAtResponse) Marshaler() _bindings.Marshaler {
	return _mFile2WriteAtResponse
}

type File2WriteResponse struct {
	_           struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	ActualCount uint64   `fidl_offset_v2:"0"`
}

var _mFile2WriteResponse = _bindings.CreateLazyMarshaler(File2WriteResponse{})

func (msg *File2WriteResponse) Marshaler() _bindings.Marshaler {
	return _mFile2WriteResponse
}

type FileObject struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	// An optional event which transmits information about an object's readability
	// or writability. This event relays information about the underlying object, not
	// the capability granted to client: this event may be signalled "readable" on a
	// connection that does not have the capability to read.
	//
	// The "`FILE_SIGNAL_`" values may be observed on this event.
	Event _zx.Event `fidl_offset_v2:"0" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
	// A placeholder for future stream support.
	//
	// Currently, servers are required not to send a handle in this field.
	Stream _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"31" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}

var _mFileObject = _bindings.CreateLazyMarshaler(FileObject{})

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

type FilesystemInfo struct {
	_ struct{} `fidl:"s" fidl_size_v2:"96" fidl_alignment_v2:"8"`
	// The number of data bytes which may be stored in a filesystem. This does not count
	// metadata or other filesystem overhead like block rounding.
	TotalBytes uint64 `fidl_offset_v2:"0"`
	// The number of data bytes which are in use by the filesystem. This does not count
	// metadata or other filesystem overhead like block rounding.
	UsedBytes uint64 `fidl_offset_v2:"8"`
	// The number of nodes which may be stored in the filesystem.
	TotalNodes uint64 `fidl_offset_v2:"16"`
	// The number of nodes used by the filesystem.
	UsedNodes uint64 `fidl_offset_v2:"24"`
	// The amount of additional space which may be allocated from the underlying volume
	// manager. If unsupported or there is no space for the filesystem to grow, this will
	// be zero.
	FreeSharedPoolBytes uint64 `fidl_offset_v2:"32"`
	// A unique identifier for this filesystem instance. Will not be preserved across
	// reboots.
	//
	// Implementors should create a kernel object (normally an event) and use its koid for
	// the filesystem ID. This koid guarantees uniqueness in the system.
	FsId uint64 `fidl_offset_v2:"40"`
	// The size in bytes of a single filesystem block.
	BlockSize uint32 `fidl_offset_v2:"48"`
	// The maximum length of a filesystem name.
	MaxFilenameSize uint32 `fidl_offset_v2:"52"`
	// A unique identifier for the type of the underlying filesystem.
	FsType  uint32   `fidl_offset_v2:"56"`
	Padding uint32   `fidl_offset_v2:"60"`
	Name    [32]int8 `fidl_offset_v2:"64"`
}

var _mFilesystemInfo = _bindings.CreateLazyMarshaler(FilesystemInfo{})

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

type InotifyEvent struct {
	_               struct{}         `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	WatchDescriptor uint32           `fidl_offset_v2:"0"`
	Mask            InotifyWatchMask `fidl_offset_v2:"4"`
	Cookie          uint32           `fidl_offset_v2:"8"`
	Len             uint32           `fidl_offset_v2:"12"`
	Filename        string           `fidl_offset_v2:"16" fidl_bounds:"4095"`
}

var _mInotifyEvent = _bindings.CreateLazyMarshaler(InotifyEvent{})

func (msg *InotifyEvent) Marshaler() _bindings.Marshaler {
	return _mInotifyEvent
}

type Node2SyncResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mNode2SyncResponse = _bindings.CreateLazyMarshaler(Node2SyncResponse{})

func (msg *Node2SyncResponse) Marshaler() _bindings.Marshaler {
	return _mNode2SyncResponse
}

type Node2UpdateAttributesResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mNode2UpdateAttributesResponse = _bindings.CreateLazyMarshaler(Node2UpdateAttributesResponse{})

func (msg *Node2UpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mNode2UpdateAttributesResponse
}

// NodeAttributes defines generic information about a filesystem node.
type NodeAttributes struct {
	_ struct{} `fidl:"s" fidl_size_v2:"56" fidl_alignment_v2:"8"`
	// Protection bits and node type information describe in 'mode'.
	Mode uint32 `fidl_offset_v2:"0"`
	// A filesystem-unique ID.
	Id uint64 `fidl_offset_v2:"8"`
	// Node size, in bytes.
	ContentSize uint64 `fidl_offset_v2:"16"`
	// Space needed to store node (possibly larger than size), in bytes.
	StorageSize uint64 `fidl_offset_v2:"24"`
	// Hard link count.
	LinkCount uint64 `fidl_offset_v2:"32"`
	// Time of creation (may be updated manually after creation) in ns since Unix epoch, UTC.
	CreationTime uint64 `fidl_offset_v2:"40"`
	// Time of last modification in ns since Unix epoch, UTC.
	ModificationTime uint64 `fidl_offset_v2:"48"`
}

var _mNodeAttributes = _bindings.CreateLazyMarshaler(NodeAttributes{})

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

type NodeAttributes2 struct {
	_                   struct{}                `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	MutableAttributes   MutableNodeAttributes   `fidl_offset_v2:"0"`
	ImmutableAttributes ImmutableNodeAttributes `fidl_offset_v2:"16"`
}

var _mNodeAttributes2 = _bindings.CreateLazyMarshaler(NodeAttributes2{})

func (msg *NodeAttributes2) Marshaler() _bindings.Marshaler {
	return _mNodeAttributes2
}

type PacketSocket struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	// See [`fuchsia.posix.socket.packet.Socket`] for details.
	Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}

var _mPacketSocket = _bindings.CreateLazyMarshaler(PacketSocket{})

func (msg *PacketSocket) Marshaler() _bindings.Marshaler {
	return _mPacketSocket
}

type RawSocket struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	// See [`fuchsia.posix.socket.raw.Socket`] for details.
	Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}

var _mRawSocket = _bindings.CreateLazyMarshaler(RawSocket{})

func (msg *RawSocket) Marshaler() _bindings.Marshaler {
	return _mRawSocket
}

// Options for requesting rights on the new connection.
//
// ## Rights Hierarchy
//
// Respecting principles of least privileges, rights in general must meet
// the following restrictions:
//
// * A connection must have nonzero rights.
// * From the perspective of a client, rights must never increase in a
//   derived connection.
// * From the perspective of a directory proxy, it must ensure that
//   new connections opened through it cannot have more rights than
//   the connection where the proxy received the `Open`/`Reopen` call.
//
// The proper enforcement of the rights hierarchy is a powerful refinement
// over the existing access control facilities offered by directory
// sandboxing.
//
// ## Rights vs Abilities
//
// The rights on a connection limits the set of operations allowed on that
// connection, but does not guarantee their availability, because the
// object may not support it.
//
// See [`Rights`] and [`Abilities`].
//
// ## Implementation Notes
//
// When a directory proxy encounters an absent `rights` field, let `r` be
// the rights on the connection where it received this request, the proxy
// should fill in this field with the following:
//
// ```
// RightsRequest {
//     at_most: r,
//     at_least: 0,
//     resolution: RightsResolution.MAXIMIZE,
// }
// ```
//
// before forwarding the request to the remote party.
//
// Because opening a new connection may involve multiple hops through
// directory proxies, we require the client to set an upper bound and lower
// bound on the rights request, and intermediate proxies to refine these
// bounds.
//
// The rights manipulation should be implemented mechanically
// without knowledge of any specific rights, and servers should propagate
// unknown bits members, to gracefully handle future rights extensions.
//
// ## Implementation Notes
//
// It could be common for a client to request an exact set of rights.
// We recommend client libraries to define a helper function like follows:
//
// ```
// fn Exact(exact_rights: Rights) -> RightsRequest {
//     RightsRequest {
//         at_most: exact_rights,
//         at_least: exact_rights,
//         resolution: RightsResolution.MAXIMIZE,
//     }
// }
// ```
type RightsRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	// Sets an upper bound on the resulting rights. The exact rights will
	// depend on `resolution`.
	//
	// ## Implementation Notes
	//
	// When a directory proxy encounters this variant, it should compute the
	// intersection between this and the rights on the connection where it
	// received the request, to shrink the rights.
	//
	// * If the intersection is empty, or not a superset of `at_least`,
	//   the proxy should close `object_request` with the
	//   `ZX_ERR_ACCESS_DENIED` epitaph.
	// * Otherwise, the proxy should forward the `Open` call as usual,
	//   but update `at_most` with the shrunk rights.
	AtMost Operations `fidl_offset_v2:"0"`
	// Sets a lower bound on the resulting rights. The exact rights will
	// depend on `resolution`.
	//
	// + During [`Directory.Open`], you may only specify the same rights as
	//   what the directory connection already has, or a subset of those.
	// + During [`Node.Reopen`], similarly, you may only specify the same or
	//   a subset of rights possessed by the original connection.
	// + Exceeding those rights causes `object_request` to be closed with a
	//   `ZX_ERR_ACCESS_DENIED` epitaph.
	//
	// Therefore there are these invariants which should be maintained:
	//
	// ```
	// at_most ⊋ {}
	// at_most ⊃ at_least
	// rights_on_connection_where_open_is_received ⊋ {}
	// rights_on_connection_where_open_is_received ⊃ at_least
	// ```
	//
	// using the superset (`⊃`), proper superset (`⊋`),
	// and empty set (`{}`) notations.
	AtLeast Operations `fidl_offset_v2:"8"`
	// When an `Open`/`Reopen` request reaches its final remote server, it should
	// assign rights on the new connection based on one of these modes.
	Resolution RightsResolution `fidl_offset_v2:"16"`
}

var _mRightsRequest = _bindings.CreateLazyMarshaler(RightsRequest{})

func (msg *RightsRequest) Marshaler() _bindings.Marshaler {
	return _mRightsRequest
}

type Service struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mService = _bindings.CreateLazyMarshaler(Service{})

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

type StreamSocket struct {
	_      struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Socket _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"49166" fidl_bounds:"0"`
}

var _mStreamSocket = _bindings.CreateLazyMarshaler(StreamSocket{})

func (msg *StreamSocket) Marshaler() _bindings.Marshaler {
	return _mStreamSocket
}

type SynchronousDatagramSocket struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	// See [`fuchsia.posix.socket.SynchronousDatagramSocket`] for details.
	Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}

var _mSynchronousDatagramSocket = _bindings.CreateLazyMarshaler(SynchronousDatagramSocket{})

func (msg *SynchronousDatagramSocket) Marshaler() _bindings.Marshaler {
	return _mSynchronousDatagramSocket
}

type Tty struct {
	_     struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}

var _mTty = _bindings.CreateLazyMarshaler(Tty{})

func (msg *Tty) Marshaler() _bindings.Marshaler {
	return _mTty
}

type VmofileDeprecated struct {
	_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	// The VMO which backs this file.
	Vmo _zx.VMO `fidl_offset_v2:"0" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	// The index into `vmo` which represents the first byte of the file.
	Offset uint64 `fidl_offset_v2:"8"`
	// The number of bytes, starting at `offset`, which may be used to represent this file.
	Length uint64 `fidl_offset_v2:"16"`
}

var _mVmofileDeprecated = _bindings.CreateLazyMarshaler(VmofileDeprecated{})

func (msg *VmofileDeprecated) Marshaler() _bindings.Marshaler {
	return _mVmofileDeprecated
}

type advisoryLockingWithCtxAdvisoryLockRequest struct {
	_       struct{}            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}

var _madvisoryLockingWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(advisoryLockingWithCtxAdvisoryLockRequest{})

func (msg *advisoryLockingWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
	return _madvisoryLockingWithCtxAdvisoryLockRequest
}

type advisoryLockingWithCtxAdvisoryLockResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}

var _madvisoryLockingWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(advisoryLockingWithCtxAdvisoryLockResponse{})

func (msg *advisoryLockingWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
	return _madvisoryLockingWithCtxAdvisoryLockResponse
}

type directoryWithCtxCloneRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectoryWithCtxCloneRequest = _bindings.CreateLazyMarshaler(directoryWithCtxCloneRequest{})

func (msg *directoryWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxCloneRequest
}

type directoryWithCtxDescribeResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info NodeInfo `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(directoryWithCtxDescribeResponse{})

func (msg *directoryWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxDescribeResponse
}

type directoryWithCtxOnOpenResponse struct {
	_    struct{}  `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32     `fidl_offset_v2:"0"`
	Info *NodeInfo `fidl_offset_v2:"8"`
}

var _mdirectoryWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(directoryWithCtxOnOpenResponse{})

func (msg *directoryWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxOnOpenResponse
}

type directoryWithCtxGetAttrResponse struct {
	_          struct{}       `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32          `fidl_offset_v2:"0"`
	Attributes NodeAttributes `fidl_offset_v2:"8"`
}

var _mdirectoryWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttrResponse{})

func (msg *directoryWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxGetAttrResponse
}

type directoryWithCtxSetAttrRequest struct {
	_          struct{}           `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      NodeAttributeFlags `fidl_offset_v2:"0"`
	Attributes NodeAttributes     `fidl_offset_v2:"8"`
}

var _mdirectoryWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(directoryWithCtxSetAttrRequest{})

func (msg *directoryWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxSetAttrRequest
}

type directoryWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSetAttrResponse{})

func (msg *directoryWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxSetAttrResponse
}

type directoryWithCtxGetFlagsResponse struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32     `fidl_offset_v2:"0"`
	Flags OpenFlags `fidl_offset_v2:"4"`
}

var _mdirectoryWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetFlagsResponse{})

func (msg *directoryWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxGetFlagsResponse
}

type directoryWithCtxSetFlagsRequest struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags OpenFlags `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(directoryWithCtxSetFlagsRequest{})

func (msg *directoryWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxSetFlagsRequest
}

type directoryWithCtxSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSetFlagsResponse{})

func (msg *directoryWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxSetFlagsResponse
}

type directoryWithCtxQueryFilesystemResponse struct {
	_    struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	S    int32           `fidl_offset_v2:"0"`
	Info *FilesystemInfo `fidl_offset_v2:"8"`
}

var _mdirectoryWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(directoryWithCtxQueryFilesystemResponse{})

func (msg *directoryWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxQueryFilesystemResponse
}

type directoryWithCtxOpenRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Mode   uint32                      `fidl_offset_v2:"4"`
	Path   string                      `fidl_offset_v2:"8" fidl_bounds:"4096"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"24" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectoryWithCtxOpenRequest = _bindings.CreateLazyMarshaler(directoryWithCtxOpenRequest{})

func (msg *directoryWithCtxOpenRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxOpenRequest
}

type directoryWithCtxReadDirentsRequest struct {
	_        struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	MaxBytes uint64   `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxReadDirentsRequest = _bindings.CreateLazyMarshaler(directoryWithCtxReadDirentsRequest{})

func (msg *directoryWithCtxReadDirentsRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxReadDirentsRequest
}

type directoryWithCtxReadDirentsResponse struct {
	_       struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S       int32    `fidl_offset_v2:"0"`
	Dirents []uint8  `fidl_offset_v2:"8" fidl_bounds:"8192"`
}

var _mdirectoryWithCtxReadDirentsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxReadDirentsResponse{})

func (msg *directoryWithCtxReadDirentsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxReadDirentsResponse
}

type directoryWithCtxRewindResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxRewindResponse = _bindings.CreateLazyMarshaler(directoryWithCtxRewindResponse{})

func (msg *directoryWithCtxRewindResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxRewindResponse
}

type directoryWithCtxGetTokenResponse struct {
	_     struct{}   `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32      `fidl_offset_v2:"0"`
	Token _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}

var _mdirectoryWithCtxGetTokenResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetTokenResponse{})

func (msg *directoryWithCtxGetTokenResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxGetTokenResponse
}

type directoryWithCtxLinkRequest struct {
	_              struct{}   `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	Src            string     `fidl_offset_v2:"0" fidl_bounds:"255"`
	DstParentToken _zx.Handle `fidl_offset_v2:"16" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	Dst            string     `fidl_offset_v2:"24" fidl_bounds:"255"`
}

var _mdirectoryWithCtxLinkRequest = _bindings.CreateLazyMarshaler(directoryWithCtxLinkRequest{})

func (msg *directoryWithCtxLinkRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxLinkRequest
}

type directoryWithCtxLinkResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxLinkResponse = _bindings.CreateLazyMarshaler(directoryWithCtxLinkResponse{})

func (msg *directoryWithCtxLinkResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxLinkResponse
}

type directoryWithCtxWatchRequest struct {
	_       struct{}                                `fidl:"s" fidl_size_v2:"12" fidl_alignment_v2:"4"`
	Mask    WatchMask                               `fidl_offset_v2:"0"`
	Options uint32                                  `fidl_offset_v2:"4"`
	Watcher DirectoryWatcherWithCtxInterfaceRequest `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectoryWithCtxWatchRequest = _bindings.CreateLazyMarshaler(directoryWithCtxWatchRequest{})

func (msg *directoryWithCtxWatchRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxWatchRequest
}

type directoryWithCtxWatchResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxWatchResponse = _bindings.CreateLazyMarshaler(directoryWithCtxWatchResponse{})

func (msg *directoryWithCtxWatchResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxWatchResponse
}

type directoryWithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxCloseResponse = _bindings.CreateLazyMarshaler(directoryWithCtxCloseResponse{})

func (msg *directoryWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxCloseResponse
}

type directoryWithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxQueryResponse = _bindings.CreateLazyMarshaler(directoryWithCtxQueryResponse{})

func (msg *directoryWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxQueryResponse
}

type directoryWithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectoryWithCtxReopenRequest = _bindings.CreateLazyMarshaler(directoryWithCtxReopenRequest{})

func (msg *directoryWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxReopenRequest
}

type directoryWithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(directoryWithCtxOnRepresentationResponse{})

func (msg *directoryWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxOnRepresentationResponse
}

type directoryWithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttributesRequest{})

func (msg *directoryWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxGetAttributesRequest
}

type directoryWithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttributesResponse{})

func (msg *directoryWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxGetAttributesResponse
}

type directoryWithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(directoryWithCtxUpdateAttributesResponse{})

func (msg *directoryWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxUpdateAttributesResponse
}

type directoryWithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxSyncResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSyncResponse{})

func (msg *directoryWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxSyncResponse
}

type directoryWithCtxAdvisoryLockRequest struct {
	_       struct{}            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(directoryWithCtxAdvisoryLockRequest{})

func (msg *directoryWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxAdvisoryLockRequest
}

type directoryWithCtxAdvisoryLockResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(directoryWithCtxAdvisoryLockResponse{})

func (msg *directoryWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxAdvisoryLockResponse
}

type directoryWithCtxOpen2Request struct {
	_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	// Identifies the node to open.
	//
	// If it contains multiple segments, then the directory is traversed,
	// one segment at a time, relative to the directory represented by this
	// connection.
	Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
	// The representations accepted by the caller to support a form of
	// protocol negotiation on the node being opened.
	Protocols ConnectionProtocols `fidl_offset_v2:"16"`
	// The server end of a channel created for the new connection. The
	// caller may proceed to send messages on the corresponding client end
	// right away.
	ObjectRequest _zx.Channel `fidl_offset_v2:"32" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectoryWithCtxOpen2Request = _bindings.CreateLazyMarshaler(directoryWithCtxOpen2Request{})

func (msg *directoryWithCtxOpen2Request) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxOpen2Request
}

type directoryWithCtxAddInotifyFilterRequest struct {
	_               struct{}         `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Path            string           `fidl_offset_v2:"0" fidl_bounds:"4095"`
	Filter          InotifyWatchMask `fidl_offset_v2:"16"`
	WatchDescriptor uint32           `fidl_offset_v2:"20"`
	Socket          _zx.Socket       `fidl_offset_v2:"24" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectoryWithCtxAddInotifyFilterRequest = _bindings.CreateLazyMarshaler(directoryWithCtxAddInotifyFilterRequest{})

func (msg *directoryWithCtxAddInotifyFilterRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxAddInotifyFilterRequest
}

type directoryWithCtxUnlinkRequest struct {
	_       struct{}      `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Name    string        `fidl_offset_v2:"0" fidl_bounds:"255"`
	Options UnlinkOptions `fidl_offset_v2:"16"`
}

var _mdirectoryWithCtxUnlinkRequest = _bindings.CreateLazyMarshaler(directoryWithCtxUnlinkRequest{})

func (msg *directoryWithCtxUnlinkRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxUnlinkRequest
}

type directoryWithCtxUnlinkResponse struct {
	_      struct{}               `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Directory2UnlinkResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxUnlinkResponse = _bindings.CreateLazyMarshaler(directoryWithCtxUnlinkResponse{})

func (msg *directoryWithCtxUnlinkResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxUnlinkResponse
}

type directoryWithCtxEnumerateRequest struct {
	_        struct{}                                 `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Options  DirectoryEnumerateOptions                `fidl_offset_v2:"0"`
	Iterator DirectoryIteratorWithCtxInterfaceRequest `fidl_offset_v2:"16" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectoryWithCtxEnumerateRequest = _bindings.CreateLazyMarshaler(directoryWithCtxEnumerateRequest{})

func (msg *directoryWithCtxEnumerateRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxEnumerateRequest
}

type directoryWithCtxRenameRequest struct {
	_              struct{}  `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	Src            string    `fidl_offset_v2:"0" fidl_bounds:"255"`
	DstParentToken _zx.Event `fidl_offset_v2:"16" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	Dst            string    `fidl_offset_v2:"24" fidl_bounds:"255"`
}

var _mdirectoryWithCtxRenameRequest = _bindings.CreateLazyMarshaler(directoryWithCtxRenameRequest{})

func (msg *directoryWithCtxRenameRequest) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxRenameRequest
}

type directoryWithCtxRenameResponse struct {
	_      struct{}               `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Directory2RenameResult `fidl_offset_v2:"0"`
}

var _mdirectoryWithCtxRenameResponse = _bindings.CreateLazyMarshaler(directoryWithCtxRenameResponse{})

func (msg *directoryWithCtxRenameResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryWithCtxRenameResponse
}

type directory1WithCtxCloneRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectory1WithCtxCloneRequest = _bindings.CreateLazyMarshaler(directory1WithCtxCloneRequest{})

func (msg *directory1WithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxCloneRequest
}

type directory1WithCtxDescribeResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info NodeInfo `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxDescribeResponse = _bindings.CreateLazyMarshaler(directory1WithCtxDescribeResponse{})

func (msg *directory1WithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxDescribeResponse
}

type directory1WithCtxOnOpenResponse struct {
	_    struct{}  `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32     `fidl_offset_v2:"0"`
	Info *NodeInfo `fidl_offset_v2:"8"`
}

var _mdirectory1WithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(directory1WithCtxOnOpenResponse{})

func (msg *directory1WithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxOnOpenResponse
}

type directory1WithCtxGetAttrResponse struct {
	_          struct{}       `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32          `fidl_offset_v2:"0"`
	Attributes NodeAttributes `fidl_offset_v2:"8"`
}

var _mdirectory1WithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetAttrResponse{})

func (msg *directory1WithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxGetAttrResponse
}

type directory1WithCtxSetAttrRequest struct {
	_          struct{}           `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      NodeAttributeFlags `fidl_offset_v2:"0"`
	Attributes NodeAttributes     `fidl_offset_v2:"8"`
}

var _mdirectory1WithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(directory1WithCtxSetAttrRequest{})

func (msg *directory1WithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxSetAttrRequest
}

type directory1WithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(directory1WithCtxSetAttrResponse{})

func (msg *directory1WithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxSetAttrResponse
}

type directory1WithCtxGetFlagsResponse struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32     `fidl_offset_v2:"0"`
	Flags OpenFlags `fidl_offset_v2:"4"`
}

var _mdirectory1WithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetFlagsResponse{})

func (msg *directory1WithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxGetFlagsResponse
}

type directory1WithCtxSetFlagsRequest struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags OpenFlags `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(directory1WithCtxSetFlagsRequest{})

func (msg *directory1WithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxSetFlagsRequest
}

type directory1WithCtxSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxSetFlagsResponse{})

func (msg *directory1WithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxSetFlagsResponse
}

type directory1WithCtxQueryFilesystemResponse struct {
	_    struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	S    int32           `fidl_offset_v2:"0"`
	Info *FilesystemInfo `fidl_offset_v2:"8"`
}

var _mdirectory1WithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(directory1WithCtxQueryFilesystemResponse{})

func (msg *directory1WithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxQueryFilesystemResponse
}

type directory1WithCtxOpenRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Mode   uint32                      `fidl_offset_v2:"4"`
	Path   string                      `fidl_offset_v2:"8" fidl_bounds:"4096"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"24" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectory1WithCtxOpenRequest = _bindings.CreateLazyMarshaler(directory1WithCtxOpenRequest{})

func (msg *directory1WithCtxOpenRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxOpenRequest
}

type directory1WithCtxReadDirentsRequest struct {
	_        struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	MaxBytes uint64   `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxReadDirentsRequest = _bindings.CreateLazyMarshaler(directory1WithCtxReadDirentsRequest{})

func (msg *directory1WithCtxReadDirentsRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxReadDirentsRequest
}

type directory1WithCtxReadDirentsResponse struct {
	_       struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S       int32    `fidl_offset_v2:"0"`
	Dirents []uint8  `fidl_offset_v2:"8" fidl_bounds:"8192"`
}

var _mdirectory1WithCtxReadDirentsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxReadDirentsResponse{})

func (msg *directory1WithCtxReadDirentsResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxReadDirentsResponse
}

type directory1WithCtxRewindResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxRewindResponse = _bindings.CreateLazyMarshaler(directory1WithCtxRewindResponse{})

func (msg *directory1WithCtxRewindResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxRewindResponse
}

type directory1WithCtxGetTokenResponse struct {
	_     struct{}   `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32      `fidl_offset_v2:"0"`
	Token _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}

var _mdirectory1WithCtxGetTokenResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetTokenResponse{})

func (msg *directory1WithCtxGetTokenResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxGetTokenResponse
}

type directory1WithCtxLinkRequest struct {
	_              struct{}   `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	Src            string     `fidl_offset_v2:"0" fidl_bounds:"255"`
	DstParentToken _zx.Handle `fidl_offset_v2:"16" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	Dst            string     `fidl_offset_v2:"24" fidl_bounds:"255"`
}

var _mdirectory1WithCtxLinkRequest = _bindings.CreateLazyMarshaler(directory1WithCtxLinkRequest{})

func (msg *directory1WithCtxLinkRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxLinkRequest
}

type directory1WithCtxLinkResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxLinkResponse = _bindings.CreateLazyMarshaler(directory1WithCtxLinkResponse{})

func (msg *directory1WithCtxLinkResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxLinkResponse
}

type directory1WithCtxWatchRequest struct {
	_       struct{}                                `fidl:"s" fidl_size_v2:"12" fidl_alignment_v2:"4"`
	Mask    WatchMask                               `fidl_offset_v2:"0"`
	Options uint32                                  `fidl_offset_v2:"4"`
	Watcher DirectoryWatcherWithCtxInterfaceRequest `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectory1WithCtxWatchRequest = _bindings.CreateLazyMarshaler(directory1WithCtxWatchRequest{})

func (msg *directory1WithCtxWatchRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxWatchRequest
}

type directory1WithCtxWatchResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mdirectory1WithCtxWatchResponse = _bindings.CreateLazyMarshaler(directory1WithCtxWatchResponse{})

func (msg *directory1WithCtxWatchResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory1WithCtxWatchResponse
}

type directory2WithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(directory2WithCtxCloseResponse{})

func (msg *directory2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxCloseResponse
}

type directory2WithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(directory2WithCtxQueryResponse{})

func (msg *directory2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxQueryResponse
}

type directory2WithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectory2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(directory2WithCtxReopenRequest{})

func (msg *directory2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxReopenRequest
}

type directory2WithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(directory2WithCtxOnRepresentationResponse{})

func (msg *directory2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxOnRepresentationResponse
}

type directory2WithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(directory2WithCtxGetAttributesRequest{})

func (msg *directory2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxGetAttributesRequest
}

type directory2WithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(directory2WithCtxGetAttributesResponse{})

func (msg *directory2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxGetAttributesResponse
}

type directory2WithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(directory2WithCtxUpdateAttributesResponse{})

func (msg *directory2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxUpdateAttributesResponse
}

type directory2WithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(directory2WithCtxSyncResponse{})

func (msg *directory2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxSyncResponse
}

type directory2WithCtxAdvisoryLockRequest struct {
	_       struct{}            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(directory2WithCtxAdvisoryLockRequest{})

func (msg *directory2WithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxAdvisoryLockRequest
}

type directory2WithCtxAdvisoryLockResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(directory2WithCtxAdvisoryLockResponse{})

func (msg *directory2WithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxAdvisoryLockResponse
}

type directory2WithCtxOpen2Request struct {
	_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	// Identifies the node to open.
	//
	// If it contains multiple segments, then the directory is traversed,
	// one segment at a time, relative to the directory represented by this
	// connection.
	Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
	// The representations accepted by the caller to support a form of
	// protocol negotiation on the node being opened.
	Protocols ConnectionProtocols `fidl_offset_v2:"16"`
	// The server end of a channel created for the new connection. The
	// caller may proceed to send messages on the corresponding client end
	// right away.
	ObjectRequest _zx.Channel `fidl_offset_v2:"32" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectory2WithCtxOpen2Request = _bindings.CreateLazyMarshaler(directory2WithCtxOpen2Request{})

func (msg *directory2WithCtxOpen2Request) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxOpen2Request
}

type directory2WithCtxAddInotifyFilterRequest struct {
	_               struct{}         `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Path            string           `fidl_offset_v2:"0" fidl_bounds:"4095"`
	Filter          InotifyWatchMask `fidl_offset_v2:"16"`
	WatchDescriptor uint32           `fidl_offset_v2:"20"`
	Socket          _zx.Socket       `fidl_offset_v2:"24" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mdirectory2WithCtxAddInotifyFilterRequest = _bindings.CreateLazyMarshaler(directory2WithCtxAddInotifyFilterRequest{})

func (msg *directory2WithCtxAddInotifyFilterRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxAddInotifyFilterRequest
}

type directory2WithCtxUnlinkRequest struct {
	_       struct{}      `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Name    string        `fidl_offset_v2:"0" fidl_bounds:"255"`
	Options UnlinkOptions `fidl_offset_v2:"16"`
}

var _mdirectory2WithCtxUnlinkRequest = _bindings.CreateLazyMarshaler(directory2WithCtxUnlinkRequest{})

func (msg *directory2WithCtxUnlinkRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxUnlinkRequest
}

type directory2WithCtxUnlinkResponse struct {
	_      struct{}               `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Directory2UnlinkResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxUnlinkResponse = _bindings.CreateLazyMarshaler(directory2WithCtxUnlinkResponse{})

func (msg *directory2WithCtxUnlinkResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxUnlinkResponse
}

type directory2WithCtxEnumerateRequest struct {
	_        struct{}                                 `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Options  DirectoryEnumerateOptions                `fidl_offset_v2:"0"`
	Iterator DirectoryIteratorWithCtxInterfaceRequest `fidl_offset_v2:"16" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mdirectory2WithCtxEnumerateRequest = _bindings.CreateLazyMarshaler(directory2WithCtxEnumerateRequest{})

func (msg *directory2WithCtxEnumerateRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxEnumerateRequest
}

type directory2WithCtxRenameRequest struct {
	_              struct{}  `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	Src            string    `fidl_offset_v2:"0" fidl_bounds:"255"`
	DstParentToken _zx.Event `fidl_offset_v2:"16" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	Dst            string    `fidl_offset_v2:"24" fidl_bounds:"255"`
}

var _mdirectory2WithCtxRenameRequest = _bindings.CreateLazyMarshaler(directory2WithCtxRenameRequest{})

func (msg *directory2WithCtxRenameRequest) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxRenameRequest
}

type directory2WithCtxRenameResponse struct {
	_      struct{}               `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Directory2RenameResult `fidl_offset_v2:"0"`
}

var _mdirectory2WithCtxRenameResponse = _bindings.CreateLazyMarshaler(directory2WithCtxRenameResponse{})

func (msg *directory2WithCtxRenameResponse) Marshaler() _bindings.Marshaler {
	return _mdirectory2WithCtxRenameResponse
}

type directoryIteratorWithCtxGetNextResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result DirectoryIteratorGetNextResult `fidl_offset_v2:"0"`
}

var _mdirectoryIteratorWithCtxGetNextResponse = _bindings.CreateLazyMarshaler(directoryIteratorWithCtxGetNextResponse{})

func (msg *directoryIteratorWithCtxGetNextResponse) Marshaler() _bindings.Marshaler {
	return _mdirectoryIteratorWithCtxGetNextResponse
}

type fileWithCtxAdvisoryLockRequest struct {
	_       struct{}            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}

var _mfileWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(fileWithCtxAdvisoryLockRequest{})

func (msg *fileWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxAdvisoryLockRequest
}

type fileWithCtxAdvisoryLockResponse struct {
	_      struct{}                          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(fileWithCtxAdvisoryLockResponse{})

func (msg *fileWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxAdvisoryLockResponse
}

type fileWithCtxCloneRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mfileWithCtxCloneRequest = _bindings.CreateLazyMarshaler(fileWithCtxCloneRequest{})

func (msg *fileWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxCloneRequest
}

type fileWithCtxDescribeResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info NodeInfo `fidl_offset_v2:"0"`
}

var _mfileWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(fileWithCtxDescribeResponse{})

func (msg *fileWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxDescribeResponse
}

type fileWithCtxOnOpenResponse struct {
	_    struct{}  `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32     `fidl_offset_v2:"0"`
	Info *NodeInfo `fidl_offset_v2:"8"`
}

var _mfileWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(fileWithCtxOnOpenResponse{})

func (msg *fileWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxOnOpenResponse
}

type fileWithCtxGetAttrResponse struct {
	_          struct{}       `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32          `fidl_offset_v2:"0"`
	Attributes NodeAttributes `fidl_offset_v2:"8"`
}

var _mfileWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetAttrResponse{})

func (msg *fileWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetAttrResponse
}

type fileWithCtxSetAttrRequest struct {
	_          struct{}           `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      NodeAttributeFlags `fidl_offset_v2:"0"`
	Attributes NodeAttributes     `fidl_offset_v2:"8"`
}

var _mfileWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(fileWithCtxSetAttrRequest{})

func (msg *fileWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSetAttrRequest
}

type fileWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mfileWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(fileWithCtxSetAttrResponse{})

func (msg *fileWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSetAttrResponse
}

type fileWithCtxGetFlagsResponse struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32     `fidl_offset_v2:"0"`
	Flags OpenFlags `fidl_offset_v2:"4"`
}

var _mfileWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetFlagsResponse{})

func (msg *fileWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetFlagsResponse
}

type fileWithCtxSetFlagsRequest struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags OpenFlags `fidl_offset_v2:"0"`
}

var _mfileWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(fileWithCtxSetFlagsRequest{})

func (msg *fileWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSetFlagsRequest
}

type fileWithCtxSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mfileWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(fileWithCtxSetFlagsResponse{})

func (msg *fileWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSetFlagsResponse
}

type fileWithCtxQueryFilesystemResponse struct {
	_    struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	S    int32           `fidl_offset_v2:"0"`
	Info *FilesystemInfo `fidl_offset_v2:"8"`
}

var _mfileWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(fileWithCtxQueryFilesystemResponse{})

func (msg *fileWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxQueryFilesystemResponse
}

type fileWithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxCloseResponse = _bindings.CreateLazyMarshaler(fileWithCtxCloseResponse{})

func (msg *fileWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxCloseResponse
}

type fileWithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mfileWithCtxQueryResponse = _bindings.CreateLazyMarshaler(fileWithCtxQueryResponse{})

func (msg *fileWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxQueryResponse
}

type fileWithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mfileWithCtxReopenRequest = _bindings.CreateLazyMarshaler(fileWithCtxReopenRequest{})

func (msg *fileWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxReopenRequest
}

type fileWithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mfileWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(fileWithCtxOnRepresentationResponse{})

func (msg *fileWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxOnRepresentationResponse
}

type fileWithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mfileWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(fileWithCtxGetAttributesRequest{})

func (msg *fileWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetAttributesRequest
}

type fileWithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetAttributesResponse{})

func (msg *fileWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetAttributesResponse
}

type fileWithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(fileWithCtxUpdateAttributesResponse{})

func (msg *fileWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxUpdateAttributesResponse
}

type fileWithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxSyncResponse = _bindings.CreateLazyMarshaler(fileWithCtxSyncResponse{})

func (msg *fileWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSyncResponse
}

type fileWithCtxSeekRequest struct {
	_      struct{}   `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Origin SeekOrigin `fidl_offset_v2:"0"`
	Offset int64      `fidl_offset_v2:"8"`
}

var _mfileWithCtxSeekRequest = _bindings.CreateLazyMarshaler(fileWithCtxSeekRequest{})

func (msg *fileWithCtxSeekRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSeekRequest
}

type fileWithCtxSeekResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2SeekResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxSeekResponse = _bindings.CreateLazyMarshaler(fileWithCtxSeekResponse{})

func (msg *fileWithCtxSeekResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxSeekResponse
}

type fileWithCtxReadRequest struct {
	_     struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Count uint64   `fidl_offset_v2:"0"`
}

var _mfileWithCtxReadRequest = _bindings.CreateLazyMarshaler(fileWithCtxReadRequest{})

func (msg *fileWithCtxReadRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxReadRequest
}

type fileWithCtxReadResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ReadResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxReadResponse = _bindings.CreateLazyMarshaler(fileWithCtxReadResponse{})

func (msg *fileWithCtxReadResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxReadResponse
}

type fileWithCtxWriteRequest struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Data []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
}

var _mfileWithCtxWriteRequest = _bindings.CreateLazyMarshaler(fileWithCtxWriteRequest{})

func (msg *fileWithCtxWriteRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxWriteRequest
}

type fileWithCtxWriteResponse struct {
	_      struct{}         `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2WriteResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxWriteResponse = _bindings.CreateLazyMarshaler(fileWithCtxWriteResponse{})

func (msg *fileWithCtxWriteResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxWriteResponse
}

type fileWithCtxReadAtRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Count  uint64   `fidl_offset_v2:"0"`
	Offset uint64   `fidl_offset_v2:"8"`
}

var _mfileWithCtxReadAtRequest = _bindings.CreateLazyMarshaler(fileWithCtxReadAtRequest{})

func (msg *fileWithCtxReadAtRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxReadAtRequest
}

type fileWithCtxReadAtResponse struct {
	_      struct{}          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ReadAtResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxReadAtResponse = _bindings.CreateLazyMarshaler(fileWithCtxReadAtResponse{})

func (msg *fileWithCtxReadAtResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxReadAtResponse
}

type fileWithCtxWriteAtRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Data   []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
	Offset uint64   `fidl_offset_v2:"16"`
}

var _mfileWithCtxWriteAtRequest = _bindings.CreateLazyMarshaler(fileWithCtxWriteAtRequest{})

func (msg *fileWithCtxWriteAtRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxWriteAtRequest
}

type fileWithCtxWriteAtResponse struct {
	_      struct{}           `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2WriteAtResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxWriteAtResponse = _bindings.CreateLazyMarshaler(fileWithCtxWriteAtResponse{})

func (msg *fileWithCtxWriteAtResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxWriteAtResponse
}

type fileWithCtxResizeRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Length uint64   `fidl_offset_v2:"0"`
}

var _mfileWithCtxResizeRequest = _bindings.CreateLazyMarshaler(fileWithCtxResizeRequest{})

func (msg *fileWithCtxResizeRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxResizeRequest
}

type fileWithCtxResizeResponse struct {
	_      struct{}          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ResizeResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxResizeResponse = _bindings.CreateLazyMarshaler(fileWithCtxResizeResponse{})

func (msg *fileWithCtxResizeResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxResizeResponse
}

type fileWithCtxGetBackingMemoryRequest struct {
	_     struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags VmoFlags `fidl_offset_v2:"0"`
}

var _mfileWithCtxGetBackingMemoryRequest = _bindings.CreateLazyMarshaler(fileWithCtxGetBackingMemoryRequest{})

func (msg *fileWithCtxGetBackingMemoryRequest) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetBackingMemoryRequest
}

type fileWithCtxGetBackingMemoryResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2GetBackingMemoryResult `fidl_offset_v2:"0"`
}

var _mfileWithCtxGetBackingMemoryResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetBackingMemoryResponse{})

func (msg *fileWithCtxGetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
	return _mfileWithCtxGetBackingMemoryResponse
}

type file2WithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(file2WithCtxCloseResponse{})

func (msg *file2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxCloseResponse
}

type file2WithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mfile2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(file2WithCtxQueryResponse{})

func (msg *file2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxQueryResponse
}

type file2WithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mfile2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(file2WithCtxReopenRequest{})

func (msg *file2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxReopenRequest
}

type file2WithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mfile2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(file2WithCtxOnRepresentationResponse{})

func (msg *file2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxOnRepresentationResponse
}

type file2WithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mfile2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(file2WithCtxGetAttributesRequest{})

func (msg *file2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxGetAttributesRequest
}

type file2WithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(file2WithCtxGetAttributesResponse{})

func (msg *file2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxGetAttributesResponse
}

type file2WithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(file2WithCtxUpdateAttributesResponse{})

func (msg *file2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxUpdateAttributesResponse
}

type file2WithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(file2WithCtxSyncResponse{})

func (msg *file2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxSyncResponse
}

type file2WithCtxSeekRequest struct {
	_      struct{}   `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Origin SeekOrigin `fidl_offset_v2:"0"`
	Offset int64      `fidl_offset_v2:"8"`
}

var _mfile2WithCtxSeekRequest = _bindings.CreateLazyMarshaler(file2WithCtxSeekRequest{})

func (msg *file2WithCtxSeekRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxSeekRequest
}

type file2WithCtxSeekResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2SeekResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxSeekResponse = _bindings.CreateLazyMarshaler(file2WithCtxSeekResponse{})

func (msg *file2WithCtxSeekResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxSeekResponse
}

type file2WithCtxReadRequest struct {
	_     struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Count uint64   `fidl_offset_v2:"0"`
}

var _mfile2WithCtxReadRequest = _bindings.CreateLazyMarshaler(file2WithCtxReadRequest{})

func (msg *file2WithCtxReadRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxReadRequest
}

type file2WithCtxReadResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ReadResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxReadResponse = _bindings.CreateLazyMarshaler(file2WithCtxReadResponse{})

func (msg *file2WithCtxReadResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxReadResponse
}

type file2WithCtxWriteRequest struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Data []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
}

var _mfile2WithCtxWriteRequest = _bindings.CreateLazyMarshaler(file2WithCtxWriteRequest{})

func (msg *file2WithCtxWriteRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxWriteRequest
}

type file2WithCtxWriteResponse struct {
	_      struct{}         `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2WriteResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxWriteResponse = _bindings.CreateLazyMarshaler(file2WithCtxWriteResponse{})

func (msg *file2WithCtxWriteResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxWriteResponse
}

type file2WithCtxReadAtRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Count  uint64   `fidl_offset_v2:"0"`
	Offset uint64   `fidl_offset_v2:"8"`
}

var _mfile2WithCtxReadAtRequest = _bindings.CreateLazyMarshaler(file2WithCtxReadAtRequest{})

func (msg *file2WithCtxReadAtRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxReadAtRequest
}

type file2WithCtxReadAtResponse struct {
	_      struct{}          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ReadAtResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxReadAtResponse = _bindings.CreateLazyMarshaler(file2WithCtxReadAtResponse{})

func (msg *file2WithCtxReadAtResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxReadAtResponse
}

type file2WithCtxWriteAtRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Data   []uint8  `fidl_offset_v2:"0" fidl_bounds:"8192"`
	Offset uint64   `fidl_offset_v2:"16"`
}

var _mfile2WithCtxWriteAtRequest = _bindings.CreateLazyMarshaler(file2WithCtxWriteAtRequest{})

func (msg *file2WithCtxWriteAtRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxWriteAtRequest
}

type file2WithCtxWriteAtResponse struct {
	_      struct{}           `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2WriteAtResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxWriteAtResponse = _bindings.CreateLazyMarshaler(file2WithCtxWriteAtResponse{})

func (msg *file2WithCtxWriteAtResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxWriteAtResponse
}

type file2WithCtxResizeRequest struct {
	_      struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Length uint64   `fidl_offset_v2:"0"`
}

var _mfile2WithCtxResizeRequest = _bindings.CreateLazyMarshaler(file2WithCtxResizeRequest{})

func (msg *file2WithCtxResizeRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxResizeRequest
}

type file2WithCtxResizeResponse struct {
	_      struct{}          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2ResizeResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxResizeResponse = _bindings.CreateLazyMarshaler(file2WithCtxResizeResponse{})

func (msg *file2WithCtxResizeResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxResizeResponse
}

type file2WithCtxGetBackingMemoryRequest struct {
	_     struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags VmoFlags `fidl_offset_v2:"0"`
}

var _mfile2WithCtxGetBackingMemoryRequest = _bindings.CreateLazyMarshaler(file2WithCtxGetBackingMemoryRequest{})

func (msg *file2WithCtxGetBackingMemoryRequest) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxGetBackingMemoryRequest
}

type file2WithCtxGetBackingMemoryResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result File2GetBackingMemoryResult `fidl_offset_v2:"0"`
}

var _mfile2WithCtxGetBackingMemoryResponse = _bindings.CreateLazyMarshaler(file2WithCtxGetBackingMemoryResponse{})

func (msg *file2WithCtxGetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
	return _mfile2WithCtxGetBackingMemoryResponse
}

type nodeWithCtxCloneRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mnodeWithCtxCloneRequest = _bindings.CreateLazyMarshaler(nodeWithCtxCloneRequest{})

func (msg *nodeWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxCloneRequest
}

type nodeWithCtxDescribeResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info NodeInfo `fidl_offset_v2:"0"`
}

var _mnodeWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(nodeWithCtxDescribeResponse{})

func (msg *nodeWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxDescribeResponse
}

type nodeWithCtxOnOpenResponse struct {
	_    struct{}  `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32     `fidl_offset_v2:"0"`
	Info *NodeInfo `fidl_offset_v2:"8"`
}

var _mnodeWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(nodeWithCtxOnOpenResponse{})

func (msg *nodeWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxOnOpenResponse
}

type nodeWithCtxGetAttrResponse struct {
	_          struct{}       `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32          `fidl_offset_v2:"0"`
	Attributes NodeAttributes `fidl_offset_v2:"8"`
}

var _mnodeWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttrResponse{})

func (msg *nodeWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxGetAttrResponse
}

type nodeWithCtxSetAttrRequest struct {
	_          struct{}           `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      NodeAttributeFlags `fidl_offset_v2:"0"`
	Attributes NodeAttributes     `fidl_offset_v2:"8"`
}

var _mnodeWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(nodeWithCtxSetAttrRequest{})

func (msg *nodeWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxSetAttrRequest
}

type nodeWithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mnodeWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSetAttrResponse{})

func (msg *nodeWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxSetAttrResponse
}

type nodeWithCtxGetFlagsResponse struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32     `fidl_offset_v2:"0"`
	Flags OpenFlags `fidl_offset_v2:"4"`
}

var _mnodeWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetFlagsResponse{})

func (msg *nodeWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxGetFlagsResponse
}

type nodeWithCtxSetFlagsRequest struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags OpenFlags `fidl_offset_v2:"0"`
}

var _mnodeWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(nodeWithCtxSetFlagsRequest{})

func (msg *nodeWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxSetFlagsRequest
}

type nodeWithCtxSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mnodeWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSetFlagsResponse{})

func (msg *nodeWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxSetFlagsResponse
}

type nodeWithCtxQueryFilesystemResponse struct {
	_    struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	S    int32           `fidl_offset_v2:"0"`
	Info *FilesystemInfo `fidl_offset_v2:"8"`
}

var _mnodeWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(nodeWithCtxQueryFilesystemResponse{})

func (msg *nodeWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxQueryFilesystemResponse
}

type nodeWithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mnodeWithCtxCloseResponse = _bindings.CreateLazyMarshaler(nodeWithCtxCloseResponse{})

func (msg *nodeWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxCloseResponse
}

type nodeWithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mnodeWithCtxQueryResponse = _bindings.CreateLazyMarshaler(nodeWithCtxQueryResponse{})

func (msg *nodeWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxQueryResponse
}

type nodeWithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mnodeWithCtxReopenRequest = _bindings.CreateLazyMarshaler(nodeWithCtxReopenRequest{})

func (msg *nodeWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxReopenRequest
}

type nodeWithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mnodeWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(nodeWithCtxOnRepresentationResponse{})

func (msg *nodeWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxOnRepresentationResponse
}

type nodeWithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mnodeWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttributesRequest{})

func (msg *nodeWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxGetAttributesRequest
}

type nodeWithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mnodeWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttributesResponse{})

func (msg *nodeWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxGetAttributesResponse
}

type nodeWithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mnodeWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(nodeWithCtxUpdateAttributesResponse{})

func (msg *nodeWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxUpdateAttributesResponse
}

type nodeWithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mnodeWithCtxSyncResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSyncResponse{})

func (msg *nodeWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mnodeWithCtxSyncResponse
}

type node1WithCtxCloneRequest struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	Flags  OpenFlags                   `fidl_offset_v2:"0"`
	Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mnode1WithCtxCloneRequest = _bindings.CreateLazyMarshaler(node1WithCtxCloneRequest{})

func (msg *node1WithCtxCloneRequest) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxCloneRequest
}

type node1WithCtxDescribeResponse struct {
	_    struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Info NodeInfo `fidl_offset_v2:"0"`
}

var _mnode1WithCtxDescribeResponse = _bindings.CreateLazyMarshaler(node1WithCtxDescribeResponse{})

func (msg *node1WithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxDescribeResponse
}

type node1WithCtxOnOpenResponse struct {
	_    struct{}  `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	S    int32     `fidl_offset_v2:"0"`
	Info *NodeInfo `fidl_offset_v2:"8"`
}

var _mnode1WithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(node1WithCtxOnOpenResponse{})

func (msg *node1WithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxOnOpenResponse
}

type node1WithCtxGetAttrResponse struct {
	_          struct{}       `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	S          int32          `fidl_offset_v2:"0"`
	Attributes NodeAttributes `fidl_offset_v2:"8"`
}

var _mnode1WithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(node1WithCtxGetAttrResponse{})

func (msg *node1WithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxGetAttrResponse
}

type node1WithCtxSetAttrRequest struct {
	_          struct{}           `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
	Flags      NodeAttributeFlags `fidl_offset_v2:"0"`
	Attributes NodeAttributes     `fidl_offset_v2:"8"`
}

var _mnode1WithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(node1WithCtxSetAttrRequest{})

func (msg *node1WithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxSetAttrRequest
}

type node1WithCtxSetAttrResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mnode1WithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(node1WithCtxSetAttrResponse{})

func (msg *node1WithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxSetAttrResponse
}

type node1WithCtxGetFlagsResponse struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	S     int32     `fidl_offset_v2:"0"`
	Flags OpenFlags `fidl_offset_v2:"4"`
}

var _mnode1WithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(node1WithCtxGetFlagsResponse{})

func (msg *node1WithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxGetFlagsResponse
}

type node1WithCtxSetFlagsRequest struct {
	_     struct{}  `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Flags OpenFlags `fidl_offset_v2:"0"`
}

var _mnode1WithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(node1WithCtxSetFlagsRequest{})

func (msg *node1WithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxSetFlagsRequest
}

type node1WithCtxSetFlagsResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	S int32    `fidl_offset_v2:"0"`
}

var _mnode1WithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(node1WithCtxSetFlagsResponse{})

func (msg *node1WithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxSetFlagsResponse
}

type node1WithCtxQueryFilesystemResponse struct {
	_    struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	S    int32           `fidl_offset_v2:"0"`
	Info *FilesystemInfo `fidl_offset_v2:"8"`
}

var _mnode1WithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(node1WithCtxQueryFilesystemResponse{})

func (msg *node1WithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
	return _mnode1WithCtxQueryFilesystemResponse
}

type node2WithCtxCloseResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}

var _mnode2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(node2WithCtxCloseResponse{})

func (msg *node2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxCloseResponse
}

type node2WithCtxQueryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Identifies the underlying protocol.
	Protocol uint64 `fidl_offset_v2:"0"`
}

var _mnode2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(node2WithCtxQueryResponse{})

func (msg *node2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxQueryResponse
}

type node2WithCtxReopenRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	// Requests rights on the new connection according to the specified rules.
	//
	// If absent, inherits the rights from the connection where the call
	// is made.
	RightsRequest *RightsRequest `fidl_offset_v2:"0"`
	ObjectRequest _zx.Channel    `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mnode2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(node2WithCtxReopenRequest{})

func (msg *node2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxReopenRequest
}

type node2WithCtxOnRepresentationResponse struct {
	_       struct{}       `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Payload Representation `fidl_offset_v2:"0"`
}

var _mnode2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(node2WithCtxOnRepresentationResponse{})

func (msg *node2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxOnRepresentationResponse
}

type node2WithCtxGetAttributesRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	// Set the corresponding bit to one to query that particular attribute.
	//
	// The elements here correspond one-to-one with [`NodeAttributes`].
	Query NodeAttributesQuery `fidl_offset_v2:"0"`
}

var _mnode2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(node2WithCtxGetAttributesRequest{})

func (msg *node2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxGetAttributesRequest
}

type node2WithCtxGetAttributesResponse struct {
	_      struct{}                 `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}

var _mnode2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(node2WithCtxGetAttributesResponse{})

func (msg *node2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxGetAttributesResponse
}

type node2WithCtxUpdateAttributesResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}

var _mnode2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(node2WithCtxUpdateAttributesResponse{})

func (msg *node2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxUpdateAttributesResponse
}

type node2WithCtxSyncResponse struct {
	_      struct{}        `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result Node2SyncResult `fidl_offset_v2:"0"`
}

var _mnode2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(node2WithCtxSyncResponse{})

func (msg *node2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
	return _mnode2WithCtxSyncResponse
}

type I_advisoryLockingAdvisoryLockResultTag uint64

const (
	AdvisoryLockingAdvisoryLockResultResponse = 1 // 0x00000001
	AdvisoryLockingAdvisoryLockResultErr      = 2 // 0x00000002
)

type AdvisoryLockingAdvisoryLockResult struct {
	I_advisoryLockingAdvisoryLockResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                               AdvisoryLockingAdvisoryLockResponse `fidl_ordinal:"1"`
	Err                                    int32                               `fidl_ordinal:"2"`
}

var _mAdvisoryLockingAdvisoryLockResult = _bindings.CreateLazyMarshaler(AdvisoryLockingAdvisoryLockResult{})

func (msg *AdvisoryLockingAdvisoryLockResult) Marshaler() _bindings.Marshaler {
	return _mAdvisoryLockingAdvisoryLockResult
}

func (_m *AdvisoryLockingAdvisoryLockResult) reset() {
	switch _m.I_advisoryLockingAdvisoryLockResultTag {
	case 1:
		var _zeroed AdvisoryLockingAdvisoryLockResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *AdvisoryLockingAdvisoryLockResult) Which() I_advisoryLockingAdvisoryLockResultTag {
	return _m.I_advisoryLockingAdvisoryLockResultTag
}

func (_m *AdvisoryLockingAdvisoryLockResult) Ordinal() uint64 {
	return uint64(_m.I_advisoryLockingAdvisoryLockResultTag)
}

func (_m *AdvisoryLockingAdvisoryLockResult) SetResponse(response AdvisoryLockingAdvisoryLockResponse) {
	_m.reset()
	_m.I_advisoryLockingAdvisoryLockResultTag = AdvisoryLockingAdvisoryLockResultResponse
	_m.Response = response
}

func AdvisoryLockingAdvisoryLockResultWithResponse(response AdvisoryLockingAdvisoryLockResponse) AdvisoryLockingAdvisoryLockResult {
	var _u AdvisoryLockingAdvisoryLockResult
	_u.SetResponse(response)
	return _u
}

func (_m *AdvisoryLockingAdvisoryLockResult) SetErr(err int32) {
	_m.reset()
	_m.I_advisoryLockingAdvisoryLockResultTag = AdvisoryLockingAdvisoryLockResultErr
	_m.Err = err
}

func AdvisoryLockingAdvisoryLockResultWithErr(err int32) AdvisoryLockingAdvisoryLockResult {
	var _u AdvisoryLockingAdvisoryLockResult
	_u.SetErr(err)
	return _u
}

type I_connectionProtocolsTag uint64

const (
	ConnectionProtocols_unknownData = 0 // 0x00000000
	ConnectionProtocolsConnector    = 1 // 0x00000001
	ConnectionProtocolsNode         = 2 // 0x00000002
)

type ConnectionProtocols struct {
	I_connectionProtocolsTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData            interface{}
	// Requests that the node's underlying protocol be served on the
	// connection.
	Connector ConnectorFlags `fidl_ordinal:"1"`
	// Requests that the underlying [`Node`] protocol be served on the
	// connection.
	Node NodeOptions `fidl_ordinal:"2"`
}

var _mConnectionProtocols = _bindings.CreateLazyMarshaler(ConnectionProtocols{})

func (msg *ConnectionProtocols) Marshaler() _bindings.Marshaler {
	return _mConnectionProtocols
}

func (_m *ConnectionProtocols) reset() {
	switch _m.I_connectionProtocolsTag {
	case 1:
		var _zeroed ConnectorFlags
		_m.Connector = _zeroed
	case 2:
		var _zeroed NodeOptions
		_m.Node = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *ConnectionProtocols) Which() I_connectionProtocolsTag {
	switch _m.I_connectionProtocolsTag {
	case 1:
		return ConnectionProtocolsConnector
	case 2:
		return ConnectionProtocolsNode
	default:
		return ConnectionProtocols_unknownData
	}
}

func (_m *ConnectionProtocols) Ordinal() uint64 {
	return uint64(_m.I_connectionProtocolsTag)
}

func (_m *ConnectionProtocols) SetConnector(connector ConnectorFlags) {
	_m.reset()
	_m.I_connectionProtocolsTag = ConnectionProtocolsConnector
	_m.Connector = connector
}

func ConnectionProtocolsWithConnector(connector ConnectorFlags) ConnectionProtocols {
	var _u ConnectionProtocols
	_u.SetConnector(connector)
	return _u
}

func (_m *ConnectionProtocols) SetNode(node NodeOptions) {
	_m.reset()
	_m.I_connectionProtocolsTag = ConnectionProtocolsNode
	_m.Node = node
}

func ConnectionProtocolsWithNode(node NodeOptions) ConnectionProtocols {
	var _u ConnectionProtocols
	_u.SetNode(node)
	return _u
}
func (_m *ConnectionProtocols) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_directory2RenameResultTag uint64

const (
	Directory2RenameResultResponse = 1 // 0x00000001
	Directory2RenameResultErr      = 2 // 0x00000002
)

type Directory2RenameResult struct {
	I_directory2RenameResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                    Directory2RenameResponse `fidl_ordinal:"1"`
	Err                         int32                    `fidl_ordinal:"2"`
}

var _mDirectory2RenameResult = _bindings.CreateLazyMarshaler(Directory2RenameResult{})

func (msg *Directory2RenameResult) Marshaler() _bindings.Marshaler {
	return _mDirectory2RenameResult
}

func (_m *Directory2RenameResult) reset() {
	switch _m.I_directory2RenameResultTag {
	case 1:
		var _zeroed Directory2RenameResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *Directory2RenameResult) Which() I_directory2RenameResultTag {
	return _m.I_directory2RenameResultTag
}

func (_m *Directory2RenameResult) Ordinal() uint64 {
	return uint64(_m.I_directory2RenameResultTag)
}

func (_m *Directory2RenameResult) SetResponse(response Directory2RenameResponse) {
	_m.reset()
	_m.I_directory2RenameResultTag = Directory2RenameResultResponse
	_m.Response = response
}

func Directory2RenameResultWithResponse(response Directory2RenameResponse) Directory2RenameResult {
	var _u Directory2RenameResult
	_u.SetResponse(response)
	return _u
}

func (_m *Directory2RenameResult) SetErr(err int32) {
	_m.reset()
	_m.I_directory2RenameResultTag = Directory2RenameResultErr
	_m.Err = err
}

func Directory2RenameResultWithErr(err int32) Directory2RenameResult {
	var _u Directory2RenameResult
	_u.SetErr(err)
	return _u
}

type I_directory2UnlinkResultTag uint64

const (
	Directory2UnlinkResultResponse = 1 // 0x00000001
	Directory2UnlinkResultErr      = 2 // 0x00000002
)

type Directory2UnlinkResult struct {
	I_directory2UnlinkResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                    Directory2UnlinkResponse `fidl_ordinal:"1"`
	Err                         int32                    `fidl_ordinal:"2"`
}

var _mDirectory2UnlinkResult = _bindings.CreateLazyMarshaler(Directory2UnlinkResult{})

func (msg *Directory2UnlinkResult) Marshaler() _bindings.Marshaler {
	return _mDirectory2UnlinkResult
}

func (_m *Directory2UnlinkResult) reset() {
	switch _m.I_directory2UnlinkResultTag {
	case 1:
		var _zeroed Directory2UnlinkResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *Directory2UnlinkResult) Which() I_directory2UnlinkResultTag {
	return _m.I_directory2UnlinkResultTag
}

func (_m *Directory2UnlinkResult) Ordinal() uint64 {
	return uint64(_m.I_directory2UnlinkResultTag)
}

func (_m *Directory2UnlinkResult) SetResponse(response Directory2UnlinkResponse) {
	_m.reset()
	_m.I_directory2UnlinkResultTag = Directory2UnlinkResultResponse
	_m.Response = response
}

func Directory2UnlinkResultWithResponse(response Directory2UnlinkResponse) Directory2UnlinkResult {
	var _u Directory2UnlinkResult
	_u.SetResponse(response)
	return _u
}

func (_m *Directory2UnlinkResult) SetErr(err int32) {
	_m.reset()
	_m.I_directory2UnlinkResultTag = Directory2UnlinkResultErr
	_m.Err = err
}

func Directory2UnlinkResultWithErr(err int32) Directory2UnlinkResult {
	var _u Directory2UnlinkResult
	_u.SetErr(err)
	return _u
}

type I_directoryIteratorGetNextResultTag uint64

const (
	DirectoryIteratorGetNextResultResponse = 1 // 0x00000001
	DirectoryIteratorGetNextResultErr      = 2 // 0x00000002
)

type DirectoryIteratorGetNextResult struct {
	I_directoryIteratorGetNextResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            DirectoryIteratorGetNextResponse `fidl_ordinal:"1"`
	Err                                 int32                            `fidl_ordinal:"2"`
}

var _mDirectoryIteratorGetNextResult = _bindings.CreateLazyMarshaler(DirectoryIteratorGetNextResult{})

func (msg *DirectoryIteratorGetNextResult) Marshaler() _bindings.Marshaler {
	return _mDirectoryIteratorGetNextResult
}

func (_m *DirectoryIteratorGetNextResult) reset() {
	switch _m.I_directoryIteratorGetNextResultTag {
	case 1:
		var _zeroed DirectoryIteratorGetNextResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *DirectoryIteratorGetNextResult) Which() I_directoryIteratorGetNextResultTag {
	return _m.I_directoryIteratorGetNextResultTag
}

func (_m *DirectoryIteratorGetNextResult) Ordinal() uint64 {
	return uint64(_m.I_directoryIteratorGetNextResultTag)
}

func (_m *DirectoryIteratorGetNextResult) SetResponse(response DirectoryIteratorGetNextResponse) {
	_m.reset()
	_m.I_directoryIteratorGetNextResultTag = DirectoryIteratorGetNextResultResponse
	_m.Response = response
}

func DirectoryIteratorGetNextResultWithResponse(response DirectoryIteratorGetNextResponse) DirectoryIteratorGetNextResult {
	var _u DirectoryIteratorGetNextResult
	_u.SetResponse(response)
	return _u
}

func (_m *DirectoryIteratorGetNextResult) SetErr(err int32) {
	_m.reset()
	_m.I_directoryIteratorGetNextResultTag = DirectoryIteratorGetNextResultErr
	_m.Err = err
}

func DirectoryIteratorGetNextResultWithErr(err int32) DirectoryIteratorGetNextResult {
	var _u DirectoryIteratorGetNextResult
	_u.SetErr(err)
	return _u
}

type I_file2GetBackingMemoryResultTag uint64

const (
	File2GetBackingMemoryResultResponse = 1 // 0x00000001
	File2GetBackingMemoryResultErr      = 2 // 0x00000002
)

type File2GetBackingMemoryResult struct {
	I_file2GetBackingMemoryResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	Response                         File2GetBackingMemoryResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

var _mFile2GetBackingMemoryResult = _bindings.CreateLazyMarshaler(File2GetBackingMemoryResult{})

func (msg *File2GetBackingMemoryResult) Marshaler() _bindings.Marshaler {
	return _mFile2GetBackingMemoryResult
}

func (_m *File2GetBackingMemoryResult) reset() {
	switch _m.I_file2GetBackingMemoryResultTag {
	case 1:
		var _zeroed File2GetBackingMemoryResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2GetBackingMemoryResult) Which() I_file2GetBackingMemoryResultTag {
	return _m.I_file2GetBackingMemoryResultTag
}

func (_m *File2GetBackingMemoryResult) Ordinal() uint64 {
	return uint64(_m.I_file2GetBackingMemoryResultTag)
}

func (_m *File2GetBackingMemoryResult) SetResponse(response File2GetBackingMemoryResponse) {
	_m.reset()
	_m.I_file2GetBackingMemoryResultTag = File2GetBackingMemoryResultResponse
	_m.Response = response
}

func File2GetBackingMemoryResultWithResponse(response File2GetBackingMemoryResponse) File2GetBackingMemoryResult {
	var _u File2GetBackingMemoryResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2GetBackingMemoryResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2GetBackingMemoryResultTag = File2GetBackingMemoryResultErr
	_m.Err = err
}

func File2GetBackingMemoryResultWithErr(err int32) File2GetBackingMemoryResult {
	var _u File2GetBackingMemoryResult
	_u.SetErr(err)
	return _u
}

type I_file2ReadAtResultTag uint64

const (
	File2ReadAtResultResponse = 1 // 0x00000001
	File2ReadAtResultErr      = 2 // 0x00000002
)

type File2ReadAtResult struct {
	I_file2ReadAtResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response               File2ReadAtResponse `fidl_ordinal:"1"`
	Err                    int32               `fidl_ordinal:"2"`
}

var _mFile2ReadAtResult = _bindings.CreateLazyMarshaler(File2ReadAtResult{})

func (msg *File2ReadAtResult) Marshaler() _bindings.Marshaler {
	return _mFile2ReadAtResult
}

func (_m *File2ReadAtResult) reset() {
	switch _m.I_file2ReadAtResultTag {
	case 1:
		var _zeroed File2ReadAtResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2ReadAtResult) Which() I_file2ReadAtResultTag {
	return _m.I_file2ReadAtResultTag
}

func (_m *File2ReadAtResult) Ordinal() uint64 {
	return uint64(_m.I_file2ReadAtResultTag)
}

func (_m *File2ReadAtResult) SetResponse(response File2ReadAtResponse) {
	_m.reset()
	_m.I_file2ReadAtResultTag = File2ReadAtResultResponse
	_m.Response = response
}

func File2ReadAtResultWithResponse(response File2ReadAtResponse) File2ReadAtResult {
	var _u File2ReadAtResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2ReadAtResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2ReadAtResultTag = File2ReadAtResultErr
	_m.Err = err
}

func File2ReadAtResultWithErr(err int32) File2ReadAtResult {
	var _u File2ReadAtResult
	_u.SetErr(err)
	return _u
}

type I_file2ReadResultTag uint64

const (
	File2ReadResultResponse = 1 // 0x00000001
	File2ReadResultErr      = 2 // 0x00000002
)

type File2ReadResult struct {
	I_file2ReadResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response             File2ReadResponse `fidl_ordinal:"1"`
	Err                  int32             `fidl_ordinal:"2"`
}

var _mFile2ReadResult = _bindings.CreateLazyMarshaler(File2ReadResult{})

func (msg *File2ReadResult) Marshaler() _bindings.Marshaler {
	return _mFile2ReadResult
}

func (_m *File2ReadResult) reset() {
	switch _m.I_file2ReadResultTag {
	case 1:
		var _zeroed File2ReadResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2ReadResult) Which() I_file2ReadResultTag {
	return _m.I_file2ReadResultTag
}

func (_m *File2ReadResult) Ordinal() uint64 {
	return uint64(_m.I_file2ReadResultTag)
}

func (_m *File2ReadResult) SetResponse(response File2ReadResponse) {
	_m.reset()
	_m.I_file2ReadResultTag = File2ReadResultResponse
	_m.Response = response
}

func File2ReadResultWithResponse(response File2ReadResponse) File2ReadResult {
	var _u File2ReadResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2ReadResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2ReadResultTag = File2ReadResultErr
	_m.Err = err
}

func File2ReadResultWithErr(err int32) File2ReadResult {
	var _u File2ReadResult
	_u.SetErr(err)
	return _u
}

type I_file2ResizeResultTag uint64

const (
	File2ResizeResultResponse = 1 // 0x00000001
	File2ResizeResultErr      = 2 // 0x00000002
)

type File2ResizeResult struct {
	I_file2ResizeResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response               File2ResizeResponse `fidl_ordinal:"1"`
	Err                    int32               `fidl_ordinal:"2"`
}

var _mFile2ResizeResult = _bindings.CreateLazyMarshaler(File2ResizeResult{})

func (msg *File2ResizeResult) Marshaler() _bindings.Marshaler {
	return _mFile2ResizeResult
}

func (_m *File2ResizeResult) reset() {
	switch _m.I_file2ResizeResultTag {
	case 1:
		var _zeroed File2ResizeResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2ResizeResult) Which() I_file2ResizeResultTag {
	return _m.I_file2ResizeResultTag
}

func (_m *File2ResizeResult) Ordinal() uint64 {
	return uint64(_m.I_file2ResizeResultTag)
}

func (_m *File2ResizeResult) SetResponse(response File2ResizeResponse) {
	_m.reset()
	_m.I_file2ResizeResultTag = File2ResizeResultResponse
	_m.Response = response
}

func File2ResizeResultWithResponse(response File2ResizeResponse) File2ResizeResult {
	var _u File2ResizeResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2ResizeResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2ResizeResultTag = File2ResizeResultErr
	_m.Err = err
}

func File2ResizeResultWithErr(err int32) File2ResizeResult {
	var _u File2ResizeResult
	_u.SetErr(err)
	return _u
}

type I_file2SeekResultTag uint64

const (
	File2SeekResultResponse = 1 // 0x00000001
	File2SeekResultErr      = 2 // 0x00000002
)

type File2SeekResult struct {
	I_file2SeekResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response             File2SeekResponse `fidl_ordinal:"1"`
	Err                  int32             `fidl_ordinal:"2"`
}

var _mFile2SeekResult = _bindings.CreateLazyMarshaler(File2SeekResult{})

func (msg *File2SeekResult) Marshaler() _bindings.Marshaler {
	return _mFile2SeekResult
}

func (_m *File2SeekResult) reset() {
	switch _m.I_file2SeekResultTag {
	case 1:
		var _zeroed File2SeekResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2SeekResult) Which() I_file2SeekResultTag {
	return _m.I_file2SeekResultTag
}

func (_m *File2SeekResult) Ordinal() uint64 {
	return uint64(_m.I_file2SeekResultTag)
}

func (_m *File2SeekResult) SetResponse(response File2SeekResponse) {
	_m.reset()
	_m.I_file2SeekResultTag = File2SeekResultResponse
	_m.Response = response
}

func File2SeekResultWithResponse(response File2SeekResponse) File2SeekResult {
	var _u File2SeekResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2SeekResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2SeekResultTag = File2SeekResultErr
	_m.Err = err
}

func File2SeekResultWithErr(err int32) File2SeekResult {
	var _u File2SeekResult
	_u.SetErr(err)
	return _u
}

type I_file2WriteAtResultTag uint64

const (
	File2WriteAtResultResponse = 1 // 0x00000001
	File2WriteAtResultErr      = 2 // 0x00000002
)

type File2WriteAtResult struct {
	I_file2WriteAtResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                File2WriteAtResponse `fidl_ordinal:"1"`
	Err                     int32                `fidl_ordinal:"2"`
}

var _mFile2WriteAtResult = _bindings.CreateLazyMarshaler(File2WriteAtResult{})

func (msg *File2WriteAtResult) Marshaler() _bindings.Marshaler {
	return _mFile2WriteAtResult
}

func (_m *File2WriteAtResult) reset() {
	switch _m.I_file2WriteAtResultTag {
	case 1:
		var _zeroed File2WriteAtResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2WriteAtResult) Which() I_file2WriteAtResultTag {
	return _m.I_file2WriteAtResultTag
}

func (_m *File2WriteAtResult) Ordinal() uint64 {
	return uint64(_m.I_file2WriteAtResultTag)
}

func (_m *File2WriteAtResult) SetResponse(response File2WriteAtResponse) {
	_m.reset()
	_m.I_file2WriteAtResultTag = File2WriteAtResultResponse
	_m.Response = response
}

func File2WriteAtResultWithResponse(response File2WriteAtResponse) File2WriteAtResult {
	var _u File2WriteAtResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2WriteAtResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2WriteAtResultTag = File2WriteAtResultErr
	_m.Err = err
}

func File2WriteAtResultWithErr(err int32) File2WriteAtResult {
	var _u File2WriteAtResult
	_u.SetErr(err)
	return _u
}

type I_file2WriteResultTag uint64

const (
	File2WriteResultResponse = 1 // 0x00000001
	File2WriteResultErr      = 2 // 0x00000002
)

type File2WriteResult struct {
	I_file2WriteResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response              File2WriteResponse `fidl_ordinal:"1"`
	Err                   int32              `fidl_ordinal:"2"`
}

var _mFile2WriteResult = _bindings.CreateLazyMarshaler(File2WriteResult{})

func (msg *File2WriteResult) Marshaler() _bindings.Marshaler {
	return _mFile2WriteResult
}

func (_m *File2WriteResult) reset() {
	switch _m.I_file2WriteResultTag {
	case 1:
		var _zeroed File2WriteResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *File2WriteResult) Which() I_file2WriteResultTag {
	return _m.I_file2WriteResultTag
}

func (_m *File2WriteResult) Ordinal() uint64 {
	return uint64(_m.I_file2WriteResultTag)
}

func (_m *File2WriteResult) SetResponse(response File2WriteResponse) {
	_m.reset()
	_m.I_file2WriteResultTag = File2WriteResultResponse
	_m.Response = response
}

func File2WriteResultWithResponse(response File2WriteResponse) File2WriteResult {
	var _u File2WriteResult
	_u.SetResponse(response)
	return _u
}

func (_m *File2WriteResult) SetErr(err int32) {
	_m.reset()
	_m.I_file2WriteResultTag = File2WriteResultErr
	_m.Err = err
}

func File2WriteResultWithErr(err int32) File2WriteResult {
	var _u File2WriteResult
	_u.SetErr(err)
	return _u
}

type I_node2GetAttributesResultTag uint64

const (
	Node2GetAttributesResultResponse = 1 // 0x00000001
	Node2GetAttributesResultErr      = 2 // 0x00000002
)

type Node2GetAttributesResult struct {
	I_node2GetAttributesResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                      NodeAttributes2 `fidl_ordinal:"1"`
	Err                           int32           `fidl_ordinal:"2"`
}

var _mNode2GetAttributesResult = _bindings.CreateLazyMarshaler(Node2GetAttributesResult{})

func (msg *Node2GetAttributesResult) Marshaler() _bindings.Marshaler {
	return _mNode2GetAttributesResult
}

func (_m *Node2GetAttributesResult) reset() {
	switch _m.I_node2GetAttributesResultTag {
	case 1:
		var _zeroed NodeAttributes2
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *Node2GetAttributesResult) Which() I_node2GetAttributesResultTag {
	return _m.I_node2GetAttributesResultTag
}

func (_m *Node2GetAttributesResult) Ordinal() uint64 {
	return uint64(_m.I_node2GetAttributesResultTag)
}

func (_m *Node2GetAttributesResult) SetResponse(response NodeAttributes2) {
	_m.reset()
	_m.I_node2GetAttributesResultTag = Node2GetAttributesResultResponse
	_m.Response = response
}

func Node2GetAttributesResultWithResponse(response NodeAttributes2) Node2GetAttributesResult {
	var _u Node2GetAttributesResult
	_u.SetResponse(response)
	return _u
}

func (_m *Node2GetAttributesResult) SetErr(err int32) {
	_m.reset()
	_m.I_node2GetAttributesResultTag = Node2GetAttributesResultErr
	_m.Err = err
}

func Node2GetAttributesResultWithErr(err int32) Node2GetAttributesResult {
	var _u Node2GetAttributesResult
	_u.SetErr(err)
	return _u
}

type I_node2SyncResultTag uint64

const (
	Node2SyncResultResponse = 1 // 0x00000001
	Node2SyncResultErr      = 2 // 0x00000002
)

type Node2SyncResult struct {
	I_node2SyncResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response             Node2SyncResponse `fidl_ordinal:"1"`
	Err                  int32             `fidl_ordinal:"2"`
}

var _mNode2SyncResult = _bindings.CreateLazyMarshaler(Node2SyncResult{})

func (msg *Node2SyncResult) Marshaler() _bindings.Marshaler {
	return _mNode2SyncResult
}

func (_m *Node2SyncResult) reset() {
	switch _m.I_node2SyncResultTag {
	case 1:
		var _zeroed Node2SyncResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *Node2SyncResult) Which() I_node2SyncResultTag {
	return _m.I_node2SyncResultTag
}

func (_m *Node2SyncResult) Ordinal() uint64 {
	return uint64(_m.I_node2SyncResultTag)
}

func (_m *Node2SyncResult) SetResponse(response Node2SyncResponse) {
	_m.reset()
	_m.I_node2SyncResultTag = Node2SyncResultResponse
	_m.Response = response
}

func Node2SyncResultWithResponse(response Node2SyncResponse) Node2SyncResult {
	var _u Node2SyncResult
	_u.SetResponse(response)
	return _u
}

func (_m *Node2SyncResult) SetErr(err int32) {
	_m.reset()
	_m.I_node2SyncResultTag = Node2SyncResultErr
	_m.Err = err
}

func Node2SyncResultWithErr(err int32) Node2SyncResult {
	var _u Node2SyncResult
	_u.SetErr(err)
	return _u
}

type I_node2UpdateAttributesResultTag uint64

const (
	Node2UpdateAttributesResultResponse = 1 // 0x00000001
	Node2UpdateAttributesResultErr      = 2 // 0x00000002
)

type Node2UpdateAttributesResult struct {
	I_node2UpdateAttributesResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         Node2UpdateAttributesResponse `fidl_ordinal:"1"`
	Err                              int32                         `fidl_ordinal:"2"`
}

var _mNode2UpdateAttributesResult = _bindings.CreateLazyMarshaler(Node2UpdateAttributesResult{})

func (msg *Node2UpdateAttributesResult) Marshaler() _bindings.Marshaler {
	return _mNode2UpdateAttributesResult
}

func (_m *Node2UpdateAttributesResult) reset() {
	switch _m.I_node2UpdateAttributesResultTag {
	case 1:
		var _zeroed Node2UpdateAttributesResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed int32
		_m.Err = _zeroed
	}
}

func (_m *Node2UpdateAttributesResult) Which() I_node2UpdateAttributesResultTag {
	return _m.I_node2UpdateAttributesResultTag
}

func (_m *Node2UpdateAttributesResult) Ordinal() uint64 {
	return uint64(_m.I_node2UpdateAttributesResultTag)
}

func (_m *Node2UpdateAttributesResult) SetResponse(response Node2UpdateAttributesResponse) {
	_m.reset()
	_m.I_node2UpdateAttributesResultTag = Node2UpdateAttributesResultResponse
	_m.Response = response
}

func Node2UpdateAttributesResultWithResponse(response Node2UpdateAttributesResponse) Node2UpdateAttributesResult {
	var _u Node2UpdateAttributesResult
	_u.SetResponse(response)
	return _u
}

func (_m *Node2UpdateAttributesResult) SetErr(err int32) {
	_m.reset()
	_m.I_node2UpdateAttributesResultTag = Node2UpdateAttributesResultErr
	_m.Err = err
}

func Node2UpdateAttributesResultWithErr(err int32) Node2UpdateAttributesResult {
	var _u Node2UpdateAttributesResult
	_u.SetErr(err)
	return _u
}

type I_nodeInfoTag uint64

const (
	NodeInfoService                   = 1  // 0x00000001
	NodeInfoFile                      = 2  // 0x00000002
	NodeInfoDirectory                 = 3  // 0x00000003
	NodeInfoVmofileDeprecated         = 5  // 0x00000005
	NodeInfoTty                       = 7  // 0x00000007
	NodeInfoSynchronousDatagramSocket = 9  // 0x00000009
	NodeInfoStreamSocket              = 10 // 0x0000000a
	NodeInfoRawSocket                 = 11 // 0x0000000b
	NodeInfoPacketSocket              = 12 // 0x0000000c
	NodeInfoDatagramSocket            = 13 // 0x0000000d
)

// Connection information.
//
// Refer to [`Node.Describe`] and [`Node.OnOpen`] for usage.
type NodeInfo struct {
	I_nodeInfoTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	// No protocol information was supplied by the connection.
	Service Service `fidl_ordinal:"1"`
	// The connection composes [`File`].
	File FileObject `fidl_ordinal:"2"`
	// The connection composes [`Directory`].
	Directory DirectoryObject `fidl_ordinal:"3"`
	// The connection composes [`File`]. Its implementation is backed by a VMO.
	VmofileDeprecated VmofileDeprecated `fidl_ordinal:"5"`
	// The connection composes [`fuchsia.hardware.pty/Device`].
	Tty Tty `fidl_ordinal:"7"`
	// The connection composes [`fuchsia.posix.socket/SynchronousDatagramSocket`].
	SynchronousDatagramSocket SynchronousDatagramSocket `fidl_ordinal:"9"`
	// The connection composes [`fuchsia.posix.socket/StreamSocket`].
	StreamSocket StreamSocket `fidl_ordinal:"10"`
	// The connection composes [`fuchsia.posix.socket.raw/Socket`].
	RawSocket RawSocket `fidl_ordinal:"11"`
	// The connection composes [`fuchsia.posix.socket.packet/Socket`].
	PacketSocket PacketSocket `fidl_ordinal:"12"`
	// The connection composes  [`fuchsia.posix.socket/DatagramSocket`].
	DatagramSocket DatagramSocket `fidl_ordinal:"13"`
}

var _mNodeInfo = _bindings.CreateLazyMarshaler(NodeInfo{})

func (msg *NodeInfo) Marshaler() _bindings.Marshaler {
	return _mNodeInfo
}

func (_m *NodeInfo) reset() {
	switch _m.I_nodeInfoTag {
	case 1:
		var _zeroed Service
		_m.Service = _zeroed
	case 2:
		var _zeroed FileObject
		_m.File = _zeroed
	case 3:
		var _zeroed DirectoryObject
		_m.Directory = _zeroed
	case 5:
		var _zeroed VmofileDeprecated
		_m.VmofileDeprecated = _zeroed
	case 7:
		var _zeroed Tty
		_m.Tty = _zeroed
	case 9:
		var _zeroed SynchronousDatagramSocket
		_m.SynchronousDatagramSocket = _zeroed
	case 10:
		var _zeroed StreamSocket
		_m.StreamSocket = _zeroed
	case 11:
		var _zeroed RawSocket
		_m.RawSocket = _zeroed
	case 12:
		var _zeroed PacketSocket
		_m.PacketSocket = _zeroed
	case 13:
		var _zeroed DatagramSocket
		_m.DatagramSocket = _zeroed
	}
}

func (_m *NodeInfo) Which() I_nodeInfoTag {
	return _m.I_nodeInfoTag
}

func (_m *NodeInfo) Ordinal() uint64 {
	return uint64(_m.I_nodeInfoTag)
}

func (_m *NodeInfo) SetService(service Service) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoService
	_m.Service = service
}

func NodeInfoWithService(service Service) NodeInfo {
	var _u NodeInfo
	_u.SetService(service)
	return _u
}

func (_m *NodeInfo) SetFile(file FileObject) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoFile
	_m.File = file
}

func NodeInfoWithFile(file FileObject) NodeInfo {
	var _u NodeInfo
	_u.SetFile(file)
	return _u
}

func (_m *NodeInfo) SetDirectory(directory DirectoryObject) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoDirectory
	_m.Directory = directory
}

func NodeInfoWithDirectory(directory DirectoryObject) NodeInfo {
	var _u NodeInfo
	_u.SetDirectory(directory)
	return _u
}

func (_m *NodeInfo) SetVmofileDeprecated(vmofileDeprecated VmofileDeprecated) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoVmofileDeprecated
	_m.VmofileDeprecated = vmofileDeprecated
}

func NodeInfoWithVmofileDeprecated(vmofileDeprecated VmofileDeprecated) NodeInfo {
	var _u NodeInfo
	_u.SetVmofileDeprecated(vmofileDeprecated)
	return _u
}

func (_m *NodeInfo) SetTty(tty Tty) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoTty
	_m.Tty = tty
}

func NodeInfoWithTty(tty Tty) NodeInfo {
	var _u NodeInfo
	_u.SetTty(tty)
	return _u
}

func (_m *NodeInfo) SetSynchronousDatagramSocket(synchronousDatagramSocket SynchronousDatagramSocket) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoSynchronousDatagramSocket
	_m.SynchronousDatagramSocket = synchronousDatagramSocket
}

func NodeInfoWithSynchronousDatagramSocket(synchronousDatagramSocket SynchronousDatagramSocket) NodeInfo {
	var _u NodeInfo
	_u.SetSynchronousDatagramSocket(synchronousDatagramSocket)
	return _u
}

func (_m *NodeInfo) SetStreamSocket(streamSocket StreamSocket) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoStreamSocket
	_m.StreamSocket = streamSocket
}

func NodeInfoWithStreamSocket(streamSocket StreamSocket) NodeInfo {
	var _u NodeInfo
	_u.SetStreamSocket(streamSocket)
	return _u
}

func (_m *NodeInfo) SetRawSocket(rawSocket RawSocket) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoRawSocket
	_m.RawSocket = rawSocket
}

func NodeInfoWithRawSocket(rawSocket RawSocket) NodeInfo {
	var _u NodeInfo
	_u.SetRawSocket(rawSocket)
	return _u
}

func (_m *NodeInfo) SetPacketSocket(packetSocket PacketSocket) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoPacketSocket
	_m.PacketSocket = packetSocket
}

func NodeInfoWithPacketSocket(packetSocket PacketSocket) NodeInfo {
	var _u NodeInfo
	_u.SetPacketSocket(packetSocket)
	return _u
}

func (_m *NodeInfo) SetDatagramSocket(datagramSocket DatagramSocket) {
	_m.reset()
	_m.I_nodeInfoTag = NodeInfoDatagramSocket
	_m.DatagramSocket = datagramSocket
}

func NodeInfoWithDatagramSocket(datagramSocket DatagramSocket) NodeInfo {
	var _u NodeInfo
	_u.SetDatagramSocket(datagramSocket)
	return _u
}

type I_representationTag uint64

const (
	Representation_unknownData = 0 // 0x00000000
	RepresentationConnector    = 1 // 0x00000001
	RepresentationDirectory    = 2 // 0x00000002
	RepresentationFile         = 3 // 0x00000003
)

type Representation struct {
	I_representationTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	I_unknownData       interface{}
	// Auxiliary data for the connector representation of a node, used
	// for protocol discovery and connection.
	//
	// It supports connecting to arbitrary protocols exported by the
	// filesystem server at a path, including ones that do not compose
	// [`Node2`].
	//
	// See [`NodeProtocolKinds.CONNECTOR`].
	Connector ConnectorInfo `fidl_ordinal:"1"`
	// Auxiliary data for the directory representation of a node. The
	// selection of this variant in [`Representation`] implies that the
	// connection speaks the [`Directory`] protocol.
	//
	// See [`NodeProtocolKinds.DIRECTORY`].
	Directory DirectoryInfo `fidl_ordinal:"2"`
	// Auxiliary data for the file representation of a node. The
	// selection of this variant in [`Representation`] implies that the
	// connection speaks the [`File`] protocol.
	//
	// See [`NodeProtocolKinds.FILE`].
	File FileInfo `fidl_ordinal:"3"`
}

var _mRepresentation = _bindings.CreateLazyMarshaler(Representation{})

func (msg *Representation) Marshaler() _bindings.Marshaler {
	return _mRepresentation
}

func (_m *Representation) reset() {
	switch _m.I_representationTag {
	case 1:
		var _zeroed ConnectorInfo
		_m.Connector = _zeroed
	case 2:
		var _zeroed DirectoryInfo
		_m.Directory = _zeroed
	case 3:
		var _zeroed FileInfo
		_m.File = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *Representation) Which() I_representationTag {
	switch _m.I_representationTag {
	case 1:
		return RepresentationConnector
	case 2:
		return RepresentationDirectory
	case 3:
		return RepresentationFile
	default:
		return Representation_unknownData
	}
}

func (_m *Representation) Ordinal() uint64 {
	return uint64(_m.I_representationTag)
}

func (_m *Representation) SetConnector(connector ConnectorInfo) {
	_m.reset()
	_m.I_representationTag = RepresentationConnector
	_m.Connector = connector
}

func RepresentationWithConnector(connector ConnectorInfo) Representation {
	var _u Representation
	_u.SetConnector(connector)
	return _u
}

func (_m *Representation) SetDirectory(directory DirectoryInfo) {
	_m.reset()
	_m.I_representationTag = RepresentationDirectory
	_m.Directory = directory
}

func RepresentationWithDirectory(directory DirectoryInfo) Representation {
	var _u Representation
	_u.SetDirectory(directory)
	return _u
}

func (_m *Representation) SetFile(file FileInfo) {
	_m.reset()
	_m.I_representationTag = RepresentationFile
	_m.File = file
}

func RepresentationWithFile(file FileInfo) Representation {
	var _u Representation
	_u.SetFile(file)
	return _u
}
func (_m *Representation) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type AdvisoryLockRequest struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// The type of lock to be acquired.
	//
	// If this field is absent, the [`AdvisoryLock`] method will fail
	// with ZX_ERR_INVALID_ARGS.
	Type        AdvisoryLockType `fidl_ordinal:"1"`
	TypePresent bool
	// The byte range within the file to be locked.
	//
	// The range can extend beyond the end of the file but cannot extend beyond
	// the beginning of the file.
	//
	// If this field is absent, the range defaults to the entire file.
	Range        AdvisoryLockRange `fidl_ordinal:"2"`
	RangePresent bool
	// Whether the file should wait reply to the [`AdvisoryLock`]
	// method until the requested lock can be acquired.
	//
	// If this field is absent, the file will not wait.
	Wait        bool `fidl_ordinal:"3"`
	WaitPresent bool
}

var _mAdvisoryLockRequest = _bindings.CreateLazyMarshaler(AdvisoryLockRequest{})

func (msg *AdvisoryLockRequest) Marshaler() _bindings.Marshaler {
	return _mAdvisoryLockRequest
}

func (u *AdvisoryLockRequest) SetType(type_ AdvisoryLockType) {
	u.Type = type_
	u.TypePresent = true
}

func (u *AdvisoryLockRequest) GetType() AdvisoryLockType {
	return u.Type
}

func (u *AdvisoryLockRequest) GetTypeWithDefault(_default AdvisoryLockType) AdvisoryLockType {
	if !u.HasType() {
		return _default
	}
	return u.Type
}

func (u *AdvisoryLockRequest) HasType() bool {
	return u.TypePresent
}

func (u *AdvisoryLockRequest) ClearType() {
	u.TypePresent = false
}

func (u *AdvisoryLockRequest) SetRange(range_ AdvisoryLockRange) {
	u.Range = range_
	u.RangePresent = true
}

func (u *AdvisoryLockRequest) GetRange() AdvisoryLockRange {
	return u.Range
}

func (u *AdvisoryLockRequest) GetRangeWithDefault(_default AdvisoryLockRange) AdvisoryLockRange {
	if !u.HasRange() {
		return _default
	}
	return u.Range
}

func (u *AdvisoryLockRequest) HasRange() bool {
	return u.RangePresent
}

func (u *AdvisoryLockRequest) ClearRange() {
	u.RangePresent = false
}

func (u *AdvisoryLockRequest) SetWait(wait bool) {
	u.Wait = wait
	u.WaitPresent = true
}

func (u *AdvisoryLockRequest) GetWait() bool {
	return u.Wait
}

func (u *AdvisoryLockRequest) GetWaitWithDefault(_default bool) bool {
	if !u.HasWait() {
		return _default
	}
	return u.Wait
}

func (u *AdvisoryLockRequest) HasWait() bool {
	return u.WaitPresent
}

func (u *AdvisoryLockRequest) ClearWait() {
	u.WaitPresent = false
}

func (u *AdvisoryLockRequest) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *AdvisoryLockRequest) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type ConnectionInfo struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	I_unknownData interface{}
	// The rights possessed by the current connection. Note: `rights` limits
	// the set of operations allowed on the connection, but does not guarantee
	// their availability. For example, one may have the [`Rights.EXECUTE`]
	// right on a file connection, but the file itself does not have the
	// `EXECUTE` ability, and hence cannot be executed. See
	// [`ConnectionOptions.rights`].
	Rights        Operations `fidl_ordinal:"1"`
	RightsPresent bool
}

var _mConnectionInfo = _bindings.CreateLazyMarshaler(ConnectionInfo{})

func (msg *ConnectionInfo) Marshaler() _bindings.Marshaler {
	return _mConnectionInfo
}

func (u *ConnectionInfo) SetRights(rights Operations) {
	u.Rights = rights
	u.RightsPresent = true
}

func (u *ConnectionInfo) GetRights() Operations {
	return u.Rights
}

func (u *ConnectionInfo) GetRightsWithDefault(_default Operations) Operations {
	if !u.HasRights() {
		return _default
	}
	return u.Rights
}

func (u *ConnectionInfo) HasRights() bool {
	return u.RightsPresent
}

func (u *ConnectionInfo) ClearRights() {
	u.RightsPresent = false
}

func (u *ConnectionInfo) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ConnectionInfo) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type ConnectorInfo struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
}

var _mConnectorInfo = _bindings.CreateLazyMarshaler(ConnectorInfo{})

func (msg *ConnectorInfo) Marshaler() _bindings.Marshaler {
	return _mConnectorInfo
}

func (u *ConnectorInfo) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ConnectorInfo) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type DirectoryEntry struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// Name of the node. This field must be present.
	Name        string `fidl_bounds:"255" fidl_ordinal:"1"`
	NamePresent bool
	// Describes the kinds of representations supported by the node.
	Protocols        NodeProtocolKinds `fidl_ordinal:"2"`
	ProtocolsPresent bool
	// Describes the kinds of operations supported by the node.
	Abilities        Operations `fidl_ordinal:"3"`
	AbilitiesPresent bool
	// An ID for the node. See [`Id`].
	// This `id` should be unique among all entries of a directory.
	Id        uint64 `fidl_ordinal:"4"`
	IdPresent bool
}

var _mDirectoryEntry = _bindings.CreateLazyMarshaler(DirectoryEntry{})

func (msg *DirectoryEntry) Marshaler() _bindings.Marshaler {
	return _mDirectoryEntry
}

func (u *DirectoryEntry) SetName(name string) {
	u.Name = name
	u.NamePresent = true
}

func (u *DirectoryEntry) GetName() string {
	return u.Name
}

func (u *DirectoryEntry) GetNameWithDefault(_default string) string {
	if !u.HasName() {
		return _default
	}
	return u.Name
}

func (u *DirectoryEntry) HasName() bool {
	return u.NamePresent
}

func (u *DirectoryEntry) ClearName() {
	u.NamePresent = false
}

func (u *DirectoryEntry) SetProtocols(protocols NodeProtocolKinds) {
	u.Protocols = protocols
	u.ProtocolsPresent = true
}

func (u *DirectoryEntry) GetProtocols() NodeProtocolKinds {
	return u.Protocols
}

func (u *DirectoryEntry) GetProtocolsWithDefault(_default NodeProtocolKinds) NodeProtocolKinds {
	if !u.HasProtocols() {
		return _default
	}
	return u.Protocols
}

func (u *DirectoryEntry) HasProtocols() bool {
	return u.ProtocolsPresent
}

func (u *DirectoryEntry) ClearProtocols() {
	u.ProtocolsPresent = false
}

func (u *DirectoryEntry) SetAbilities(abilities Operations) {
	u.Abilities = abilities
	u.AbilitiesPresent = true
}

func (u *DirectoryEntry) GetAbilities() Operations {
	return u.Abilities
}

func (u *DirectoryEntry) GetAbilitiesWithDefault(_default Operations) Operations {
	if !u.HasAbilities() {
		return _default
	}
	return u.Abilities
}

func (u *DirectoryEntry) HasAbilities() bool {
	return u.AbilitiesPresent
}

func (u *DirectoryEntry) ClearAbilities() {
	u.AbilitiesPresent = false
}

func (u *DirectoryEntry) SetId(id uint64) {
	u.Id = id
	u.IdPresent = true
}

func (u *DirectoryEntry) GetId() uint64 {
	return u.Id
}

func (u *DirectoryEntry) GetIdWithDefault(_default uint64) uint64 {
	if !u.HasId() {
		return _default
	}
	return u.Id
}

func (u *DirectoryEntry) HasId() bool {
	return u.IdPresent
}

func (u *DirectoryEntry) ClearId() {
	u.IdPresent = false
}

func (u *DirectoryEntry) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *DirectoryEntry) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type DirectoryEnumerateOptions struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
}

var _mDirectoryEnumerateOptions = _bindings.CreateLazyMarshaler(DirectoryEnumerateOptions{})

func (msg *DirectoryEnumerateOptions) Marshaler() _bindings.Marshaler {
	return _mDirectoryEnumerateOptions
}

func (u *DirectoryEnumerateOptions) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *DirectoryEnumerateOptions) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type DirectoryInfo struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
}

var _mDirectoryInfo = _bindings.CreateLazyMarshaler(DirectoryInfo{})

func (msg *DirectoryInfo) Marshaler() _bindings.Marshaler {
	return _mDirectoryInfo
}

func (u *DirectoryInfo) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *DirectoryInfo) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

// Auxiliary data for the file representation of a node.
type FileInfo struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	I_unknownData interface{}
	// True if the file is opened in append mode.
	// In append mode, the seek offset is moved to the end before every
	// write, the two steps performed in an atomic manner.
	IsAppend        bool `fidl_ordinal:"1"`
	IsAppendPresent bool
	// An optional event which transmits information about an object's
	// readability or writability. This event relays information about the
	// underlying object, not the capability granted to client: this event
	// may be signalled "readable" on a connection that does not have
	// the capability to read.
	//
	// This event will be present if the following conditions are met:
	//
	// - The `available_operations` on the file connection is not empty.
	// - The filesystem supports signalling readability/writability events.
	//
	// The [`FileSignal`] values may be observed on this event.
	Observer        _zx.Event `fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"0" fidl_ordinal:"2"`
	ObserverPresent bool
	// An optional stream object, which can be used to read to and write from
	// the file.
	//
	// Reading and writing the file using the stream object can be up to 20x
	// faster than reading and writing the file using the Read and Write
	// operations in the [`File`] protocol.
	Stream        _zx.Handle `fidl_handle_subtype:"31" fidl_handle_rights:"2147483648" fidl_bounds:"0" fidl_ordinal:"3"`
	StreamPresent bool
}

var _mFileInfo = _bindings.CreateLazyMarshaler(FileInfo{})

func (msg *FileInfo) Marshaler() _bindings.Marshaler {
	return _mFileInfo
}

func (u *FileInfo) SetIsAppend(isAppend bool) {
	u.IsAppend = isAppend
	u.IsAppendPresent = true
}

func (u *FileInfo) GetIsAppend() bool {
	return u.IsAppend
}

func (u *FileInfo) GetIsAppendWithDefault(_default bool) bool {
	if !u.HasIsAppend() {
		return _default
	}
	return u.IsAppend
}

func (u *FileInfo) HasIsAppend() bool {
	return u.IsAppendPresent
}

func (u *FileInfo) ClearIsAppend() {
	u.IsAppendPresent = false
}

func (u *FileInfo) SetObserver(observer _zx.Event) {
	u.Observer = observer
	u.ObserverPresent = true
}

func (u *FileInfo) GetObserver() _zx.Event {
	return u.Observer
}

func (u *FileInfo) GetObserverWithDefault(_default _zx.Event) _zx.Event {
	if !u.HasObserver() {
		return _default
	}
	return u.Observer
}

func (u *FileInfo) HasObserver() bool {
	return u.ObserverPresent
}

func (u *FileInfo) ClearObserver() {
	u.ObserverPresent = false
}

func (u *FileInfo) SetStream(stream _zx.Handle) {
	u.Stream = stream
	u.StreamPresent = true
}

func (u *FileInfo) GetStream() _zx.Handle {
	return u.Stream
}

func (u *FileInfo) GetStreamWithDefault(_default _zx.Handle) _zx.Handle {
	if !u.HasStream() {
		return _default
	}
	return u.Stream
}

func (u *FileInfo) HasStream() bool {
	return u.StreamPresent
}

func (u *FileInfo) ClearStream() {
	u.StreamPresent = false
}

func (u *FileInfo) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *FileInfo) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type ImmutableNodeAttributes struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// Describes the kinds of representations supported by the node.
	// Note: This is not the result of the connection-time negotiation,
	// which is conveyed via `representation`.
	Protocols        NodeProtocolKinds `fidl_ordinal:"1"`
	ProtocolsPresent bool
	// Describes the kinds of operations supported by the node.
	// Note: This is distinct from the rights used at connection time.
	Abilities        Operations `fidl_ordinal:"2"`
	AbilitiesPresent bool
	// Node size, in bytes.
	ContentSize        uint64 `fidl_ordinal:"3"`
	ContentSizePresent bool
	// Space needed to store the node (possibly larger than size), in bytes.
	StorageSize        uint64 `fidl_ordinal:"4"`
	StorageSizePresent bool
	// Number of hard links to the node. It must be at least one.
	LinkCount        uint64 `fidl_ordinal:"5"`
	LinkCountPresent bool
	// An ID for the node. See [`Id`].
	// This `id` should be unique among all entries of a directory.
	Id        uint64 `fidl_ordinal:"6"`
	IdPresent bool
}

var _mImmutableNodeAttributes = _bindings.CreateLazyMarshaler(ImmutableNodeAttributes{})

func (msg *ImmutableNodeAttributes) Marshaler() _bindings.Marshaler {
	return _mImmutableNodeAttributes
}

func (u *ImmutableNodeAttributes) SetProtocols(protocols NodeProtocolKinds) {
	u.Protocols = protocols
	u.ProtocolsPresent = true
}

func (u *ImmutableNodeAttributes) GetProtocols() NodeProtocolKinds {
	return u.Protocols
}

func (u *ImmutableNodeAttributes) GetProtocolsWithDefault(_default NodeProtocolKinds) NodeProtocolKinds {
	if !u.HasProtocols() {
		return _default
	}
	return u.Protocols
}

func (u *ImmutableNodeAttributes) HasProtocols() bool {
	return u.ProtocolsPresent
}

func (u *ImmutableNodeAttributes) ClearProtocols() {
	u.ProtocolsPresent = false
}

func (u *ImmutableNodeAttributes) SetAbilities(abilities Operations) {
	u.Abilities = abilities
	u.AbilitiesPresent = true
}

func (u *ImmutableNodeAttributes) GetAbilities() Operations {
	return u.Abilities
}

func (u *ImmutableNodeAttributes) GetAbilitiesWithDefault(_default Operations) Operations {
	if !u.HasAbilities() {
		return _default
	}
	return u.Abilities
}

func (u *ImmutableNodeAttributes) HasAbilities() bool {
	return u.AbilitiesPresent
}

func (u *ImmutableNodeAttributes) ClearAbilities() {
	u.AbilitiesPresent = false
}

func (u *ImmutableNodeAttributes) SetContentSize(contentSize uint64) {
	u.ContentSize = contentSize
	u.ContentSizePresent = true
}

func (u *ImmutableNodeAttributes) GetContentSize() uint64 {
	return u.ContentSize
}

func (u *ImmutableNodeAttributes) GetContentSizeWithDefault(_default uint64) uint64 {
	if !u.HasContentSize() {
		return _default
	}
	return u.ContentSize
}

func (u *ImmutableNodeAttributes) HasContentSize() bool {
	return u.ContentSizePresent
}

func (u *ImmutableNodeAttributes) ClearContentSize() {
	u.ContentSizePresent = false
}

func (u *ImmutableNodeAttributes) SetStorageSize(storageSize uint64) {
	u.StorageSize = storageSize
	u.StorageSizePresent = true
}

func (u *ImmutableNodeAttributes) GetStorageSize() uint64 {
	return u.StorageSize
}

func (u *ImmutableNodeAttributes) GetStorageSizeWithDefault(_default uint64) uint64 {
	if !u.HasStorageSize() {
		return _default
	}
	return u.StorageSize
}

func (u *ImmutableNodeAttributes) HasStorageSize() bool {
	return u.StorageSizePresent
}

func (u *ImmutableNodeAttributes) ClearStorageSize() {
	u.StorageSizePresent = false
}

func (u *ImmutableNodeAttributes) SetLinkCount(linkCount uint64) {
	u.LinkCount = linkCount
	u.LinkCountPresent = true
}

func (u *ImmutableNodeAttributes) GetLinkCount() uint64 {
	return u.LinkCount
}

func (u *ImmutableNodeAttributes) GetLinkCountWithDefault(_default uint64) uint64 {
	if !u.HasLinkCount() {
		return _default
	}
	return u.LinkCount
}

func (u *ImmutableNodeAttributes) HasLinkCount() bool {
	return u.LinkCountPresent
}

func (u *ImmutableNodeAttributes) ClearLinkCount() {
	u.LinkCountPresent = false
}

func (u *ImmutableNodeAttributes) SetId(id uint64) {
	u.Id = id
	u.IdPresent = true
}

func (u *ImmutableNodeAttributes) GetId() uint64 {
	return u.Id
}

func (u *ImmutableNodeAttributes) GetIdWithDefault(_default uint64) uint64 {
	if !u.HasId() {
		return _default
	}
	return u.Id
}

func (u *ImmutableNodeAttributes) HasId() bool {
	return u.IdPresent
}

func (u *ImmutableNodeAttributes) ClearId() {
	u.IdPresent = false
}

func (u *ImmutableNodeAttributes) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ImmutableNodeAttributes) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type MutableNodeAttributes struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// Time of creation in nanoseconds since the Unix epoch, UTC.
	CreationTime        uint64 `fidl_ordinal:"1"`
	CreationTimePresent bool
	// Time of last modification in nanoseconds since the Unix epoch, UTC.
	ModificationTime        uint64 `fidl_ordinal:"2"`
	ModificationTimePresent bool
}

var _mMutableNodeAttributes = _bindings.CreateLazyMarshaler(MutableNodeAttributes{})

func (msg *MutableNodeAttributes) Marshaler() _bindings.Marshaler {
	return _mMutableNodeAttributes
}

func (u *MutableNodeAttributes) SetCreationTime(creationTime uint64) {
	u.CreationTime = creationTime
	u.CreationTimePresent = true
}

func (u *MutableNodeAttributes) GetCreationTime() uint64 {
	return u.CreationTime
}

func (u *MutableNodeAttributes) GetCreationTimeWithDefault(_default uint64) uint64 {
	if !u.HasCreationTime() {
		return _default
	}
	return u.CreationTime
}

func (u *MutableNodeAttributes) HasCreationTime() bool {
	return u.CreationTimePresent
}

func (u *MutableNodeAttributes) ClearCreationTime() {
	u.CreationTimePresent = false
}

func (u *MutableNodeAttributes) SetModificationTime(modificationTime uint64) {
	u.ModificationTime = modificationTime
	u.ModificationTimePresent = true
}

func (u *MutableNodeAttributes) GetModificationTime() uint64 {
	return u.ModificationTime
}

func (u *MutableNodeAttributes) GetModificationTimeWithDefault(_default uint64) uint64 {
	if !u.HasModificationTime() {
		return _default
	}
	return u.ModificationTime
}

func (u *MutableNodeAttributes) HasModificationTime() bool {
	return u.ModificationTimePresent
}

func (u *MutableNodeAttributes) ClearModificationTime() {
	u.ModificationTimePresent = false
}

func (u *MutableNodeAttributes) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *MutableNodeAttributes) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type NodeOptions struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	Flags         NodeFlags `fidl_ordinal:"1"`
	FlagsPresent  bool
	// Callers may assert the type of the object by setting the
	// protocol corresponding to the expected type:
	//
	// * If the caller expected a directory but the node cannot be
	// accessed as a directory, the error is `ZX_ERR_NOT_DIR`.
	//
	// * If the caller expected a file but the node cannot be
	// accessed as a file, the error is `ZX_ERR_NOT_FILE`.
	//
	// * In other mismatched cases, the error is
	// `ZX_ERR_WRONG_TYPE`.
	//
	// If more than one protocol is present, the resultant protocol
	// may become any one of them. Callers should specify
	// [`NodeFlags.GET_REPRESENTATION`] to receive a
	// [`Node.OnRepresentation`] event, in order to ascertain the
	// protocol.
	//
	// If absent, indicates that the caller accepts any [`Node`]
	// protocol (including [`Node`] itself for connector nodes, for
	// instance).
	Protocols        NodeProtocols `fidl_ordinal:"2"`
	ProtocolsPresent bool
	// Specifies behavior with respect to existence. If an object
	// is to be created, its type is specified by `protocols`; it
	// must be present. If a valid object type cannot be
	// unambiguously inferred e.g. both `directory` and `file` are
	// set, the request must fail.
	Mode        OpenMode `fidl_ordinal:"3"`
	ModePresent bool
	// Requests rights on the new connection according to the
	// specified rules.
	//
	// If absent, inherits at most the rights from the connection
	// where the `Open` call is made. If the path crosses
	// intermediate proxies, a proxy may strip elements from the
	// resulting rights if the intermediate connection does not
	// have the corresponding rights.
	RightsRequest        RightsRequest `fidl_ordinal:"4"`
	RightsRequestPresent bool
}

var _mNodeOptions = _bindings.CreateLazyMarshaler(NodeOptions{})

func (msg *NodeOptions) Marshaler() _bindings.Marshaler {
	return _mNodeOptions
}

func (u *NodeOptions) SetFlags(flags NodeFlags) {
	u.Flags = flags
	u.FlagsPresent = true
}

func (u *NodeOptions) GetFlags() NodeFlags {
	return u.Flags
}

func (u *NodeOptions) GetFlagsWithDefault(_default NodeFlags) NodeFlags {
	if !u.HasFlags() {
		return _default
	}
	return u.Flags
}

func (u *NodeOptions) HasFlags() bool {
	return u.FlagsPresent
}

func (u *NodeOptions) ClearFlags() {
	u.FlagsPresent = false
}

func (u *NodeOptions) SetProtocols(protocols NodeProtocols) {
	u.Protocols = protocols
	u.ProtocolsPresent = true
}

func (u *NodeOptions) GetProtocols() NodeProtocols {
	return u.Protocols
}

func (u *NodeOptions) GetProtocolsWithDefault(_default NodeProtocols) NodeProtocols {
	if !u.HasProtocols() {
		return _default
	}
	return u.Protocols
}

func (u *NodeOptions) HasProtocols() bool {
	return u.ProtocolsPresent
}

func (u *NodeOptions) ClearProtocols() {
	u.ProtocolsPresent = false
}

func (u *NodeOptions) SetMode(mode OpenMode) {
	u.Mode = mode
	u.ModePresent = true
}

func (u *NodeOptions) GetMode() OpenMode {
	return u.Mode
}

func (u *NodeOptions) GetModeWithDefault(_default OpenMode) OpenMode {
	if !u.HasMode() {
		return _default
	}
	return u.Mode
}

func (u *NodeOptions) HasMode() bool {
	return u.ModePresent
}

func (u *NodeOptions) ClearMode() {
	u.ModePresent = false
}

func (u *NodeOptions) SetRightsRequest(rightsRequest RightsRequest) {
	u.RightsRequest = rightsRequest
	u.RightsRequestPresent = true
}

func (u *NodeOptions) GetRightsRequest() RightsRequest {
	return u.RightsRequest
}

func (u *NodeOptions) GetRightsRequestWithDefault(_default RightsRequest) RightsRequest {
	if !u.HasRightsRequest() {
		return _default
	}
	return u.RightsRequest
}

func (u *NodeOptions) HasRightsRequest() bool {
	return u.RightsRequestPresent
}

func (u *NodeOptions) ClearRightsRequest() {
	u.RightsRequestPresent = false
}

func (u *NodeOptions) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *NodeOptions) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type NodeProtocols struct {
	_                struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData    interface{}
	Directory        DirectoryProtocol `fidl_ordinal:"1"`
	DirectoryPresent bool
	File             FileProtocolFlags `fidl_ordinal:"2"`
	FilePresent      bool
}

var _mNodeProtocols = _bindings.CreateLazyMarshaler(NodeProtocols{})

func (msg *NodeProtocols) Marshaler() _bindings.Marshaler {
	return _mNodeProtocols
}

func (u *NodeProtocols) SetDirectory(directory DirectoryProtocol) {
	u.Directory = directory
	u.DirectoryPresent = true
}

func (u *NodeProtocols) GetDirectory() DirectoryProtocol {
	return u.Directory
}

func (u *NodeProtocols) GetDirectoryWithDefault(_default DirectoryProtocol) DirectoryProtocol {
	if !u.HasDirectory() {
		return _default
	}
	return u.Directory
}

func (u *NodeProtocols) HasDirectory() bool {
	return u.DirectoryPresent
}

func (u *NodeProtocols) ClearDirectory() {
	u.DirectoryPresent = false
}

func (u *NodeProtocols) SetFile(file FileProtocolFlags) {
	u.File = file
	u.FilePresent = true
}

func (u *NodeProtocols) GetFile() FileProtocolFlags {
	return u.File
}

func (u *NodeProtocols) GetFileWithDefault(_default FileProtocolFlags) FileProtocolFlags {
	if !u.HasFile() {
		return _default
	}
	return u.File
}

func (u *NodeProtocols) HasFile() bool {
	return u.FilePresent
}

func (u *NodeProtocols) ClearFile() {
	u.FilePresent = false
}

func (u *NodeProtocols) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *NodeProtocols) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type UnlinkOptions struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	Flags         UnlinkFlags `fidl_ordinal:"1"`
	FlagsPresent  bool
}

var _mUnlinkOptions = _bindings.CreateLazyMarshaler(UnlinkOptions{})

func (msg *UnlinkOptions) Marshaler() _bindings.Marshaler {
	return _mUnlinkOptions
}

func (u *UnlinkOptions) SetFlags(flags UnlinkFlags) {
	u.Flags = flags
	u.FlagsPresent = true
}

func (u *UnlinkOptions) GetFlags() UnlinkFlags {
	return u.Flags
}

func (u *UnlinkOptions) GetFlagsWithDefault(_default UnlinkFlags) UnlinkFlags {
	if !u.HasFlags() {
		return _default
	}
	return u.Flags
}

func (u *UnlinkOptions) HasFlags() bool {
	return u.FlagsPresent
}

func (u *UnlinkOptions) ClearFlags() {
	u.FlagsPresent = false
}

func (u *UnlinkOptions) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *UnlinkOptions) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

const (
	AdvisoryLockingAdvisoryLockOrdinal uint64 = 0x6ee9c0ad53ec87aa
)

type AdvisoryLockingWithCtxInterface _bindings.ChannelProxy

// Acquires an advisory lock on the underlying file.
//
// The lock lasts until either this connection is closed or
// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
// explicitly.
//
// Advisory locks are purely advisory. They do not prevent actual read or
// write operations from occurring on the file, either through this
// connection or through other connections.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
// * [`Rights.WRITE_BYTES`] if `request.type` is
//   [`AdvisoryLockType.WRITE`].
//
// # Errors
//
// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
//   example, another connection might hold a conflicting lock type.
// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
//   to acquire the given type of lock.
func (p *AdvisoryLockingWithCtxInterface) AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error) {
	req_ := &advisoryLockingWithCtxAdvisoryLockRequest{Request: request}
	resp_ := &advisoryLockingWithCtxAdvisoryLockResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(AdvisoryLockingAdvisoryLockOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Advisory locking protocol.
//
// This protocol is intended to be composed into the |File| protocol to
// provide support for advisory locking.
//
// Advisory locks are purely advisory. They do not prevent actual read or
// write operations from occurring on the file, either through this
// connection or through other connections.
//
// These primitives are designed to support the flock() and fcntl(),
// specifically F_SETLK, F_SETLKW, and F_GETLK, functionality that code
// running on Fuchsia expects from other operating systems.
type AdvisoryLockingWithCtx interface {
	// Acquires an advisory lock on the underlying file.
	//
	// The lock lasts until either this connection is closed or
	// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
	// explicitly.
	//
	// Advisory locks are purely advisory. They do not prevent actual read or
	// write operations from occurring on the file, either through this
	// connection or through other connections.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
	// * [`Rights.WRITE_BYTES`] if `request.type` is
	//   [`AdvisoryLockType.WRITE`].
	//
	// # Errors
	//
	// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
	//   example, another connection might hold a conflicting lock type.
	// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
	// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
	//   to acquire the given type of lock.
	AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error)
}

type AdvisoryLockingWithCtxTransitionalBase struct{}

type AdvisoryLockingWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewAdvisoryLockingWithCtxInterfaceRequest() (AdvisoryLockingWithCtxInterfaceRequest, *AdvisoryLockingWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return AdvisoryLockingWithCtxInterfaceRequest(req), (*AdvisoryLockingWithCtxInterface)(cli), err
}

type AdvisoryLockingWithCtxStub struct {
	Impl AdvisoryLockingWithCtx
}

func (s_ *AdvisoryLockingWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case AdvisoryLockingAdvisoryLockOrdinal:
		in_ := &advisoryLockingWithCtxAdvisoryLockRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AdvisoryLock(args_.Ctx, (*in_).Request)
		out_ := &advisoryLockingWithCtxAdvisoryLockResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type AdvisoryLockingEventProxy _bindings.ChannelProxy

const (
	DirectoryCloneOrdinal             uint64 = 0x5a61678f293ce16f
	DirectoryDescribeOrdinal          uint64 = 0xffcec215078dea0
	DirectoryOnOpenOrdinal            uint64 = 0x7fc7bbb1dbfd1972
	DirectoryGetAttrOrdinal           uint64 = 0x78985e216314dafd
	DirectorySetAttrOrdinal           uint64 = 0x4186c0f40d938f46
	DirectoryGetFlagsOrdinal          uint64 = 0x5b88fffb8eda3aa1
	DirectorySetFlagsOrdinal          uint64 = 0x5295b76c71fde733
	DirectoryQueryFilesystemOrdinal   uint64 = 0x6f344a1c6b0a0610
	DirectoryOpenOrdinal              uint64 = 0x2c5044561d685ec0
	DirectoryReadDirentsOrdinal       uint64 = 0x3582806bf27faa0a
	DirectoryRewindOrdinal            uint64 = 0x16b1202af0f34c71
	DirectoryGetTokenOrdinal          uint64 = 0x26ae9d18763c8655
	DirectoryLinkOrdinal              uint64 = 0x740604c0c7c930e7
	DirectoryWatchOrdinal             uint64 = 0x5717193a59d66d91
	DirectoryCloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	DirectoryQueryOrdinal             uint64 = 0x2658edee9decfc06
	DirectoryReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	DirectoryOnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	DirectoryGetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	DirectoryGetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	DirectoryUpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	DirectorySyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
	DirectoryAdvisoryLockOrdinal      uint64 = 0x6ee9c0ad53ec87aa
	DirectoryOpen2Ordinal             uint64 = 0x2fbc4fbbff7c54d6
	DirectoryAddInotifyFilterOrdinal  uint64 = 0x1fcddfeabd4b932a
	DirectoryUnlinkOrdinal            uint64 = 0x750a0326a78d7bed
	DirectoryEnumerateOrdinal         uint64 = 0x36a4ca72c332c37d
	DirectoryRenameOrdinal            uint64 = 0x7060e7723b9928de
)

type DirectoryWithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OpenFlags.RIGHT_*`
// - `OpenFlags.APPEND`
// - `OpenFlags.DESCRIBE`
// - `OpenFlags.CLONE_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
// `OpenFlags.CLONE_SAME_RIGHTS`.
func (p *DirectoryWithCtxInterface) Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error {
	req_ := &directoryWithCtxCloneRequest{Flags: flags, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DirectoryCloneOrdinal, req_)
	return err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) Describe(ctx_ _bindings.Context) (NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryDescribeOrdinal, req_, resp_)
	return (*resp_).Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *DirectoryWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *NodeInfo, error) {
	resp_ := &directoryWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryOnOpenOrdinal, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetAttrOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Attributes, err_
}

// Updates information about the node.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *DirectoryWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error) {
	req_ := &directoryWithCtxSetAttrRequest{Flags: flags, Attributes: attributes}
	resp_ := &directoryWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectorySetAttrOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetFlagsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OpenFlags.APPEND`
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error) {
	req_ := &directoryWithCtxSetFlagsRequest{Flags: flags}
	resp_ := &directoryWithCtxSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectorySetFlagsOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Query the filesystem for filesystem-specific information.
func (p *DirectoryWithCtxInterface) QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxQueryFilesystemResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryQueryFilesystemOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Opens a new object relative to this directory object.
//
// `path` may contain multiple segments, separated by "/" characters, and should never be
// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
//
// If an unknown value is sent for flags the connection should be closed.
//
// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
// the `object` channel which will be connected to the opened entity.
//
// Rights are never increased. When you open a nested entity within a directory, you may only
// request the same rights as what the directory connection already has, or a subset of those.
// Exceeding those rights causes an access denied error to be transmitted in the
// `OnOpen` event if applicable, and the `object` connection closed.
//
// `mode` is only used if an object is created and indicates the type of object to be
// created. An unsupported mode will cause the connection to be closed.
// The mode type, if set, must always be consistent with the OpenFlags.DIRECTORY and
// OpenFlags.NOT_DIRECTORY flags, even if an object is not being created. If an object is not
// being created, `mode` is otherwise ignored. If an object is being created and the mode
// type is not set, a directory will be created if OpenFlags.DIRECTORY is set (explicitly or
// implicitly), or otherwise a server chosen object type.
func (p *DirectoryWithCtxInterface) Open(ctx_ _bindings.Context, flags OpenFlags, mode uint32, path string, object NodeWithCtxInterfaceRequest) error {
	req_ := &directoryWithCtxOpenRequest{Flags: flags, Mode: mode, Path: path, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DirectoryOpenOrdinal, req_)
	return err_
}

// Reads a collection of variably sized dirents into a buffer.
// The number of dirents in a directory may be very large: akin to
// calling read multiple times on a file, directories have a seek
// offset which is updated on subsequent calls to ReadDirents.
// Each call to ReadDirents will only return whole dirent structures,
// they will not get split across ReadDirent calls.
//
// These dirents are of the form:
// ```
// struct dirent {
//   // Describes the inode of the entry.
//   uint64 ino;
//   // Describes the length of the dirent name in bytes.
//   uint8 size;
//   // Describes the type of the entry. Aligned with the
//   // POSIX d_type values. Use `DirentType` constants.
//   uint8 type;
//   // Unterminated name of entry.
//   char name[0];
// }
// ```
//
// This method does not require any rights, since one could always probe for
// directory contents by triggering name conflicts during file creation.
func (p *DirectoryWithCtxInterface) ReadDirents(ctx_ _bindings.Context, maxBytes uint64) (int32, []uint8, error) {
	req_ := &directoryWithCtxReadDirentsRequest{MaxBytes: maxBytes}
	resp_ := &directoryWithCtxReadDirentsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryReadDirentsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Dirents, err_
}

// Resets the directory seek offset.
//
// This method does not require any rights, similar to ReadDirents.
func (p *DirectoryWithCtxInterface) Rewind(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxRewindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRewindOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires a token to a Directory which can be used to identify access to it at a later point
// in time. The token will remain valid for as long as the connection requesting the token
// remains open.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *DirectoryWithCtxInterface) GetToken(ctx_ _bindings.Context) (int32, _zx.Handle, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxGetTokenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetTokenOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Token, err_
}

// Creates a link to an object named src by the name dst, within a directory represented by
// token.
//
// `src` must be a resolved object name. Including "/" in the string will
// return `ZX_ERR_INVALID_ARGS`.
//
// `dst` must be a resolved object name. Including "/" in the string will
// return `ZX_ERR_INVALID_ARGS`.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *DirectoryWithCtxInterface) Link(ctx_ _bindings.Context, src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := &directoryWithCtxLinkRequest{Src: src, DstParentToken: dstParentToken, Dst: dst}
	resp_ := &directoryWithCtxLinkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryLinkOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Watches a directory, receiving events of added messages on the
// watcher request channel.
//
// Options must be zero; it is reserved.
//
// This method does not require any rights, similar to ReadDirents.
func (p *DirectoryWithCtxInterface) Watch(ctx_ _bindings.Context, mask WatchMask, options uint32, watcher DirectoryWatcherWithCtxInterfaceRequest) (int32, error) {
	req_ := &directoryWithCtxWatchRequest{Mask: mask, Options: options, Watcher: watcher}
	resp_ := &directoryWithCtxWatchResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryWatchOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *DirectoryWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryCloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *DirectoryWithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryQueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *DirectoryWithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &directoryWithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DirectoryReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *DirectoryWithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &directoryWithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryOnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *DirectoryWithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &directoryWithCtxGetAttributesRequest{Query: query}
	resp_ := &directoryWithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *DirectoryWithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &directoryWithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryUpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *DirectoryWithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &directoryWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectorySyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Acquires an advisory lock on the underlying file.
//
// The lock lasts until either this connection is closed or
// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
// explicitly.
//
// Advisory locks are purely advisory. They do not prevent actual read or
// write operations from occurring on the file, either through this
// connection or through other connections.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
// * [`Rights.WRITE_BYTES`] if `request.type` is
//   [`AdvisoryLockType.WRITE`].
//
// # Errors
//
// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
//   example, another connection might hold a conflicting lock type.
// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
//   to acquire the given type of lock.
func (p *DirectoryWithCtxInterface) AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error) {
	req_ := &directoryWithCtxAdvisoryLockRequest{Request: request}
	resp_ := &directoryWithCtxAdvisoryLockResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdvisoryLockOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Opens or creates a new node relative to this directory node.
//
// This method requires the following rights on the current connection:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.TRAVERSE`]
//
// Errors are presented as an epitaph on the `object_request` channel.
//
// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
//   what is allowed.
// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
func (p *DirectoryWithCtxInterface) Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error {
	req_ := &directoryWithCtxOpen2Request{Path: path, Protocols: protocols, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DirectoryOpen2Ordinal, req_)
	return err_
}

// Adds a new inotify filter for an object relative to this directory object.
//
// + 'filter` is a mask of different inotify events that need to be watched by the server
//   for a specific file/directory.
//
// + `path` may contain multiple segments, separated by "/" characters,
//   and should never be empty; i.e., "" is an invalid path. Paths should not contain
//   a leading "/".
//
// +`watch_descriptor` is client assigned value to identify a filter.
//   Server shouldn't trust the client-assigned watch_descriptor. They should just send it
//   back to the client in the socket.
//   This value is not used by server, but it is returned back as part of InotifyEvent,
//   to help the client correlate filter with events on this filter.
//
// + `socket` is shared between different filter objects i.e every new filter will
//   have a different server end of the socket and there will be a single client end per
//   inotify instance on inotify init.
func (p *DirectoryWithCtxInterface) AddInotifyFilter(ctx_ _bindings.Context, path string, filter InotifyWatchMask, watchDescriptor uint32, socket _zx.Socket) error {
	req_ := &directoryWithCtxAddInotifyFilterRequest{Path: path, Filter: filter, WatchDescriptor: watchDescriptor, Socket: socket}
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAddInotifyFilterOrdinal, req_, resp_)
	return err_
}

// Removes a child node from the this directory's list of entries.
//
// Note: this does not guarantee that the underlying object is destroyed.
// Although the link will be removed from the containing directory,
// objects with multiple references (such as files which are still open)
// will not actually be destroyed until all references are closed.
//
// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
//   [`Rights.WRITE_BYTES`].
// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
//   support writing.
// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
//   containing a remote channel.
// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
//     something other than a directory was found.
//
// Other errors may be returned for filesystem-specific reasons.
//
// This method requires the following rights:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.MODIFY_DIRECTORY`]
func (p *DirectoryWithCtxInterface) Unlink(ctx_ _bindings.Context, name string, options UnlinkOptions) (Directory2UnlinkResult, error) {
	req_ := &directoryWithCtxUnlinkRequest{Name: name, Options: options}
	resp_ := &directoryWithCtxUnlinkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryUnlinkOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Initiates a directory listing operation over the input channel,
// starting at seek offset 0.
//
// This method requires the [`Rights.ENUMERATE`] right. If this right is
// absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
func (p *DirectoryWithCtxInterface) Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error {
	req_ := &directoryWithCtxEnumerateRequest{Options: options, Iterator: iterator}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DirectoryEnumerateOrdinal, req_)
	return err_
}

// Renames a node named `src` to the name `dst`, in a directory represented
// by `dst_parent_token`.
//
// `src` and `dst` must be valid node names.
// See [`Name`] for what constitutes a valid name.
//
// This method requires the following rights on both the current
// connection, and the connection identified by `dst_parent_token`:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.MODIFY_DIRECTORY`]
//
// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
func (p *DirectoryWithCtxInterface) Rename(ctx_ _bindings.Context, src string, dstParentToken _zx.Event, dst string) (Directory2RenameResult, error) {
	req_ := &directoryWithCtxRenameRequest{Src: src, DstParentToken: dstParentToken, Dst: dst}
	resp_ := &directoryWithCtxRenameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRenameOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

type DirectoryWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OpenFlags.RIGHT_*`
	// - `OpenFlags.APPEND`
	// - `OpenFlags.DESCRIBE`
	// - `OpenFlags.CLONE_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
	// `OpenFlags.CLONE_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error)
	// Updates information about the node.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OpenFlags.APPEND`
	//
	// This method does not require any rights.
	SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error)
	// Query the filesystem for filesystem-specific information.
	QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error)
	// Opens a new object relative to this directory object.
	//
	// `path` may contain multiple segments, separated by "/" characters, and should never be
	// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
	// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
	// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
	// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
	//
	// If an unknown value is sent for flags the connection should be closed.
	//
	// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
	// the `object` channel which will be connected to the opened entity.
	//
	// Rights are never increased. When you open a nested entity within a directory, you may only
	// request the same rights as what the directory connection already has, or a subset of those.
	// Exceeding those rights causes an access denied error to be transmitted in the
	// `OnOpen` event if applicable, and the `object` connection closed.
	//
	// `mode` is only used if an object is created and indicates the type of object to be
	// created. An unsupported mode will cause the connection to be closed.
	// The mode type, if set, must always be consistent with the OpenFlags.DIRECTORY and
	// OpenFlags.NOT_DIRECTORY flags, even if an object is not being created. If an object is not
	// being created, `mode` is otherwise ignored. If an object is being created and the mode
	// type is not set, a directory will be created if OpenFlags.DIRECTORY is set (explicitly or
	// implicitly), or otherwise a server chosen object type.
	Open(ctx_ _bindings.Context, flags OpenFlags, mode uint32, path string, object NodeWithCtxInterfaceRequest) error
	// Reads a collection of variably sized dirents into a buffer.
	// The number of dirents in a directory may be very large: akin to
	// calling read multiple times on a file, directories have a seek
	// offset which is updated on subsequent calls to ReadDirents.
	// Each call to ReadDirents will only return whole dirent structures,
	// they will not get split across ReadDirent calls.
	//
	// These dirents are of the form:
	// ```
	// struct dirent {
	//   // Describes the inode of the entry.
	//   uint64 ino;
	//   // Describes the length of the dirent name in bytes.
	//   uint8 size;
	//   // Describes the type of the entry. Aligned with the
	//   // POSIX d_type values. Use `DirentType` constants.
	//   uint8 type;
	//   // Unterminated name of entry.
	//   char name[0];
	// }
	// ```
	//
	// This method does not require any rights, since one could always probe for
	// directory contents by triggering name conflicts during file creation.
	ReadDirents(ctx_ _bindings.Context, maxBytes uint64) (int32, []uint8, error)
	// Resets the directory seek offset.
	//
	// This method does not require any rights, similar to ReadDirents.
	Rewind(ctx_ _bindings.Context) (int32, error)
	// Acquires a token to a Directory which can be used to identify access to it at a later point
	// in time. The token will remain valid for as long as the connection requesting the token
	// remains open.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	GetToken(ctx_ _bindings.Context) (int32, _zx.Handle, error)
	// Creates a link to an object named src by the name dst, within a directory represented by
	// token.
	//
	// `src` must be a resolved object name. Including "/" in the string will
	// return `ZX_ERR_INVALID_ARGS`.
	//
	// `dst` must be a resolved object name. Including "/" in the string will
	// return `ZX_ERR_INVALID_ARGS`.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	Link(ctx_ _bindings.Context, src string, dstParentToken _zx.Handle, dst string) (int32, error)
	// Watches a directory, receiving events of added messages on the
	// watcher request channel.
	//
	// Options must be zero; it is reserved.
	//
	// This method does not require any rights, similar to ReadDirents.
	Watch(ctx_ _bindings.Context, mask WatchMask, options uint32, watcher DirectoryWatcherWithCtxInterfaceRequest) (int32, error)
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
	// Acquires an advisory lock on the underlying file.
	//
	// The lock lasts until either this connection is closed or
	// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
	// explicitly.
	//
	// Advisory locks are purely advisory. They do not prevent actual read or
	// write operations from occurring on the file, either through this
	// connection or through other connections.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
	// * [`Rights.WRITE_BYTES`] if `request.type` is
	//   [`AdvisoryLockType.WRITE`].
	//
	// # Errors
	//
	// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
	//   example, another connection might hold a conflicting lock type.
	// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
	// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
	//   to acquire the given type of lock.
	AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error)
	// Opens or creates a new node relative to this directory node.
	//
	// This method requires the following rights on the current connection:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.TRAVERSE`]
	//
	// Errors are presented as an epitaph on the `object_request` channel.
	//
	// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
	//   what is allowed.
	// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
	Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error
	// Adds a new inotify filter for an object relative to this directory object.
	//
	// + 'filter` is a mask of different inotify events that need to be watched by the server
	//   for a specific file/directory.
	//
	// + `path` may contain multiple segments, separated by "/" characters,
	//   and should never be empty; i.e., "" is an invalid path. Paths should not contain
	//   a leading "/".
	//
	// +`watch_descriptor` is client assigned value to identify a filter.
	//   Server shouldn't trust the client-assigned watch_descriptor. They should just send it
	//   back to the client in the socket.
	//   This value is not used by server, but it is returned back as part of InotifyEvent,
	//   to help the client correlate filter with events on this filter.
	//
	// + `socket` is shared between different filter objects i.e every new filter will
	//   have a different server end of the socket and there will be a single client end per
	//   inotify instance on inotify init.
	AddInotifyFilter(ctx_ _bindings.Context, path string, filter InotifyWatchMask, watchDescriptor uint32, socket _zx.Socket) error
	// Removes a child node from the this directory's list of entries.
	//
	// Note: this does not guarantee that the underlying object is destroyed.
	// Although the link will be removed from the containing directory,
	// objects with multiple references (such as files which are still open)
	// will not actually be destroyed until all references are closed.
	//
	// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
	//   [`Rights.WRITE_BYTES`].
	// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
	//   support writing.
	// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
	// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
	// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
	//   containing a remote channel.
	// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
	//     something other than a directory was found.
	//
	// Other errors may be returned for filesystem-specific reasons.
	//
	// This method requires the following rights:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.MODIFY_DIRECTORY`]
	Unlink(ctx_ _bindings.Context, name string, options UnlinkOptions) (Directory2UnlinkResult, error)
	// Initiates a directory listing operation over the input channel,
	// starting at seek offset 0.
	//
	// This method requires the [`Rights.ENUMERATE`] right. If this right is
	// absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
	Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error
	// Renames a node named `src` to the name `dst`, in a directory represented
	// by `dst_parent_token`.
	//
	// `src` and `dst` must be valid node names.
	// See [`Name`] for what constitutes a valid name.
	//
	// This method requires the following rights on both the current
	// connection, and the connection identified by `dst_parent_token`:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.MODIFY_DIRECTORY`]
	//
	// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
	Rename(ctx_ _bindings.Context, src string, dstParentToken _zx.Event, dst string) (Directory2RenameResult, error)
}

type DirectoryWithCtxTransitionalBase struct{}

func (_ *DirectoryWithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *DirectoryWithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *DirectoryWithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *DirectoryWithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *DirectoryWithCtxTransitionalBase) Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *DirectoryWithCtxTransitionalBase) Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error {
	panic("Not Implemented")
}

type DirectoryWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryWithCtxInterfaceRequest() (DirectoryWithCtxInterfaceRequest, *DirectoryWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryWithCtxInterfaceRequest(req), (*DirectoryWithCtxInterface)(cli), err
}

type DirectoryWithCtxStub struct {
	Impl DirectoryWithCtx
}

func (s_ *DirectoryWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case DirectoryCloneOrdinal:
		in_ := &directoryWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, (*in_).Flags, (*in_).Object)
		return nil, false, err_
	case DirectoryDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := &directoryWithCtxDescribeResponse{Info: info}
		return out_, true, err_
	case DirectoryGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := &directoryWithCtxGetAttrResponse{S: s, Attributes: attributes}
		return out_, true, err_
	case DirectorySetAttrOrdinal:
		in_ := &directoryWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, (*in_).Flags, (*in_).Attributes)
		out_ := &directoryWithCtxSetAttrResponse{S: s}
		return out_, true, err_
	case DirectoryGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.GetFlags(args_.Ctx)
		out_ := &directoryWithCtxGetFlagsResponse{S: s, Flags: flags}
		return out_, true, err_
	case DirectorySetFlagsOrdinal:
		in_ := &directoryWithCtxSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetFlags(args_.Ctx, (*in_).Flags)
		out_ := &directoryWithCtxSetFlagsResponse{S: s}
		return out_, true, err_
	case DirectoryQueryFilesystemOrdinal:
		s, info, err_ := s_.Impl.QueryFilesystem(args_.Ctx)
		out_ := &directoryWithCtxQueryFilesystemResponse{S: s, Info: info}
		return out_, true, err_
	case DirectoryOpenOrdinal:
		in_ := &directoryWithCtxOpenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Open(args_.Ctx, (*in_).Flags, (*in_).Mode, (*in_).Path, (*in_).Object)
		return nil, false, err_
	case DirectoryReadDirentsOrdinal:
		in_ := &directoryWithCtxReadDirentsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, dirents, err_ := s_.Impl.ReadDirents(args_.Ctx, (*in_).MaxBytes)
		out_ := &directoryWithCtxReadDirentsResponse{S: s, Dirents: dirents}
		return out_, true, err_
	case DirectoryRewindOrdinal:
		s, err_ := s_.Impl.Rewind(args_.Ctx)
		out_ := &directoryWithCtxRewindResponse{S: s}
		return out_, true, err_
	case DirectoryGetTokenOrdinal:
		s, token, err_ := s_.Impl.GetToken(args_.Ctx)
		out_ := &directoryWithCtxGetTokenResponse{S: s, Token: token}
		return out_, true, err_
	case DirectoryLinkOrdinal:
		in_ := &directoryWithCtxLinkRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.Link(args_.Ctx, (*in_).Src, (*in_).DstParentToken, (*in_).Dst)
		out_ := &directoryWithCtxLinkResponse{S: s}
		return out_, true, err_
	case DirectoryWatchOrdinal:
		in_ := &directoryWithCtxWatchRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.Watch(args_.Ctx, (*in_).Mask, (*in_).Options, (*in_).Watcher)
		out_ := &directoryWithCtxWatchResponse{S: s}
		return out_, true, err_
	case DirectoryCloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &directoryWithCtxCloseResponse{Result: result}
		return out_, true, err_
	case DirectoryQueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &directoryWithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case DirectoryReopenOrdinal:
		in_ := &directoryWithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case DirectoryGetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case DirectoryGetAttributesOrdinal:
		in_ := &directoryWithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &directoryWithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case DirectoryUpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &directoryWithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case DirectorySyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &directoryWithCtxSyncResponse{Result: result}
		return out_, true, err_
	case DirectoryAdvisoryLockOrdinal:
		in_ := &directoryWithCtxAdvisoryLockRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AdvisoryLock(args_.Ctx, (*in_).Request)
		out_ := &directoryWithCtxAdvisoryLockResponse{Result: result}
		return out_, true, err_
	case DirectoryOpen2Ordinal:
		in_ := &directoryWithCtxOpen2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Open2(args_.Ctx, (*in_).Path, (*in_).Protocols, (*in_).ObjectRequest)
		return nil, false, err_
	case DirectoryAddInotifyFilterOrdinal:
		in_ := &directoryWithCtxAddInotifyFilterRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.AddInotifyFilter(args_.Ctx, (*in_).Path, (*in_).Filter, (*in_).WatchDescriptor, (*in_).Socket)
		return nil, true, err_
	case DirectoryUnlinkOrdinal:
		in_ := &directoryWithCtxUnlinkRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Unlink(args_.Ctx, (*in_).Name, (*in_).Options)
		out_ := &directoryWithCtxUnlinkResponse{Result: result}
		return out_, true, err_
	case DirectoryEnumerateOrdinal:
		in_ := &directoryWithCtxEnumerateRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Enumerate(args_.Ctx, (*in_).Options, (*in_).Iterator)
		return nil, false, err_
	case DirectoryRenameOrdinal:
		in_ := &directoryWithCtxRenameRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Rename(args_.Ctx, (*in_).Src, (*in_).DstParentToken, (*in_).Dst)
		out_ := &directoryWithCtxRenameResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type DirectoryEventProxy _bindings.ChannelProxy

func (p *DirectoryEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := &directoryWithCtxOnOpenResponse{S: s, Info: info}
	return ((*_bindings.ChannelProxy)(p)).Send(DirectoryOnOpenOrdinal, event_)
}
func (p *DirectoryEventProxy) OnRepresentation(payload Representation) error {
	event_ := &directoryWithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(DirectoryOnRepresentationOrdinal, event_)
}

const (
	Directory1CloneOrdinal           uint64 = 0x5a61678f293ce16f
	Directory1DescribeOrdinal        uint64 = 0xffcec215078dea0
	Directory1OnOpenOrdinal          uint64 = 0x7fc7bbb1dbfd1972
	Directory1GetAttrOrdinal         uint64 = 0x78985e216314dafd
	Directory1SetAttrOrdinal         uint64 = 0x4186c0f40d938f46
	Directory1GetFlagsOrdinal        uint64 = 0x5b88fffb8eda3aa1
	Directory1SetFlagsOrdinal        uint64 = 0x5295b76c71fde733
	Directory1QueryFilesystemOrdinal uint64 = 0x6f344a1c6b0a0610
	Directory1OpenOrdinal            uint64 = 0x2c5044561d685ec0
	Directory1ReadDirentsOrdinal     uint64 = 0x3582806bf27faa0a
	Directory1RewindOrdinal          uint64 = 0x16b1202af0f34c71
	Directory1GetTokenOrdinal        uint64 = 0x26ae9d18763c8655
	Directory1LinkOrdinal            uint64 = 0x740604c0c7c930e7
	Directory1WatchOrdinal           uint64 = 0x5717193a59d66d91
)

type Directory1WithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OpenFlags.RIGHT_*`
// - `OpenFlags.APPEND`
// - `OpenFlags.DESCRIBE`
// - `OpenFlags.CLONE_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
// `OpenFlags.CLONE_SAME_RIGHTS`.
func (p *Directory1WithCtxInterface) Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error {
	req_ := &directory1WithCtxCloneRequest{Flags: flags, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Directory1CloneOrdinal, req_)
	return err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *Directory1WithCtxInterface) Describe(ctx_ _bindings.Context) (NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1DescribeOrdinal, req_, resp_)
	return (*resp_).Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *Directory1WithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *NodeInfo, error) {
	resp_ := &directory1WithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(Directory1OnOpenOrdinal, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *Directory1WithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1GetAttrOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Attributes, err_
}

// Updates information about the node.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *Directory1WithCtxInterface) SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error) {
	req_ := &directory1WithCtxSetAttrRequest{Flags: flags, Attributes: attributes}
	resp_ := &directory1WithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1SetAttrOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
func (p *Directory1WithCtxInterface) GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1GetFlagsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OpenFlags.APPEND`
//
// This method does not require any rights.
func (p *Directory1WithCtxInterface) SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error) {
	req_ := &directory1WithCtxSetFlagsRequest{Flags: flags}
	resp_ := &directory1WithCtxSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1SetFlagsOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Query the filesystem for filesystem-specific information.
func (p *Directory1WithCtxInterface) QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxQueryFilesystemResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1QueryFilesystemOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Opens a new object relative to this directory object.
//
// `path` may contain multiple segments, separated by "/" characters, and should never be
// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
//
// If an unknown value is sent for flags the connection should be closed.
//
// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
// the `object` channel which will be connected to the opened entity.
//
// Rights are never increased. When you open a nested entity within a directory, you may only
// request the same rights as what the directory connection already has, or a subset of those.
// Exceeding those rights causes an access denied error to be transmitted in the
// `OnOpen` event if applicable, and the `object` connection closed.
//
// `mode` is only used if an object is created and indicates the type of object to be
// created. An unsupported mode will cause the connection to be closed.
// The mode type, if set, must always be consistent with the OpenFlags.DIRECTORY and
// OpenFlags.NOT_DIRECTORY flags, even if an object is not being created. If an object is not
// being created, `mode` is otherwise ignored. If an object is being created and the mode
// type is not set, a directory will be created if OpenFlags.DIRECTORY is set (explicitly or
// implicitly), or otherwise a server chosen object type.
func (p *Directory1WithCtxInterface) Open(ctx_ _bindings.Context, flags OpenFlags, mode uint32, path string, object NodeWithCtxInterfaceRequest) error {
	req_ := &directory1WithCtxOpenRequest{Flags: flags, Mode: mode, Path: path, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Directory1OpenOrdinal, req_)
	return err_
}

// Reads a collection of variably sized dirents into a buffer.
// The number of dirents in a directory may be very large: akin to
// calling read multiple times on a file, directories have a seek
// offset which is updated on subsequent calls to ReadDirents.
// Each call to ReadDirents will only return whole dirent structures,
// they will not get split across ReadDirent calls.
//
// These dirents are of the form:
// ```
// struct dirent {
//   // Describes the inode of the entry.
//   uint64 ino;
//   // Describes the length of the dirent name in bytes.
//   uint8 size;
//   // Describes the type of the entry. Aligned with the
//   // POSIX d_type values. Use `DirentType` constants.
//   uint8 type;
//   // Unterminated name of entry.
//   char name[0];
// }
// ```
//
// This method does not require any rights, since one could always probe for
// directory contents by triggering name conflicts during file creation.
func (p *Directory1WithCtxInterface) ReadDirents(ctx_ _bindings.Context, maxBytes uint64) (int32, []uint8, error) {
	req_ := &directory1WithCtxReadDirentsRequest{MaxBytes: maxBytes}
	resp_ := &directory1WithCtxReadDirentsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1ReadDirentsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Dirents, err_
}

// Resets the directory seek offset.
//
// This method does not require any rights, similar to ReadDirents.
func (p *Directory1WithCtxInterface) Rewind(ctx_ _bindings.Context) (int32, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxRewindResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1RewindOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires a token to a Directory which can be used to identify access to it at a later point
// in time. The token will remain valid for as long as the connection requesting the token
// remains open.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *Directory1WithCtxInterface) GetToken(ctx_ _bindings.Context) (int32, _zx.Handle, error) {
	var req_ _bindings.Message
	resp_ := &directory1WithCtxGetTokenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1GetTokenOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Token, err_
}

// Creates a link to an object named src by the name dst, within a directory represented by
// token.
//
// `src` must be a resolved object name. Including "/" in the string will
// return `ZX_ERR_INVALID_ARGS`.
//
// `dst` must be a resolved object name. Including "/" in the string will
// return `ZX_ERR_INVALID_ARGS`.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *Directory1WithCtxInterface) Link(ctx_ _bindings.Context, src string, dstParentToken _zx.Handle, dst string) (int32, error) {
	req_ := &directory1WithCtxLinkRequest{Src: src, DstParentToken: dstParentToken, Dst: dst}
	resp_ := &directory1WithCtxLinkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1LinkOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Watches a directory, receiving events of added messages on the
// watcher request channel.
//
// Options must be zero; it is reserved.
//
// This method does not require any rights, similar to ReadDirents.
func (p *Directory1WithCtxInterface) Watch(ctx_ _bindings.Context, mask WatchMask, options uint32, watcher DirectoryWatcherWithCtxInterfaceRequest) (int32, error) {
	req_ := &directory1WithCtxWatchRequest{Mask: mask, Options: options, Watcher: watcher}
	resp_ := &directory1WithCtxWatchResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory1WatchOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Directory defines a node which is capable of containing other Objects.
type Directory1WithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OpenFlags.RIGHT_*`
	// - `OpenFlags.APPEND`
	// - `OpenFlags.DESCRIBE`
	// - `OpenFlags.CLONE_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
	// `OpenFlags.CLONE_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error)
	// Updates information about the node.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OpenFlags.APPEND`
	//
	// This method does not require any rights.
	SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error)
	// Query the filesystem for filesystem-specific information.
	QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error)
	// Opens a new object relative to this directory object.
	//
	// `path` may contain multiple segments, separated by "/" characters, and should never be
	// empty; i.e. "" is an invalid path. A trailing slash implies OpenFlags.DIRECTORY. Components
	// must not be empty (i.e. "foo//bar" is invalid). ".." is disallowed anywhere in the path. "."
	// is only allowed if the path is exactly ".", but not otherwise. A leading '/' is allowed (and
	// is treated the same way as if not present, i.e. "/foo/bar' and "foo/bar" are the same).
	//
	// If an unknown value is sent for flags the connection should be closed.
	//
	// `OpenFlags.RIGHT_*` flags provided in `flags` will restrict access rights on
	// the `object` channel which will be connected to the opened entity.
	//
	// Rights are never increased. When you open a nested entity within a directory, you may only
	// request the same rights as what the directory connection already has, or a subset of those.
	// Exceeding those rights causes an access denied error to be transmitted in the
	// `OnOpen` event if applicable, and the `object` connection closed.
	//
	// `mode` is only used if an object is created and indicates the type of object to be
	// created. An unsupported mode will cause the connection to be closed.
	// The mode type, if set, must always be consistent with the OpenFlags.DIRECTORY and
	// OpenFlags.NOT_DIRECTORY flags, even if an object is not being created. If an object is not
	// being created, `mode` is otherwise ignored. If an object is being created and the mode
	// type is not set, a directory will be created if OpenFlags.DIRECTORY is set (explicitly or
	// implicitly), or otherwise a server chosen object type.
	Open(ctx_ _bindings.Context, flags OpenFlags, mode uint32, path string, object NodeWithCtxInterfaceRequest) error
	// Reads a collection of variably sized dirents into a buffer.
	// The number of dirents in a directory may be very large: akin to
	// calling read multiple times on a file, directories have a seek
	// offset which is updated on subsequent calls to ReadDirents.
	// Each call to ReadDirents will only return whole dirent structures,
	// they will not get split across ReadDirent calls.
	//
	// These dirents are of the form:
	// ```
	// struct dirent {
	//   // Describes the inode of the entry.
	//   uint64 ino;
	//   // Describes the length of the dirent name in bytes.
	//   uint8 size;
	//   // Describes the type of the entry. Aligned with the
	//   // POSIX d_type values. Use `DirentType` constants.
	//   uint8 type;
	//   // Unterminated name of entry.
	//   char name[0];
	// }
	// ```
	//
	// This method does not require any rights, since one could always probe for
	// directory contents by triggering name conflicts during file creation.
	ReadDirents(ctx_ _bindings.Context, maxBytes uint64) (int32, []uint8, error)
	// Resets the directory seek offset.
	//
	// This method does not require any rights, similar to ReadDirents.
	Rewind(ctx_ _bindings.Context) (int32, error)
	// Acquires a token to a Directory which can be used to identify access to it at a later point
	// in time. The token will remain valid for as long as the connection requesting the token
	// remains open.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	GetToken(ctx_ _bindings.Context) (int32, _zx.Handle, error)
	// Creates a link to an object named src by the name dst, within a directory represented by
	// token.
	//
	// `src` must be a resolved object name. Including "/" in the string will
	// return `ZX_ERR_INVALID_ARGS`.
	//
	// `dst` must be a resolved object name. Including "/" in the string will
	// return `ZX_ERR_INVALID_ARGS`.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	Link(ctx_ _bindings.Context, src string, dstParentToken _zx.Handle, dst string) (int32, error)
	// Watches a directory, receiving events of added messages on the
	// watcher request channel.
	//
	// Options must be zero; it is reserved.
	//
	// This method does not require any rights, similar to ReadDirents.
	Watch(ctx_ _bindings.Context, mask WatchMask, options uint32, watcher DirectoryWatcherWithCtxInterfaceRequest) (int32, error)
}

type Directory1WithCtxTransitionalBase struct{}

type Directory1WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDirectory1WithCtxInterfaceRequest() (Directory1WithCtxInterfaceRequest, *Directory1WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return Directory1WithCtxInterfaceRequest(req), (*Directory1WithCtxInterface)(cli), err
}

type Directory1WithCtxStub struct {
	Impl Directory1WithCtx
}

func (s_ *Directory1WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case Directory1CloneOrdinal:
		in_ := &directory1WithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, (*in_).Flags, (*in_).Object)
		return nil, false, err_
	case Directory1DescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := &directory1WithCtxDescribeResponse{Info: info}
		return out_, true, err_
	case Directory1GetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := &directory1WithCtxGetAttrResponse{S: s, Attributes: attributes}
		return out_, true, err_
	case Directory1SetAttrOrdinal:
		in_ := &directory1WithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, (*in_).Flags, (*in_).Attributes)
		out_ := &directory1WithCtxSetAttrResponse{S: s}
		return out_, true, err_
	case Directory1GetFlagsOrdinal:
		s, flags, err_ := s_.Impl.GetFlags(args_.Ctx)
		out_ := &directory1WithCtxGetFlagsResponse{S: s, Flags: flags}
		return out_, true, err_
	case Directory1SetFlagsOrdinal:
		in_ := &directory1WithCtxSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetFlags(args_.Ctx, (*in_).Flags)
		out_ := &directory1WithCtxSetFlagsResponse{S: s}
		return out_, true, err_
	case Directory1QueryFilesystemOrdinal:
		s, info, err_ := s_.Impl.QueryFilesystem(args_.Ctx)
		out_ := &directory1WithCtxQueryFilesystemResponse{S: s, Info: info}
		return out_, true, err_
	case Directory1OpenOrdinal:
		in_ := &directory1WithCtxOpenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Open(args_.Ctx, (*in_).Flags, (*in_).Mode, (*in_).Path, (*in_).Object)
		return nil, false, err_
	case Directory1ReadDirentsOrdinal:
		in_ := &directory1WithCtxReadDirentsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, dirents, err_ := s_.Impl.ReadDirents(args_.Ctx, (*in_).MaxBytes)
		out_ := &directory1WithCtxReadDirentsResponse{S: s, Dirents: dirents}
		return out_, true, err_
	case Directory1RewindOrdinal:
		s, err_ := s_.Impl.Rewind(args_.Ctx)
		out_ := &directory1WithCtxRewindResponse{S: s}
		return out_, true, err_
	case Directory1GetTokenOrdinal:
		s, token, err_ := s_.Impl.GetToken(args_.Ctx)
		out_ := &directory1WithCtxGetTokenResponse{S: s, Token: token}
		return out_, true, err_
	case Directory1LinkOrdinal:
		in_ := &directory1WithCtxLinkRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.Link(args_.Ctx, (*in_).Src, (*in_).DstParentToken, (*in_).Dst)
		out_ := &directory1WithCtxLinkResponse{S: s}
		return out_, true, err_
	case Directory1WatchOrdinal:
		in_ := &directory1WithCtxWatchRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.Watch(args_.Ctx, (*in_).Mask, (*in_).Options, (*in_).Watcher)
		out_ := &directory1WithCtxWatchResponse{S: s}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type Directory1EventProxy _bindings.ChannelProxy

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

const (
	Directory2CloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	Directory2QueryOrdinal             uint64 = 0x2658edee9decfc06
	Directory2ReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	Directory2OnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	Directory2GetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	Directory2GetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	Directory2UpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	Directory2SyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
	Directory2AdvisoryLockOrdinal      uint64 = 0x6ee9c0ad53ec87aa
	Directory2Open2Ordinal             uint64 = 0x2fbc4fbbff7c54d6
	Directory2AddInotifyFilterOrdinal  uint64 = 0x1fcddfeabd4b932a
	Directory2UnlinkOrdinal            uint64 = 0x750a0326a78d7bed
	Directory2EnumerateOrdinal         uint64 = 0x36a4ca72c332c37d
	Directory2RenameOrdinal            uint64 = 0x7060e7723b9928de
)

type Directory2WithCtxInterface _bindings.ChannelProxy

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *Directory2WithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &directory2WithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2CloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *Directory2WithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &directory2WithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2QueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *Directory2WithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &directory2WithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Directory2ReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *Directory2WithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &directory2WithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(Directory2OnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *Directory2WithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2GetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *Directory2WithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &directory2WithCtxGetAttributesRequest{Query: query}
	resp_ := &directory2WithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2GetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *Directory2WithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &directory2WithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2UpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *Directory2WithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &directory2WithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2SyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Acquires an advisory lock on the underlying file.
//
// The lock lasts until either this connection is closed or
// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
// explicitly.
//
// Advisory locks are purely advisory. They do not prevent actual read or
// write operations from occurring on the file, either through this
// connection or through other connections.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
// * [`Rights.WRITE_BYTES`] if `request.type` is
//   [`AdvisoryLockType.WRITE`].
//
// # Errors
//
// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
//   example, another connection might hold a conflicting lock type.
// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
//   to acquire the given type of lock.
func (p *Directory2WithCtxInterface) AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error) {
	req_ := &directory2WithCtxAdvisoryLockRequest{Request: request}
	resp_ := &directory2WithCtxAdvisoryLockResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2AdvisoryLockOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Opens or creates a new node relative to this directory node.
//
// This method requires the following rights on the current connection:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.TRAVERSE`]
//
// Errors are presented as an epitaph on the `object_request` channel.
//
// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
//   what is allowed.
// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
func (p *Directory2WithCtxInterface) Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error {
	req_ := &directory2WithCtxOpen2Request{Path: path, Protocols: protocols, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Directory2Open2Ordinal, req_)
	return err_
}

// Adds a new inotify filter for an object relative to this directory object.
//
// + 'filter` is a mask of different inotify events that need to be watched by the server
//   for a specific file/directory.
//
// + `path` may contain multiple segments, separated by "/" characters,
//   and should never be empty; i.e., "" is an invalid path. Paths should not contain
//   a leading "/".
//
// +`watch_descriptor` is client assigned value to identify a filter.
//   Server shouldn't trust the client-assigned watch_descriptor. They should just send it
//   back to the client in the socket.
//   This value is not used by server, but it is returned back as part of InotifyEvent,
//   to help the client correlate filter with events on this filter.
//
// + `socket` is shared between different filter objects i.e every new filter will
//   have a different server end of the socket and there will be a single client end per
//   inotify instance on inotify init.
func (p *Directory2WithCtxInterface) AddInotifyFilter(ctx_ _bindings.Context, path string, filter InotifyWatchMask, watchDescriptor uint32, socket _zx.Socket) error {
	req_ := &directory2WithCtxAddInotifyFilterRequest{Path: path, Filter: filter, WatchDescriptor: watchDescriptor, Socket: socket}
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2AddInotifyFilterOrdinal, req_, resp_)
	return err_
}

// Removes a child node from the this directory's list of entries.
//
// Note: this does not guarantee that the underlying object is destroyed.
// Although the link will be removed from the containing directory,
// objects with multiple references (such as files which are still open)
// will not actually be destroyed until all references are closed.
//
// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
//   [`Rights.WRITE_BYTES`].
// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
//   support writing.
// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
//   containing a remote channel.
// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
//     something other than a directory was found.
//
// Other errors may be returned for filesystem-specific reasons.
//
// This method requires the following rights:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.MODIFY_DIRECTORY`]
func (p *Directory2WithCtxInterface) Unlink(ctx_ _bindings.Context, name string, options UnlinkOptions) (Directory2UnlinkResult, error) {
	req_ := &directory2WithCtxUnlinkRequest{Name: name, Options: options}
	resp_ := &directory2WithCtxUnlinkResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2UnlinkOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Initiates a directory listing operation over the input channel,
// starting at seek offset 0.
//
// This method requires the [`Rights.ENUMERATE`] right. If this right is
// absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
func (p *Directory2WithCtxInterface) Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error {
	req_ := &directory2WithCtxEnumerateRequest{Options: options, Iterator: iterator}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Directory2EnumerateOrdinal, req_)
	return err_
}

// Renames a node named `src` to the name `dst`, in a directory represented
// by `dst_parent_token`.
//
// `src` and `dst` must be valid node names.
// See [`Name`] for what constitutes a valid name.
//
// This method requires the following rights on both the current
// connection, and the connection identified by `dst_parent_token`:
//
// * [`Rights.ENUMERATE`]
// * [`Rights.MODIFY_DIRECTORY`]
//
// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
func (p *Directory2WithCtxInterface) Rename(ctx_ _bindings.Context, src string, dstParentToken _zx.Event, dst string) (Directory2RenameResult, error) {
	req_ := &directory2WithCtxRenameRequest{Src: src, DstParentToken: dstParentToken, Dst: dst}
	resp_ := &directory2WithCtxRenameResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Directory2RenameOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// A [`Node2`] that is capable of containing other nodes.
type Directory2WithCtx interface {
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
	// Acquires an advisory lock on the underlying file.
	//
	// The lock lasts until either this connection is closed or
	// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
	// explicitly.
	//
	// Advisory locks are purely advisory. They do not prevent actual read or
	// write operations from occurring on the file, either through this
	// connection or through other connections.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
	// * [`Rights.WRITE_BYTES`] if `request.type` is
	//   [`AdvisoryLockType.WRITE`].
	//
	// # Errors
	//
	// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
	//   example, another connection might hold a conflicting lock type.
	// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
	// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
	//   to acquire the given type of lock.
	AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error)
	// Opens or creates a new node relative to this directory node.
	//
	// This method requires the following rights on the current connection:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.TRAVERSE`]
	//
	// Errors are presented as an epitaph on the `object_request` channel.
	//
	// * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
	//   what is allowed.
	// * error `ZX_ERR_BAD_PATH` if `path` is invalid.
	Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error
	// Adds a new inotify filter for an object relative to this directory object.
	//
	// + 'filter` is a mask of different inotify events that need to be watched by the server
	//   for a specific file/directory.
	//
	// + `path` may contain multiple segments, separated by "/" characters,
	//   and should never be empty; i.e., "" is an invalid path. Paths should not contain
	//   a leading "/".
	//
	// +`watch_descriptor` is client assigned value to identify a filter.
	//   Server shouldn't trust the client-assigned watch_descriptor. They should just send it
	//   back to the client in the socket.
	//   This value is not used by server, but it is returned back as part of InotifyEvent,
	//   to help the client correlate filter with events on this filter.
	//
	// + `socket` is shared between different filter objects i.e every new filter will
	//   have a different server end of the socket and there will be a single client end per
	//   inotify instance on inotify init.
	AddInotifyFilter(ctx_ _bindings.Context, path string, filter InotifyWatchMask, watchDescriptor uint32, socket _zx.Socket) error
	// Removes a child node from the this directory's list of entries.
	//
	// Note: this does not guarantee that the underlying object is destroyed.
	// Although the link will be removed from the containing directory,
	// objects with multiple references (such as files which are still open)
	// will not actually be destroyed until all references are closed.
	//
	// * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
	//   [`Rights.WRITE_BYTES`].
	// * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
	//   support writing.
	// * error `ZX_ERR_BAD_PATH` if `name` is invalid.
	// * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.
	// * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,
	//   containing a remote channel.
	// * error `ZX_ERR_NOT_DIR` if the options requested a directory but
	//     something other than a directory was found.
	//
	// Other errors may be returned for filesystem-specific reasons.
	//
	// This method requires the following rights:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.MODIFY_DIRECTORY`]
	Unlink(ctx_ _bindings.Context, name string, options UnlinkOptions) (Directory2UnlinkResult, error)
	// Initiates a directory listing operation over the input channel,
	// starting at seek offset 0.
	//
	// This method requires the [`Rights.ENUMERATE`] right. If this right is
	// absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
	Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error
	// Renames a node named `src` to the name `dst`, in a directory represented
	// by `dst_parent_token`.
	//
	// `src` and `dst` must be valid node names.
	// See [`Name`] for what constitutes a valid name.
	//
	// This method requires the following rights on both the current
	// connection, and the connection identified by `dst_parent_token`:
	//
	// * [`Rights.ENUMERATE`]
	// * [`Rights.MODIFY_DIRECTORY`]
	//
	// * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
	Rename(ctx_ _bindings.Context, src string, dstParentToken _zx.Event, dst string) (Directory2RenameResult, error)
}

type Directory2WithCtxTransitionalBase struct{}

func (_ *Directory2WithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *Directory2WithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *Directory2WithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *Directory2WithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *Directory2WithCtxTransitionalBase) Open2(ctx_ _bindings.Context, path string, protocols ConnectionProtocols, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *Directory2WithCtxTransitionalBase) Enumerate(ctx_ _bindings.Context, options DirectoryEnumerateOptions, iterator DirectoryIteratorWithCtxInterfaceRequest) error {
	panic("Not Implemented")
}

type Directory2WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDirectory2WithCtxInterfaceRequest() (Directory2WithCtxInterfaceRequest, *Directory2WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return Directory2WithCtxInterfaceRequest(req), (*Directory2WithCtxInterface)(cli), err
}

type Directory2WithCtxStub struct {
	Impl Directory2WithCtx
}

func (s_ *Directory2WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case Directory2CloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &directory2WithCtxCloseResponse{Result: result}
		return out_, true, err_
	case Directory2QueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &directory2WithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case Directory2ReopenOrdinal:
		in_ := &directory2WithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case Directory2GetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case Directory2GetAttributesOrdinal:
		in_ := &directory2WithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &directory2WithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case Directory2UpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &directory2WithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case Directory2SyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &directory2WithCtxSyncResponse{Result: result}
		return out_, true, err_
	case Directory2AdvisoryLockOrdinal:
		in_ := &directory2WithCtxAdvisoryLockRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AdvisoryLock(args_.Ctx, (*in_).Request)
		out_ := &directory2WithCtxAdvisoryLockResponse{Result: result}
		return out_, true, err_
	case Directory2Open2Ordinal:
		in_ := &directory2WithCtxOpen2Request{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Open2(args_.Ctx, (*in_).Path, (*in_).Protocols, (*in_).ObjectRequest)
		return nil, false, err_
	case Directory2AddInotifyFilterOrdinal:
		in_ := &directory2WithCtxAddInotifyFilterRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.AddInotifyFilter(args_.Ctx, (*in_).Path, (*in_).Filter, (*in_).WatchDescriptor, (*in_).Socket)
		return nil, true, err_
	case Directory2UnlinkOrdinal:
		in_ := &directory2WithCtxUnlinkRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Unlink(args_.Ctx, (*in_).Name, (*in_).Options)
		out_ := &directory2WithCtxUnlinkResponse{Result: result}
		return out_, true, err_
	case Directory2EnumerateOrdinal:
		in_ := &directory2WithCtxEnumerateRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Enumerate(args_.Ctx, (*in_).Options, (*in_).Iterator)
		return nil, false, err_
	case Directory2RenameOrdinal:
		in_ := &directory2WithCtxRenameRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Rename(args_.Ctx, (*in_).Src, (*in_).DstParentToken, (*in_).Dst)
		out_ := &directory2WithCtxRenameResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type Directory2EventProxy _bindings.ChannelProxy

func (p *Directory2EventProxy) OnRepresentation(payload Representation) error {
	event_ := &directory2WithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(Directory2OnRepresentationOrdinal, event_)
}

const (
	DirectoryIteratorGetNextOrdinal uint64 = 0x3c70af7d00d750eb
)

type DirectoryIteratorWithCtxInterface _bindings.ChannelProxy

// Reads a collection of variably sized directory entries into a buffer.
//
// The number of entries in a directory may be very large: akin to
// calling read multiple times on a file, directories have a seek
// offset which is updated on subsequent calls to `Enumerate`.
// The caller should always use a receiving buffer size as large as the
// maximum channel limit.
//
// When the end of iteration is reached, the returned `entries` vector
// will be empty.
//
// This method does not require any rights, as the rights are checked
// in the [`Directory.Enumerate`] call.
func (p *DirectoryIteratorWithCtxInterface) GetNext(ctx_ _bindings.Context) (DirectoryIteratorGetNextResult, error) {
	var req_ _bindings.Message
	resp_ := &directoryIteratorWithCtxGetNextResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(DirectoryIteratorGetNextOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

type DirectoryIteratorWithCtx interface {
	// Reads a collection of variably sized directory entries into a buffer.
	//
	// The number of entries in a directory may be very large: akin to
	// calling read multiple times on a file, directories have a seek
	// offset which is updated on subsequent calls to `Enumerate`.
	// The caller should always use a receiving buffer size as large as the
	// maximum channel limit.
	//
	// When the end of iteration is reached, the returned `entries` vector
	// will be empty.
	//
	// This method does not require any rights, as the rights are checked
	// in the [`Directory.Enumerate`] call.
	GetNext(ctx_ _bindings.Context) (DirectoryIteratorGetNextResult, error)
}

type DirectoryIteratorWithCtxTransitionalBase struct{}

type DirectoryIteratorWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryIteratorWithCtxInterfaceRequest() (DirectoryIteratorWithCtxInterfaceRequest, *DirectoryIteratorWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryIteratorWithCtxInterfaceRequest(req), (*DirectoryIteratorWithCtxInterface)(cli), err
}

type DirectoryIteratorWithCtxStub struct {
	Impl DirectoryIteratorWithCtx
}

func (s_ *DirectoryIteratorWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case DirectoryIteratorGetNextOrdinal:
		result, err_ := s_.Impl.GetNext(args_.Ctx)
		out_ := &directoryIteratorWithCtxGetNextResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type DirectoryIteratorEventProxy _bindings.ChannelProxy

type DirectoryWatcherWithCtxInterface _bindings.ChannelProxy

// DirectoryWatcher transmits messages from a filesystem server
// about events happening in the filesystem. Clients can register
// new watchers using the `Directory.Watch` method, where they can
// filter which events they want to receive notifications for.
//
// The DirectoryWatcher will send messages of the form:
// ```
// struct {
//   uint8 event;
//   uint8 len;
//   char name[];
// };
// ```
// Where names are NOT null-terminated.
type DirectoryWatcherWithCtx interface {
}

type DirectoryWatcherWithCtxTransitionalBase struct{}

type DirectoryWatcherWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDirectoryWatcherWithCtxInterfaceRequest() (DirectoryWatcherWithCtxInterfaceRequest, *DirectoryWatcherWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DirectoryWatcherWithCtxInterfaceRequest(req), (*DirectoryWatcherWithCtxInterface)(cli), err
}

type DirectoryWatcherWithCtxStub struct {
	Impl DirectoryWatcherWithCtx
}

func (s_ *DirectoryWatcherWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type DirectoryWatcherEventProxy _bindings.ChannelProxy

const (
	FileAdvisoryLockOrdinal      uint64 = 0x6ee9c0ad53ec87aa
	FileCloneOrdinal             uint64 = 0x5a61678f293ce16f
	FileDescribeOrdinal          uint64 = 0xffcec215078dea0
	FileOnOpenOrdinal            uint64 = 0x7fc7bbb1dbfd1972
	FileGetAttrOrdinal           uint64 = 0x78985e216314dafd
	FileSetAttrOrdinal           uint64 = 0x4186c0f40d938f46
	FileGetFlagsOrdinal          uint64 = 0x5b88fffb8eda3aa1
	FileSetFlagsOrdinal          uint64 = 0x5295b76c71fde733
	FileQueryFilesystemOrdinal   uint64 = 0x6f344a1c6b0a0610
	FileCloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	FileQueryOrdinal             uint64 = 0x2658edee9decfc06
	FileReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	FileOnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	FileGetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	FileGetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	FileUpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	FileSyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
	FileSeekOrdinal              uint64 = 0x78079168162c5207
	FileReadOrdinal              uint64 = 0x57e419a298c8ede
	FileWriteOrdinal             uint64 = 0x6a31437832469f82
	FileReadAtOrdinal            uint64 = 0x1607a293a60d723e
	FileWriteAtOrdinal           uint64 = 0x793eefc0045e792b
	FileResizeOrdinal            uint64 = 0x2b80825f0535743a
	FileGetBackingMemoryOrdinal  uint64 = 0xa6a9e654cbf62b
	FileDescribe2Ordinal         uint64 = 0x68b5ac00c62906bc
)

type FileWithCtxInterface _bindings.ChannelProxy

// Acquires an advisory lock on the underlying file.
//
// The lock lasts until either this connection is closed or
// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
// explicitly.
//
// Advisory locks are purely advisory. They do not prevent actual read or
// write operations from occurring on the file, either through this
// connection or through other connections.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
// * [`Rights.WRITE_BYTES`] if `request.type` is
//   [`AdvisoryLockType.WRITE`].
//
// # Errors
//
// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
//   example, another connection might hold a conflicting lock type.
// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
//   to acquire the given type of lock.
func (p *FileWithCtxInterface) AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error) {
	req_ := &fileWithCtxAdvisoryLockRequest{Request: request}
	resp_ := &fileWithCtxAdvisoryLockResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileAdvisoryLockOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OpenFlags.RIGHT_*`
// - `OpenFlags.APPEND`
// - `OpenFlags.DESCRIBE`
// - `OpenFlags.CLONE_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
// `OpenFlags.CLONE_SAME_RIGHTS`.
func (p *FileWithCtxInterface) Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error {
	req_ := &fileWithCtxCloneRequest{Flags: flags, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(FileCloneOrdinal, req_)
	return err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) Describe(ctx_ _bindings.Context) (NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileDescribeOrdinal, req_, resp_)
	return (*resp_).Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *FileWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *NodeInfo, error) {
	resp_ := &fileWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(FileOnOpenOrdinal, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileGetAttrOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Attributes, err_
}

// Updates information about the node.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *FileWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error) {
	req_ := &fileWithCtxSetAttrRequest{Flags: flags, Attributes: attributes}
	resp_ := &fileWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileSetAttrOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileGetFlagsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OpenFlags.APPEND`
//
// This method does not require any rights.
func (p *FileWithCtxInterface) SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error) {
	req_ := &fileWithCtxSetFlagsRequest{Flags: flags}
	resp_ := &fileWithCtxSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileSetFlagsOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Query the filesystem for filesystem-specific information.
func (p *FileWithCtxInterface) QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxQueryFilesystemResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileQueryFilesystemOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *FileWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileCloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *FileWithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileQueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *FileWithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &fileWithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(FileReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *FileWithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &fileWithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(FileOnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileGetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *FileWithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &fileWithCtxGetAttributesRequest{Query: query}
	resp_ := &fileWithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileGetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *FileWithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &fileWithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileUpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &fileWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileSyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Moves the offset at which the next invocation of [`Read`] or [`Write`]
// will occur. The seek offset is specific to each file connection.
//
// + request `origin` the reference point where `offset` will be based on.
// + request `offset` the number of bytes to seek.
// - response `offset_from_start` the adjusted seek offset, from the start
//   of the file.
//
// This method does not require any rights.
func (p *FileWithCtxInterface) Seek(ctx_ _bindings.Context, origin SeekOrigin, offset int64) (File2SeekResult, error) {
	req_ := &fileWithCtxSeekRequest{Origin: origin, Offset: offset}
	resp_ := &fileWithCtxSeekResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileSeekOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Reads up to 'count' bytes at the seek offset.
// The seek offset is moved forward by the number of bytes read.
//
// ## Invariants
//
// * The returned `data.length` will never be greater than `count`.
// * If `data.length` is less than `count`, it means that the seek offset
//   has reached the end of file as part of this operation.
// * If `data.length` is zero while `count` is not, it means that the
//   seek offset is already at or beyond the end of file, and no data could
//   be read.
// * If `count` is zero, the server should perform all the checks ensuring
//   read access without actually read anything, and return an empty
//   `data` vector.
//
// This method requires the [`Rights.READ_BYTES`] right.
//
// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
func (p *FileWithCtxInterface) Read(ctx_ _bindings.Context, count uint64) (File2ReadResult, error) {
	req_ := &fileWithCtxReadRequest{Count: count}
	resp_ := &fileWithCtxReadResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileReadOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Writes data at the seek offset.
// The seek offset is moved forward by the number of bytes written.
// If the file is in append mode, the seek offset is first set to the end
// of the file, followed by the write, in one atomic step.
//
// The file size may grow if the seek offset plus `data.length` is beyond
// the current end of file.
//
// + request `data` the byte buffer to write to the file.
// - response `actual_count` the number of bytes written.
//
// ## Invariants
//
// * The returned `actual_count` will never be greater than `data.length`.
// * If the server is unable to write all the data due to e.g. not enough
//   space, `actual_count` may be less than `data.length`.  If no bytes
//   could be written, an error is returned.
// * If `data.length` is zero, the server should perform all the checks
//   ensuring write access without mutating the file and return a
//   successful write of zero bytes.  The seek offset is still updated if
//   in append mode.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *FileWithCtxInterface) Write(ctx_ _bindings.Context, data []uint8) (File2WriteResult, error) {
	req_ := &fileWithCtxWriteRequest{Data: data}
	resp_ := &fileWithCtxWriteResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileWriteOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Reads up to 'count' bytes at the provided offset.
// Does not affect the seek offset.
//
// ## Invariants
//
// * The returned `data.length` will never be greater than `count`.
// * If `data.length` is less than `count`, it means that `ReadAt` has hit
//   the end of file as part of this operation.
// * If `data.length` is zero while `count` is not, it means that `offset`
//   is at or past the end of file, and no data can be read.
// * If `count` is zero, the server should perform all the checks ensuring
//   read access without actually reading anything, and return an empty
//   `data` vector.
//
// This method requires the [`Rights.READ_BYTES`] right.
//
// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
func (p *FileWithCtxInterface) ReadAt(ctx_ _bindings.Context, count uint64, offset uint64) (File2ReadAtResult, error) {
	req_ := &fileWithCtxReadAtRequest{Count: count, Offset: offset}
	resp_ := &fileWithCtxReadAtResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileReadAtOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Writes data at the provided offset.
// Does not affect the seek offset.
//
// The file size may grow if `offset` plus `data.length` is past the
// current end of file.
//
// + request `data` the byte buffer to write to the file.
// + request `offset` the offset from start of the file to begin writing.
// - response `actual_count` the number of bytes written.
//
// ## Invariants
//
// * The returned `actual_count` will never be greater than `data.length`.
// * If the server is unable to write all the data due to e.g. not enough
//   space, `actual_count` may be less than `data.length`.  If no bytes
//   could be written, an error is returned.
// * If `data.length` is zero, the server should perform all the checks
//   ensuring write access without mutating the file, and will return a
//   successful write of zero bytes.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *FileWithCtxInterface) WriteAt(ctx_ _bindings.Context, data []uint8, offset uint64) (File2WriteAtResult, error) {
	req_ := &fileWithCtxWriteAtRequest{Data: data, Offset: offset}
	resp_ := &fileWithCtxWriteAtResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileWriteAtOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Shrinks or grows the file size to 'length' bytes.
//
// If file size is reduced by this operation, the extra trailing data'
// is discarded.
// If file size is increased by this operation, the extended area appears
// as if it was zeroed.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *FileWithCtxInterface) Resize(ctx_ _bindings.Context, length uint64) (File2ResizeResult, error) {
	req_ := &fileWithCtxResizeRequest{Length: length}
	resp_ := &fileWithCtxResizeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileResizeOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Acquires a [`zx.handle:VMO`] representing this file, if there is one,
// with the requested access rights.
//
// Implementations are not required to implement files backed by VMOs so
// this request may fail. Additionally, implementations may only support
// a certain subset of the flags. Clients should be prepared with fallback
// behavior if this request fails.
//
// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
// implementation is free to choose the semantics of the returned VMO.
//
// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
// - response `vmo` the requested [`zx.handle:VMO`].
// * error a [`zx.status`] value indicating the failure.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
func (p *FileWithCtxInterface) GetBackingMemory(ctx_ _bindings.Context, flags VmoFlags) (File2GetBackingMemoryResult, error) {
	req_ := &fileWithCtxGetBackingMemoryRequest{Flags: flags}
	resp_ := &fileWithCtxGetBackingMemoryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileGetBackingMemoryOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *FileWithCtxInterface) Describe2(ctx_ _bindings.Context) (FileInfo, error) {
	var req_ _bindings.Message
	resp_ := &FileInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(FileDescribe2Ordinal, req_, resp_)
	return (*resp_), err_
}

// A [`File`] that provides [`FileInfo`].
type FileWithCtx interface {
	// Acquires an advisory lock on the underlying file.
	//
	// The lock lasts until either this connection is closed or
	// this method is called with |AdvisoryLockType.UNLOCK| to release the lock
	// explicitly.
	//
	// Advisory locks are purely advisory. They do not prevent actual read or
	// write operations from occurring on the file, either through this
	// connection or through other connections.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].
	// * [`Rights.WRITE_BYTES`] if `request.type` is
	//   [`AdvisoryLockType.WRITE`].
	//
	// # Errors
	//
	// * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For
	//   example, another connection might hold a conflicting lock type.
	// * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.
	// * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights
	//   to acquire the given type of lock.
	AdvisoryLock(ctx_ _bindings.Context, request AdvisoryLockRequest) (AdvisoryLockingAdvisoryLockResult, error)
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OpenFlags.RIGHT_*`
	// - `OpenFlags.APPEND`
	// - `OpenFlags.DESCRIBE`
	// - `OpenFlags.CLONE_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
	// `OpenFlags.CLONE_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error)
	// Updates information about the node.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OpenFlags.APPEND`
	//
	// This method does not require any rights.
	SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error)
	// Query the filesystem for filesystem-specific information.
	QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error)
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
	// Moves the offset at which the next invocation of [`Read`] or [`Write`]
	// will occur. The seek offset is specific to each file connection.
	//
	// + request `origin` the reference point where `offset` will be based on.
	// + request `offset` the number of bytes to seek.
	// - response `offset_from_start` the adjusted seek offset, from the start
	//   of the file.
	//
	// This method does not require any rights.
	Seek(ctx_ _bindings.Context, origin SeekOrigin, offset int64) (File2SeekResult, error)
	// Reads up to 'count' bytes at the seek offset.
	// The seek offset is moved forward by the number of bytes read.
	//
	// ## Invariants
	//
	// * The returned `data.length` will never be greater than `count`.
	// * If `data.length` is less than `count`, it means that the seek offset
	//   has reached the end of file as part of this operation.
	// * If `data.length` is zero while `count` is not, it means that the
	//   seek offset is already at or beyond the end of file, and no data could
	//   be read.
	// * If `count` is zero, the server should perform all the checks ensuring
	//   read access without actually read anything, and return an empty
	//   `data` vector.
	//
	// This method requires the [`Rights.READ_BYTES`] right.
	//
	// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
	Read(ctx_ _bindings.Context, count uint64) (File2ReadResult, error)
	// Writes data at the seek offset.
	// The seek offset is moved forward by the number of bytes written.
	// If the file is in append mode, the seek offset is first set to the end
	// of the file, followed by the write, in one atomic step.
	//
	// The file size may grow if the seek offset plus `data.length` is beyond
	// the current end of file.
	//
	// + request `data` the byte buffer to write to the file.
	// - response `actual_count` the number of bytes written.
	//
	// ## Invariants
	//
	// * The returned `actual_count` will never be greater than `data.length`.
	// * If the server is unable to write all the data due to e.g. not enough
	//   space, `actual_count` may be less than `data.length`.  If no bytes
	//   could be written, an error is returned.
	// * If `data.length` is zero, the server should perform all the checks
	//   ensuring write access without mutating the file and return a
	//   successful write of zero bytes.  The seek offset is still updated if
	//   in append mode.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	Write(ctx_ _bindings.Context, data []uint8) (File2WriteResult, error)
	// Reads up to 'count' bytes at the provided offset.
	// Does not affect the seek offset.
	//
	// ## Invariants
	//
	// * The returned `data.length` will never be greater than `count`.
	// * If `data.length` is less than `count`, it means that `ReadAt` has hit
	//   the end of file as part of this operation.
	// * If `data.length` is zero while `count` is not, it means that `offset`
	//   is at or past the end of file, and no data can be read.
	// * If `count` is zero, the server should perform all the checks ensuring
	//   read access without actually reading anything, and return an empty
	//   `data` vector.
	//
	// This method requires the [`Rights.READ_BYTES`] right.
	//
	// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
	ReadAt(ctx_ _bindings.Context, count uint64, offset uint64) (File2ReadAtResult, error)
	// Writes data at the provided offset.
	// Does not affect the seek offset.
	//
	// The file size may grow if `offset` plus `data.length` is past the
	// current end of file.
	//
	// + request `data` the byte buffer to write to the file.
	// + request `offset` the offset from start of the file to begin writing.
	// - response `actual_count` the number of bytes written.
	//
	// ## Invariants
	//
	// * The returned `actual_count` will never be greater than `data.length`.
	// * If the server is unable to write all the data due to e.g. not enough
	//   space, `actual_count` may be less than `data.length`.  If no bytes
	//   could be written, an error is returned.
	// * If `data.length` is zero, the server should perform all the checks
	//   ensuring write access without mutating the file, and will return a
	//   successful write of zero bytes.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	WriteAt(ctx_ _bindings.Context, data []uint8, offset uint64) (File2WriteAtResult, error)
	// Shrinks or grows the file size to 'length' bytes.
	//
	// If file size is reduced by this operation, the extra trailing data'
	// is discarded.
	// If file size is increased by this operation, the extended area appears
	// as if it was zeroed.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	Resize(ctx_ _bindings.Context, length uint64) (File2ResizeResult, error)
	// Acquires a [`zx.handle:VMO`] representing this file, if there is one,
	// with the requested access rights.
	//
	// Implementations are not required to implement files backed by VMOs so
	// this request may fail. Additionally, implementations may only support
	// a certain subset of the flags. Clients should be prepared with fallback
	// behavior if this request fails.
	//
	// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
	// implementation is free to choose the semantics of the returned VMO.
	//
	// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
	// - response `vmo` the requested [`zx.handle:VMO`].
	// * error a [`zx.status`] value indicating the failure.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
	// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
	// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
	GetBackingMemory(ctx_ _bindings.Context, flags VmoFlags) (File2GetBackingMemoryResult, error)
	Describe2(ctx_ _bindings.Context) (FileInfo, error)
}

type FileWithCtxTransitionalBase struct{}

func (_ *FileWithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *FileWithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *FileWithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *FileWithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}

type FileWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewFileWithCtxInterfaceRequest() (FileWithCtxInterfaceRequest, *FileWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return FileWithCtxInterfaceRequest(req), (*FileWithCtxInterface)(cli), err
}

type FileWithCtxStub struct {
	Impl FileWithCtx
}

func (s_ *FileWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case FileAdvisoryLockOrdinal:
		in_ := &fileWithCtxAdvisoryLockRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AdvisoryLock(args_.Ctx, (*in_).Request)
		out_ := &fileWithCtxAdvisoryLockResponse{Result: result}
		return out_, true, err_
	case FileCloneOrdinal:
		in_ := &fileWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, (*in_).Flags, (*in_).Object)
		return nil, false, err_
	case FileDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := &fileWithCtxDescribeResponse{Info: info}
		return out_, true, err_
	case FileGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := &fileWithCtxGetAttrResponse{S: s, Attributes: attributes}
		return out_, true, err_
	case FileSetAttrOrdinal:
		in_ := &fileWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, (*in_).Flags, (*in_).Attributes)
		out_ := &fileWithCtxSetAttrResponse{S: s}
		return out_, true, err_
	case FileGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.GetFlags(args_.Ctx)
		out_ := &fileWithCtxGetFlagsResponse{S: s, Flags: flags}
		return out_, true, err_
	case FileSetFlagsOrdinal:
		in_ := &fileWithCtxSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetFlags(args_.Ctx, (*in_).Flags)
		out_ := &fileWithCtxSetFlagsResponse{S: s}
		return out_, true, err_
	case FileQueryFilesystemOrdinal:
		s, info, err_ := s_.Impl.QueryFilesystem(args_.Ctx)
		out_ := &fileWithCtxQueryFilesystemResponse{S: s, Info: info}
		return out_, true, err_
	case FileCloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &fileWithCtxCloseResponse{Result: result}
		return out_, true, err_
	case FileQueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &fileWithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case FileReopenOrdinal:
		in_ := &fileWithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case FileGetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case FileGetAttributesOrdinal:
		in_ := &fileWithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &fileWithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case FileUpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &fileWithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case FileSyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &fileWithCtxSyncResponse{Result: result}
		return out_, true, err_
	case FileSeekOrdinal:
		in_ := &fileWithCtxSeekRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Seek(args_.Ctx, (*in_).Origin, (*in_).Offset)
		out_ := &fileWithCtxSeekResponse{Result: result}
		return out_, true, err_
	case FileReadOrdinal:
		in_ := &fileWithCtxReadRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Read(args_.Ctx, (*in_).Count)
		out_ := &fileWithCtxReadResponse{Result: result}
		return out_, true, err_
	case FileWriteOrdinal:
		in_ := &fileWithCtxWriteRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Write(args_.Ctx, (*in_).Data)
		out_ := &fileWithCtxWriteResponse{Result: result}
		return out_, true, err_
	case FileReadAtOrdinal:
		in_ := &fileWithCtxReadAtRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.ReadAt(args_.Ctx, (*in_).Count, (*in_).Offset)
		out_ := &fileWithCtxReadAtResponse{Result: result}
		return out_, true, err_
	case FileWriteAtOrdinal:
		in_ := &fileWithCtxWriteAtRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.WriteAt(args_.Ctx, (*in_).Data, (*in_).Offset)
		out_ := &fileWithCtxWriteAtResponse{Result: result}
		return out_, true, err_
	case FileResizeOrdinal:
		in_ := &fileWithCtxResizeRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Resize(args_.Ctx, (*in_).Length)
		out_ := &fileWithCtxResizeResponse{Result: result}
		return out_, true, err_
	case FileGetBackingMemoryOrdinal:
		in_ := &fileWithCtxGetBackingMemoryRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetBackingMemory(args_.Ctx, (*in_).Flags)
		out_ := &fileWithCtxGetBackingMemoryResponse{Result: result}
		return out_, true, err_
	case FileDescribe2Ordinal:
		payload, err_ := s_.Impl.Describe2(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type FileEventProxy _bindings.ChannelProxy

func (p *FileEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := &fileWithCtxOnOpenResponse{S: s, Info: info}
	return ((*_bindings.ChannelProxy)(p)).Send(FileOnOpenOrdinal, event_)
}
func (p *FileEventProxy) OnRepresentation(payload Representation) error {
	event_ := &fileWithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(FileOnRepresentationOrdinal, event_)
}

const (
	File2CloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	File2QueryOrdinal             uint64 = 0x2658edee9decfc06
	File2ReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	File2OnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	File2GetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	File2GetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	File2UpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	File2SyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
	File2SeekOrdinal              uint64 = 0x78079168162c5207
	File2ReadOrdinal              uint64 = 0x57e419a298c8ede
	File2WriteOrdinal             uint64 = 0x6a31437832469f82
	File2ReadAtOrdinal            uint64 = 0x1607a293a60d723e
	File2WriteAtOrdinal           uint64 = 0x793eefc0045e792b
	File2ResizeOrdinal            uint64 = 0x2b80825f0535743a
	File2GetBackingMemoryOrdinal  uint64 = 0xa6a9e654cbf62b
)

type File2WithCtxInterface _bindings.ChannelProxy

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *File2WithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &file2WithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2CloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *File2WithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &file2WithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2QueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *File2WithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &file2WithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(File2ReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *File2WithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &file2WithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(File2OnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *File2WithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2GetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *File2WithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &file2WithCtxGetAttributesRequest{Query: query}
	resp_ := &file2WithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2GetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *File2WithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &file2WithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2UpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *File2WithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &file2WithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2SyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Moves the offset at which the next invocation of [`Read`] or [`Write`]
// will occur. The seek offset is specific to each file connection.
//
// + request `origin` the reference point where `offset` will be based on.
// + request `offset` the number of bytes to seek.
// - response `offset_from_start` the adjusted seek offset, from the start
//   of the file.
//
// This method does not require any rights.
func (p *File2WithCtxInterface) Seek(ctx_ _bindings.Context, origin SeekOrigin, offset int64) (File2SeekResult, error) {
	req_ := &file2WithCtxSeekRequest{Origin: origin, Offset: offset}
	resp_ := &file2WithCtxSeekResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2SeekOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Reads up to 'count' bytes at the seek offset.
// The seek offset is moved forward by the number of bytes read.
//
// ## Invariants
//
// * The returned `data.length` will never be greater than `count`.
// * If `data.length` is less than `count`, it means that the seek offset
//   has reached the end of file as part of this operation.
// * If `data.length` is zero while `count` is not, it means that the
//   seek offset is already at or beyond the end of file, and no data could
//   be read.
// * If `count` is zero, the server should perform all the checks ensuring
//   read access without actually read anything, and return an empty
//   `data` vector.
//
// This method requires the [`Rights.READ_BYTES`] right.
//
// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
func (p *File2WithCtxInterface) Read(ctx_ _bindings.Context, count uint64) (File2ReadResult, error) {
	req_ := &file2WithCtxReadRequest{Count: count}
	resp_ := &file2WithCtxReadResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2ReadOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Writes data at the seek offset.
// The seek offset is moved forward by the number of bytes written.
// If the file is in append mode, the seek offset is first set to the end
// of the file, followed by the write, in one atomic step.
//
// The file size may grow if the seek offset plus `data.length` is beyond
// the current end of file.
//
// + request `data` the byte buffer to write to the file.
// - response `actual_count` the number of bytes written.
//
// ## Invariants
//
// * The returned `actual_count` will never be greater than `data.length`.
// * If the server is unable to write all the data due to e.g. not enough
//   space, `actual_count` may be less than `data.length`.  If no bytes
//   could be written, an error is returned.
// * If `data.length` is zero, the server should perform all the checks
//   ensuring write access without mutating the file and return a
//   successful write of zero bytes.  The seek offset is still updated if
//   in append mode.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *File2WithCtxInterface) Write(ctx_ _bindings.Context, data []uint8) (File2WriteResult, error) {
	req_ := &file2WithCtxWriteRequest{Data: data}
	resp_ := &file2WithCtxWriteResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2WriteOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Reads up to 'count' bytes at the provided offset.
// Does not affect the seek offset.
//
// ## Invariants
//
// * The returned `data.length` will never be greater than `count`.
// * If `data.length` is less than `count`, it means that `ReadAt` has hit
//   the end of file as part of this operation.
// * If `data.length` is zero while `count` is not, it means that `offset`
//   is at or past the end of file, and no data can be read.
// * If `count` is zero, the server should perform all the checks ensuring
//   read access without actually reading anything, and return an empty
//   `data` vector.
//
// This method requires the [`Rights.READ_BYTES`] right.
//
// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
func (p *File2WithCtxInterface) ReadAt(ctx_ _bindings.Context, count uint64, offset uint64) (File2ReadAtResult, error) {
	req_ := &file2WithCtxReadAtRequest{Count: count, Offset: offset}
	resp_ := &file2WithCtxReadAtResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2ReadAtOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Writes data at the provided offset.
// Does not affect the seek offset.
//
// The file size may grow if `offset` plus `data.length` is past the
// current end of file.
//
// + request `data` the byte buffer to write to the file.
// + request `offset` the offset from start of the file to begin writing.
// - response `actual_count` the number of bytes written.
//
// ## Invariants
//
// * The returned `actual_count` will never be greater than `data.length`.
// * If the server is unable to write all the data due to e.g. not enough
//   space, `actual_count` may be less than `data.length`.  If no bytes
//   could be written, an error is returned.
// * If `data.length` is zero, the server should perform all the checks
//   ensuring write access without mutating the file, and will return a
//   successful write of zero bytes.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *File2WithCtxInterface) WriteAt(ctx_ _bindings.Context, data []uint8, offset uint64) (File2WriteAtResult, error) {
	req_ := &file2WithCtxWriteAtRequest{Data: data, Offset: offset}
	resp_ := &file2WithCtxWriteAtResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2WriteAtOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Shrinks or grows the file size to 'length' bytes.
//
// If file size is reduced by this operation, the extra trailing data'
// is discarded.
// If file size is increased by this operation, the extended area appears
// as if it was zeroed.
//
// This method requires the [`Rights.WRITE_BYTES`] right.
func (p *File2WithCtxInterface) Resize(ctx_ _bindings.Context, length uint64) (File2ResizeResult, error) {
	req_ := &file2WithCtxResizeRequest{Length: length}
	resp_ := &file2WithCtxResizeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2ResizeOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Acquires a [`zx.handle:VMO`] representing this file, if there is one,
// with the requested access rights.
//
// Implementations are not required to implement files backed by VMOs so
// this request may fail. Additionally, implementations may only support
// a certain subset of the flags. Clients should be prepared with fallback
// behavior if this request fails.
//
// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
// implementation is free to choose the semantics of the returned VMO.
//
// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
// - response `vmo` the requested [`zx.handle:VMO`].
// * error a [`zx.status`] value indicating the failure.
//
// This method requires the following rights:
//
// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
func (p *File2WithCtxInterface) GetBackingMemory(ctx_ _bindings.Context, flags VmoFlags) (File2GetBackingMemoryResult, error) {
	req_ := &file2WithCtxGetBackingMemoryRequest{Flags: flags}
	resp_ := &file2WithCtxGetBackingMemoryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(File2GetBackingMemoryOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// A [`Node2`] which contains a sequence of bytes of definite
// length.
//
// NOTE: cloned connections do not share their seek offset with their source
// connection.
type File2WithCtx interface {
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
	// Moves the offset at which the next invocation of [`Read`] or [`Write`]
	// will occur. The seek offset is specific to each file connection.
	//
	// + request `origin` the reference point where `offset` will be based on.
	// + request `offset` the number of bytes to seek.
	// - response `offset_from_start` the adjusted seek offset, from the start
	//   of the file.
	//
	// This method does not require any rights.
	Seek(ctx_ _bindings.Context, origin SeekOrigin, offset int64) (File2SeekResult, error)
	// Reads up to 'count' bytes at the seek offset.
	// The seek offset is moved forward by the number of bytes read.
	//
	// ## Invariants
	//
	// * The returned `data.length` will never be greater than `count`.
	// * If `data.length` is less than `count`, it means that the seek offset
	//   has reached the end of file as part of this operation.
	// * If `data.length` is zero while `count` is not, it means that the
	//   seek offset is already at or beyond the end of file, and no data could
	//   be read.
	// * If `count` is zero, the server should perform all the checks ensuring
	//   read access without actually read anything, and return an empty
	//   `data` vector.
	//
	// This method requires the [`Rights.READ_BYTES`] right.
	//
	// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
	Read(ctx_ _bindings.Context, count uint64) (File2ReadResult, error)
	// Writes data at the seek offset.
	// The seek offset is moved forward by the number of bytes written.
	// If the file is in append mode, the seek offset is first set to the end
	// of the file, followed by the write, in one atomic step.
	//
	// The file size may grow if the seek offset plus `data.length` is beyond
	// the current end of file.
	//
	// + request `data` the byte buffer to write to the file.
	// - response `actual_count` the number of bytes written.
	//
	// ## Invariants
	//
	// * The returned `actual_count` will never be greater than `data.length`.
	// * If the server is unable to write all the data due to e.g. not enough
	//   space, `actual_count` may be less than `data.length`.  If no bytes
	//   could be written, an error is returned.
	// * If `data.length` is zero, the server should perform all the checks
	//   ensuring write access without mutating the file and return a
	//   successful write of zero bytes.  The seek offset is still updated if
	//   in append mode.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	Write(ctx_ _bindings.Context, data []uint8) (File2WriteResult, error)
	// Reads up to 'count' bytes at the provided offset.
	// Does not affect the seek offset.
	//
	// ## Invariants
	//
	// * The returned `data.length` will never be greater than `count`.
	// * If `data.length` is less than `count`, it means that `ReadAt` has hit
	//   the end of file as part of this operation.
	// * If `data.length` is zero while `count` is not, it means that `offset`
	//   is at or past the end of file, and no data can be read.
	// * If `count` is zero, the server should perform all the checks ensuring
	//   read access without actually reading anything, and return an empty
	//   `data` vector.
	//
	// This method requires the [`Rights.READ_BYTES`] right.
	//
	// Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.
	ReadAt(ctx_ _bindings.Context, count uint64, offset uint64) (File2ReadAtResult, error)
	// Writes data at the provided offset.
	// Does not affect the seek offset.
	//
	// The file size may grow if `offset` plus `data.length` is past the
	// current end of file.
	//
	// + request `data` the byte buffer to write to the file.
	// + request `offset` the offset from start of the file to begin writing.
	// - response `actual_count` the number of bytes written.
	//
	// ## Invariants
	//
	// * The returned `actual_count` will never be greater than `data.length`.
	// * If the server is unable to write all the data due to e.g. not enough
	//   space, `actual_count` may be less than `data.length`.  If no bytes
	//   could be written, an error is returned.
	// * If `data.length` is zero, the server should perform all the checks
	//   ensuring write access without mutating the file, and will return a
	//   successful write of zero bytes.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	WriteAt(ctx_ _bindings.Context, data []uint8, offset uint64) (File2WriteAtResult, error)
	// Shrinks or grows the file size to 'length' bytes.
	//
	// If file size is reduced by this operation, the extra trailing data'
	// is discarded.
	// If file size is increased by this operation, the extended area appears
	// as if it was zeroed.
	//
	// This method requires the [`Rights.WRITE_BYTES`] right.
	Resize(ctx_ _bindings.Context, length uint64) (File2ResizeResult, error)
	// Acquires a [`zx.handle:VMO`] representing this file, if there is one,
	// with the requested access rights.
	//
	// Implementations are not required to implement files backed by VMOs so
	// this request may fail. Additionally, implementations may only support
	// a certain subset of the flags. Clients should be prepared with fallback
	// behavior if this request fails.
	//
	// If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the
	// implementation is free to choose the semantics of the returned VMO.
	//
	// + request `flags` a [`VmoFlags`] indicating the desired mode of access.
	// - response `vmo` the requested [`zx.handle:VMO`].
	// * error a [`zx.status`] value indicating the failure.
	//
	// This method requires the following rights:
	//
	// * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
	// * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
	// * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
	GetBackingMemory(ctx_ _bindings.Context, flags VmoFlags) (File2GetBackingMemoryResult, error)
}

type File2WithCtxTransitionalBase struct{}

func (_ *File2WithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *File2WithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *File2WithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *File2WithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}

type File2WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewFile2WithCtxInterfaceRequest() (File2WithCtxInterfaceRequest, *File2WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return File2WithCtxInterfaceRequest(req), (*File2WithCtxInterface)(cli), err
}

type File2WithCtxStub struct {
	Impl File2WithCtx
}

func (s_ *File2WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case File2CloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &file2WithCtxCloseResponse{Result: result}
		return out_, true, err_
	case File2QueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &file2WithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case File2ReopenOrdinal:
		in_ := &file2WithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case File2GetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case File2GetAttributesOrdinal:
		in_ := &file2WithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &file2WithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case File2UpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &file2WithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case File2SyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &file2WithCtxSyncResponse{Result: result}
		return out_, true, err_
	case File2SeekOrdinal:
		in_ := &file2WithCtxSeekRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Seek(args_.Ctx, (*in_).Origin, (*in_).Offset)
		out_ := &file2WithCtxSeekResponse{Result: result}
		return out_, true, err_
	case File2ReadOrdinal:
		in_ := &file2WithCtxReadRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Read(args_.Ctx, (*in_).Count)
		out_ := &file2WithCtxReadResponse{Result: result}
		return out_, true, err_
	case File2WriteOrdinal:
		in_ := &file2WithCtxWriteRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Write(args_.Ctx, (*in_).Data)
		out_ := &file2WithCtxWriteResponse{Result: result}
		return out_, true, err_
	case File2ReadAtOrdinal:
		in_ := &file2WithCtxReadAtRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.ReadAt(args_.Ctx, (*in_).Count, (*in_).Offset)
		out_ := &file2WithCtxReadAtResponse{Result: result}
		return out_, true, err_
	case File2WriteAtOrdinal:
		in_ := &file2WithCtxWriteAtRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.WriteAt(args_.Ctx, (*in_).Data, (*in_).Offset)
		out_ := &file2WithCtxWriteAtResponse{Result: result}
		return out_, true, err_
	case File2ResizeOrdinal:
		in_ := &file2WithCtxResizeRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.Resize(args_.Ctx, (*in_).Length)
		out_ := &file2WithCtxResizeResponse{Result: result}
		return out_, true, err_
	case File2GetBackingMemoryOrdinal:
		in_ := &file2WithCtxGetBackingMemoryRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetBackingMemory(args_.Ctx, (*in_).Flags)
		out_ := &file2WithCtxGetBackingMemoryResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type File2EventProxy _bindings.ChannelProxy

func (p *File2EventProxy) OnRepresentation(payload Representation) error {
	event_ := &file2WithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(File2OnRepresentationOrdinal, event_)
}

type InotifierWithCtxInterface _bindings.ChannelProxy

// Inotifier implements the linux Inotify functionality.
// It provides a mechanism for monitoring filesystem
// events.  Inotify can be used to monitor individual files, or to
// monitor directories.  When a directory is monitored, inotify will
// return events for the directory itself, and for files inside the
// directory.
type InotifierWithCtx interface {
}

type InotifierWithCtxTransitionalBase struct{}

type InotifierWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewInotifierWithCtxInterfaceRequest() (InotifierWithCtxInterfaceRequest, *InotifierWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return InotifierWithCtxInterfaceRequest(req), (*InotifierWithCtxInterface)(cli), err
}

type InotifierWithCtxStub struct {
	Impl InotifierWithCtx
}

func (s_ *InotifierWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type InotifierEventProxy _bindings.ChannelProxy

const (
	NodeCloneOrdinal             uint64 = 0x5a61678f293ce16f
	NodeDescribeOrdinal          uint64 = 0xffcec215078dea0
	NodeOnOpenOrdinal            uint64 = 0x7fc7bbb1dbfd1972
	NodeGetAttrOrdinal           uint64 = 0x78985e216314dafd
	NodeSetAttrOrdinal           uint64 = 0x4186c0f40d938f46
	NodeGetFlagsOrdinal          uint64 = 0x5b88fffb8eda3aa1
	NodeSetFlagsOrdinal          uint64 = 0x5295b76c71fde733
	NodeQueryFilesystemOrdinal   uint64 = 0x6f344a1c6b0a0610
	NodeCloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	NodeQueryOrdinal             uint64 = 0x2658edee9decfc06
	NodeReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	NodeOnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	NodeGetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	NodeGetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	NodeUpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	NodeSyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
)

type NodeWithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OpenFlags.RIGHT_*`
// - `OpenFlags.APPEND`
// - `OpenFlags.DESCRIBE`
// - `OpenFlags.CLONE_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
// `OpenFlags.CLONE_SAME_RIGHTS`.
func (p *NodeWithCtxInterface) Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error {
	req_ := &nodeWithCtxCloneRequest{Flags: flags, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(NodeCloneOrdinal, req_)
	return err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) Describe(ctx_ _bindings.Context) (NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeDescribeOrdinal, req_, resp_)
	return (*resp_).Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *NodeWithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *NodeInfo, error) {
	resp_ := &nodeWithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(NodeOnOpenOrdinal, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeGetAttrOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Attributes, err_
}

// Updates information about the node.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *NodeWithCtxInterface) SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error) {
	req_ := &nodeWithCtxSetAttrRequest{Flags: flags, Attributes: attributes}
	resp_ := &nodeWithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeSetAttrOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeGetFlagsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OpenFlags.APPEND`
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error) {
	req_ := &nodeWithCtxSetFlagsRequest{Flags: flags}
	resp_ := &nodeWithCtxSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeSetFlagsOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Query the filesystem for filesystem-specific information.
func (p *NodeWithCtxInterface) QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxQueryFilesystemResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeQueryFilesystemOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *NodeWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeCloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *NodeWithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeQueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *NodeWithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &nodeWithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(NodeReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *NodeWithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &nodeWithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(NodeOnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeGetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *NodeWithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &nodeWithCtxGetAttributesRequest{Query: query}
	resp_ := &nodeWithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeGetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *NodeWithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &nodeWithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeUpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *NodeWithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &nodeWithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(NodeSyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

type NodeWithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OpenFlags.RIGHT_*`
	// - `OpenFlags.APPEND`
	// - `OpenFlags.DESCRIBE`
	// - `OpenFlags.CLONE_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
	// `OpenFlags.CLONE_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error)
	// Updates information about the node.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OpenFlags.APPEND`
	//
	// This method does not require any rights.
	SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error)
	// Query the filesystem for filesystem-specific information.
	QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error)
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
}

type NodeWithCtxTransitionalBase struct{}

func (_ *NodeWithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *NodeWithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *NodeWithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *NodeWithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}

type NodeWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewNodeWithCtxInterfaceRequest() (NodeWithCtxInterfaceRequest, *NodeWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return NodeWithCtxInterfaceRequest(req), (*NodeWithCtxInterface)(cli), err
}

type NodeWithCtxStub struct {
	Impl NodeWithCtx
}

func (s_ *NodeWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case NodeCloneOrdinal:
		in_ := &nodeWithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, (*in_).Flags, (*in_).Object)
		return nil, false, err_
	case NodeDescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := &nodeWithCtxDescribeResponse{Info: info}
		return out_, true, err_
	case NodeGetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := &nodeWithCtxGetAttrResponse{S: s, Attributes: attributes}
		return out_, true, err_
	case NodeSetAttrOrdinal:
		in_ := &nodeWithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, (*in_).Flags, (*in_).Attributes)
		out_ := &nodeWithCtxSetAttrResponse{S: s}
		return out_, true, err_
	case NodeGetFlagsOrdinal:
		s, flags, err_ := s_.Impl.GetFlags(args_.Ctx)
		out_ := &nodeWithCtxGetFlagsResponse{S: s, Flags: flags}
		return out_, true, err_
	case NodeSetFlagsOrdinal:
		in_ := &nodeWithCtxSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetFlags(args_.Ctx, (*in_).Flags)
		out_ := &nodeWithCtxSetFlagsResponse{S: s}
		return out_, true, err_
	case NodeQueryFilesystemOrdinal:
		s, info, err_ := s_.Impl.QueryFilesystem(args_.Ctx)
		out_ := &nodeWithCtxQueryFilesystemResponse{S: s, Info: info}
		return out_, true, err_
	case NodeCloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &nodeWithCtxCloseResponse{Result: result}
		return out_, true, err_
	case NodeQueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &nodeWithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case NodeReopenOrdinal:
		in_ := &nodeWithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case NodeGetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case NodeGetAttributesOrdinal:
		in_ := &nodeWithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &nodeWithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case NodeUpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &nodeWithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case NodeSyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &nodeWithCtxSyncResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type NodeEventProxy _bindings.ChannelProxy

func (p *NodeEventProxy) OnOpen(s int32, info *NodeInfo) error {
	event_ := &nodeWithCtxOnOpenResponse{S: s, Info: info}
	return ((*_bindings.ChannelProxy)(p)).Send(NodeOnOpenOrdinal, event_)
}
func (p *NodeEventProxy) OnRepresentation(payload Representation) error {
	event_ := &nodeWithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(NodeOnRepresentationOrdinal, event_)
}

const (
	Node1CloneOrdinal           uint64 = 0x5a61678f293ce16f
	Node1DescribeOrdinal        uint64 = 0xffcec215078dea0
	Node1OnOpenOrdinal          uint64 = 0x7fc7bbb1dbfd1972
	Node1GetAttrOrdinal         uint64 = 0x78985e216314dafd
	Node1SetAttrOrdinal         uint64 = 0x4186c0f40d938f46
	Node1GetFlagsOrdinal        uint64 = 0x5b88fffb8eda3aa1
	Node1SetFlagsOrdinal        uint64 = 0x5295b76c71fde733
	Node1QueryFilesystemOrdinal uint64 = 0x6f344a1c6b0a0610
)

type Node1WithCtxInterface _bindings.ChannelProxy

// Create another connection to the same remote object.
//
// `flags` may be any of:
//
// - `OpenFlags.RIGHT_*`
// - `OpenFlags.APPEND`
// - `OpenFlags.DESCRIBE`
// - `OpenFlags.CLONE_SAME_RIGHTS`
//
// All other flags are ignored.
//
// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
// cloned object.
// The cloned object must have rights less than or equal to the original object, otherwise
// returns `ZX_ERR_ACCESS_DENIED`.
// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
// `OpenFlags.CLONE_SAME_RIGHTS`.
func (p *Node1WithCtxInterface) Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error {
	req_ := &node1WithCtxCloneRequest{Flags: flags, Object: object}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Node1CloneOrdinal, req_)
	return err_
}

// Returns extra information about the type of the object.
// If the `Describe` operation fails, the connection is closed.
//
// This method does not require any rights.
func (p *Node1WithCtxInterface) Describe(ctx_ _bindings.Context) (NodeInfo, error) {
	var req_ _bindings.Message
	resp_ := &node1WithCtxDescribeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1DescribeOrdinal, req_, resp_)
	return (*resp_).Info, err_
}

// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
//
// Indicates the success or failure of the open operation, and optionally describes the
// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
// (the same as would be returned by `Describe`).
func (p *Node1WithCtxInterface) ExpectOnOpen(ctx_ _bindings.Context) (int32, *NodeInfo, error) {
	resp_ := &node1WithCtxOnOpenResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(Node1OnOpenOrdinal, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Acquires information about the node.
//
// This method does not require any rights.
func (p *Node1WithCtxInterface) GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error) {
	var req_ _bindings.Message
	resp_ := &node1WithCtxGetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1GetAttrOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Attributes, err_
}

// Updates information about the node.
//
// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
// `ZX_ERR_BAD_HANDLE`.
func (p *Node1WithCtxInterface) SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error) {
	req_ := &node1WithCtxSetAttrRequest{Flags: flags, Attributes: attributes}
	resp_ := &node1WithCtxSetAttrResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1SetAttrOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Acquires the `Directory.Open` rights and flags used to access this file.
//
// This method does not require any rights.
func (p *Node1WithCtxInterface) GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error) {
	var req_ _bindings.Message
	resp_ := &node1WithCtxGetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1GetFlagsOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Flags, err_
}

// Changes the `Directory.Open` flags used to access the file.
// Supported flags which can be turned on / off:
// - `OpenFlags.APPEND`
//
// This method does not require any rights.
func (p *Node1WithCtxInterface) SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error) {
	req_ := &node1WithCtxSetFlagsRequest{Flags: flags}
	resp_ := &node1WithCtxSetFlagsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1SetFlagsOrdinal, req_, resp_)
	return (*resp_).S, err_
}

// Query the filesystem for filesystem-specific information.
func (p *Node1WithCtxInterface) QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error) {
	var req_ _bindings.Message
	resp_ := &node1WithCtxQueryFilesystemResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node1QueryFilesystemOrdinal, req_, resp_)
	return (*resp_).S, (*resp_).Info, err_
}

// Node defines the minimal interface for entities which can be accessed in a filesystem.
type Node1WithCtx interface {
	// Create another connection to the same remote object.
	//
	// `flags` may be any of:
	//
	// - `OpenFlags.RIGHT_*`
	// - `OpenFlags.APPEND`
	// - `OpenFlags.DESCRIBE`
	// - `OpenFlags.CLONE_SAME_RIGHTS`
	//
	// All other flags are ignored.
	//
	// The `OpenFlags.RIGHT_*` bits in `flags` request corresponding rights over the resulting
	// cloned object.
	// The cloned object must have rights less than or equal to the original object, otherwise
	// returns `ZX_ERR_ACCESS_DENIED`.
	// Alternatively, pass `OpenFlags.CLONE_SAME_RIGHTS` to inherit the rights on the source connection.
	// It is invalid to pass any of the `OpenFlags.RIGHT_*` flags together with
	// `OpenFlags.CLONE_SAME_RIGHTS`.
	Clone(ctx_ _bindings.Context, flags OpenFlags, object NodeWithCtxInterfaceRequest) error
	// Returns extra information about the type of the object.
	// If the `Describe` operation fails, the connection is closed.
	//
	// This method does not require any rights.
	Describe(ctx_ _bindings.Context) (NodeInfo, error)
	// An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.
	//
	// Indicates the success or failure of the open operation, and optionally describes the
	// object. If the status is `ZX_OK`, `info` contains descriptive information about the object
	// (the same as would be returned by `Describe`).
	// Acquires information about the node.
	//
	// This method does not require any rights.
	GetAttr(ctx_ _bindings.Context) (int32, NodeAttributes, error)
	// Updates information about the node.
	//
	// This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns
	// `ZX_ERR_BAD_HANDLE`.
	SetAttr(ctx_ _bindings.Context, flags NodeAttributeFlags, attributes NodeAttributes) (int32, error)
	// Acquires the `Directory.Open` rights and flags used to access this file.
	//
	// This method does not require any rights.
	GetFlags(ctx_ _bindings.Context) (int32, OpenFlags, error)
	// Changes the `Directory.Open` flags used to access the file.
	// Supported flags which can be turned on / off:
	// - `OpenFlags.APPEND`
	//
	// This method does not require any rights.
	SetFlags(ctx_ _bindings.Context, flags OpenFlags) (int32, error)
	// Query the filesystem for filesystem-specific information.
	QueryFilesystem(ctx_ _bindings.Context) (int32, *FilesystemInfo, error)
}

type Node1WithCtxTransitionalBase struct{}

type Node1WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewNode1WithCtxInterfaceRequest() (Node1WithCtxInterfaceRequest, *Node1WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return Node1WithCtxInterfaceRequest(req), (*Node1WithCtxInterface)(cli), err
}

type Node1WithCtxStub struct {
	Impl Node1WithCtx
}

func (s_ *Node1WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case Node1CloneOrdinal:
		in_ := &node1WithCtxCloneRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Clone(args_.Ctx, (*in_).Flags, (*in_).Object)
		return nil, false, err_
	case Node1DescribeOrdinal:
		info, err_ := s_.Impl.Describe(args_.Ctx)
		out_ := &node1WithCtxDescribeResponse{Info: info}
		return out_, true, err_
	case Node1GetAttrOrdinal:
		s, attributes, err_ := s_.Impl.GetAttr(args_.Ctx)
		out_ := &node1WithCtxGetAttrResponse{S: s, Attributes: attributes}
		return out_, true, err_
	case Node1SetAttrOrdinal:
		in_ := &node1WithCtxSetAttrRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetAttr(args_.Ctx, (*in_).Flags, (*in_).Attributes)
		out_ := &node1WithCtxSetAttrResponse{S: s}
		return out_, true, err_
	case Node1GetFlagsOrdinal:
		s, flags, err_ := s_.Impl.GetFlags(args_.Ctx)
		out_ := &node1WithCtxGetFlagsResponse{S: s, Flags: flags}
		return out_, true, err_
	case Node1SetFlagsOrdinal:
		in_ := &node1WithCtxSetFlagsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		s, err_ := s_.Impl.SetFlags(args_.Ctx, (*in_).Flags)
		out_ := &node1WithCtxSetFlagsResponse{S: s}
		return out_, true, err_
	case Node1QueryFilesystemOrdinal:
		s, info, err_ := s_.Impl.QueryFilesystem(args_.Ctx)
		out_ := &node1WithCtxQueryFilesystemResponse{S: s, Info: info}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type Node1EventProxy _bindings.ChannelProxy

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

const (
	Node2CloseOrdinal             uint64 = 0x5ac5d459ad7f657e
	Node2QueryOrdinal             uint64 = 0x2658edee9decfc06
	Node2ReopenOrdinal            uint64 = 0x6a849ef281d2baa1
	Node2OnRepresentationOrdinal  uint64 = 0x5cb40567d80a510c
	Node2GetConnectionInfoOrdinal uint64 = 0x584c377c7c0a6d0b
	Node2GetAttributesOrdinal     uint64 = 0x3d4396a638ea053b
	Node2UpdateAttributesOrdinal  uint64 = 0x3308c1da5a89bf08
	Node2SyncOrdinal              uint64 = 0x2c5c27ca0ab5dc49
)

type Node2WithCtxInterface _bindings.ChannelProxy

// Terminates the connection.
//
// After calling `Close`, the client must not send any other requests.
//
// Servers, after sending the status response, should close the connection
// regardless of status and without sending an epitaph.
//
// Closing the client end of the channel should be semantically equivalent
// to calling `Close` without knowing when the close has completed or its
// status.
func (p *Node2WithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) {
	var req_ _bindings.Message
	resp_ := &node2WithCtxCloseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2CloseOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *Node2WithCtxInterface) Query(ctx_ _bindings.Context) (uint64, error) {
	var req_ _bindings.Message
	resp_ := &node2WithCtxQueryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2QueryOrdinal, req_, resp_)
	return (*resp_).Protocol, err_
}

// Creates another connection to the same node.
//
// + `object_request` is the server end of a channel created for the new
//   connection. The caller may proceed to send messages on the
//   corresponding client end right away.
func (p *Node2WithCtxInterface) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	req_ := &node2WithCtxReopenRequest{RightsRequest: rightsRequest, ObjectRequest: objectRequest}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Node2ReopenOrdinal, req_)
	return err_
}

// An event produced eagerly by the server if requested by
// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
// from the server, and is sent exactly once.
//
// The active variant corresponds to one of the supported protocols of
// the node, and represents the result of the connection-time
// negotiation. Provides auxiliary handles if applicable.
//
// If the client specified more than one protocol in `protocols` during
// [`Directory.Open`], the [`Representation`] carries additionally the
// result of the connection-time negotiation via its tag.
//
// The elements have one-to-one correspondence with the members of
// [`NodeProtocolKinds`].
//
// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
// inherent `Describe` methods on the specific protocols. It exists as
// an optimization to avoid an additional round trip.
func (p *Node2WithCtxInterface) ExpectOnRepresentation(ctx_ _bindings.Context) (Representation, error) {
	resp_ := &node2WithCtxOnRepresentationResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(Node2OnRepresentationOrdinal, resp_)
	return (*resp_).Payload, err_
}

// Acquires information about the connection.
//
// This method does not require any rights.
func (p *Node2WithCtxInterface) GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error) {
	var req_ _bindings.Message
	resp_ := &ConnectionInfo{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2GetConnectionInfoOrdinal, req_, resp_)
	return (*resp_), err_
}

// Acquires information about the node.
//
// The attributes of a node should be stable, independent of the
// specific protocol used to access it.
//
// If a particular attribute is not applicable or not supported,
// filesystems should leave the corresponding field absent.
//
// + `query` a bit-mask specifying which attributes to fetch. The server
//   should not return more than necessary.
// - `attributes` the returned attributes.
//
// This method requires the [`Rights.GET_ATTRIBUTES`] right.
func (p *Node2WithCtxInterface) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	req_ := &node2WithCtxGetAttributesRequest{Query: query}
	resp_ := &node2WithCtxGetAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2GetAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Updates information about the node.
//
// + `attributes` the presence of a table field in `attributes` indicates
// the intent to update the corresponding attribute.
//
// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
func (p *Node2WithCtxInterface) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	req_ := &payload
	resp_ := &node2WithCtxUpdateAttributesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2UpdateAttributesOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Synchronizes updates to the node to the underlying media, if it exists.
//
// This method will return when the filesystem server has flushed the
// relevant updates to the underlying media, but does not guarantee the
// underlying media has persisted the information, nor that any information
// is committed to hardware. Clients may use `Sync` to ensure ordering
// between operations.
//
// This method does not require any rights.
func (p *Node2WithCtxInterface) Sync(ctx_ _bindings.Context) (Node2SyncResult, error) {
	var req_ _bindings.Message
	resp_ := &node2WithCtxSyncResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Node2SyncOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

// Node defines the minimal protocol for entities which can be accessed
// in a filesystem.
type Node2WithCtx interface {
	// Terminates the connection.
	//
	// After calling `Close`, the client must not send any other requests.
	//
	// Servers, after sending the status response, should close the connection
	// regardless of status and without sending an epitaph.
	//
	// Closing the client end of the channel should be semantically equivalent
	// to calling `Close` without knowing when the close has completed or its
	// status.
	Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error)
	Query(ctx_ _bindings.Context) (uint64, error)
	// Creates another connection to the same node.
	//
	// + `object_request` is the server end of a channel created for the new
	//   connection. The caller may proceed to send messages on the
	//   corresponding client end right away.
	Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error
	// An event produced eagerly by the server if requested by
	// [`NodeFlags.GET_REPRESENTATION`]. This event will be the first message
	// from the server, and is sent exactly once.
	//
	// The active variant corresponds to one of the supported protocols of
	// the node, and represents the result of the connection-time
	// negotiation. Provides auxiliary handles if applicable.
	//
	// If the client specified more than one protocol in `protocols` during
	// [`Directory.Open`], the [`Representation`] carries additionally the
	// result of the connection-time negotiation via its tag.
	//
	// The elements have one-to-one correspondence with the members of
	// [`NodeProtocolKinds`].
	//
	// This is a special case of [`fuchsia.unknown/Queryable.Query`] +
	// inherent `Describe` methods on the specific protocols. It exists as
	// an optimization to avoid an additional round trip.
	// Acquires information about the connection.
	//
	// This method does not require any rights.
	GetConnectionInfo(ctx_ _bindings.Context) (ConnectionInfo, error)
	// Acquires information about the node.
	//
	// The attributes of a node should be stable, independent of the
	// specific protocol used to access it.
	//
	// If a particular attribute is not applicable or not supported,
	// filesystems should leave the corresponding field absent.
	//
	// + `query` a bit-mask specifying which attributes to fetch. The server
	//   should not return more than necessary.
	// - `attributes` the returned attributes.
	//
	// This method requires the [`Rights.GET_ATTRIBUTES`] right.
	GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error)
	// Updates information about the node.
	//
	// + `attributes` the presence of a table field in `attributes` indicates
	// the intent to update the corresponding attribute.
	//
	// This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
	UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error)
	// Synchronizes updates to the node to the underlying media, if it exists.
	//
	// This method will return when the filesystem server has flushed the
	// relevant updates to the underlying media, but does not guarantee the
	// underlying media has persisted the information, nor that any information
	// is committed to hardware. Clients may use `Sync` to ensure ordering
	// between operations.
	//
	// This method does not require any rights.
	Sync(ctx_ _bindings.Context) (Node2SyncResult, error)
}

type Node2WithCtxTransitionalBase struct{}

func (_ *Node2WithCtxTransitionalBase) Query(ctx_ _bindings.Context) (uint64, error) {
	panic("Not Implemented")
}
func (_ *Node2WithCtxTransitionalBase) Reopen(ctx_ _bindings.Context, rightsRequest *RightsRequest, objectRequest _zx.Channel) error {
	panic("Not Implemented")
}
func (_ *Node2WithCtxTransitionalBase) GetAttributes(ctx_ _bindings.Context, query NodeAttributesQuery) (Node2GetAttributesResult, error) {
	panic("Not Implemented")
}
func (_ *Node2WithCtxTransitionalBase) UpdateAttributes(ctx_ _bindings.Context, payload MutableNodeAttributes) (Node2UpdateAttributesResult, error) {
	panic("Not Implemented")
}

type Node2WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewNode2WithCtxInterfaceRequest() (Node2WithCtxInterfaceRequest, *Node2WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return Node2WithCtxInterfaceRequest(req), (*Node2WithCtxInterface)(cli), err
}

type Node2WithCtxStub struct {
	Impl Node2WithCtx
}

func (s_ *Node2WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case Node2CloseOrdinal:
		result, err_ := s_.Impl.Close(args_.Ctx)
		out_ := &node2WithCtxCloseResponse{Result: result}
		return out_, true, err_
	case Node2QueryOrdinal:
		protocol, err_ := s_.Impl.Query(args_.Ctx)
		out_ := &node2WithCtxQueryResponse{Protocol: protocol}
		return out_, true, err_
	case Node2ReopenOrdinal:
		in_ := &node2WithCtxReopenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Reopen(args_.Ctx, (*in_).RightsRequest, (*in_).ObjectRequest)
		return nil, false, err_
	case Node2GetConnectionInfoOrdinal:
		payload, err_ := s_.Impl.GetConnectionInfo(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case Node2GetAttributesOrdinal:
		in_ := &node2WithCtxGetAttributesRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetAttributes(args_.Ctx, (*in_).Query)
		out_ := &node2WithCtxGetAttributesResponse{Result: result}
		return out_, true, err_
	case Node2UpdateAttributesOrdinal:
		in_ := &MutableNodeAttributes{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.UpdateAttributes(args_.Ctx, (*in_))
		out_ := &node2WithCtxUpdateAttributesResponse{Result: result}
		return out_, true, err_
	case Node2SyncOrdinal:
		result, err_ := s_.Impl.Sync(args_.Ctx)
		out_ := &node2WithCtxSyncResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type Node2EventProxy _bindings.ChannelProxy

func (p *Node2EventProxy) OnRepresentation(payload Representation) error {
	event_ := &node2WithCtxOnRepresentationResponse{Payload: payload}
	return ((*_bindings.ChannelProxy)(p)).Send(Node2OnRepresentationOrdinal, event_)
}