zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h

// WARNING: This file is machine generated by fidlgen.

#pragma once

#include <lib/fidl/internal.h>
#include <lib/fidl/txn_header.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/connect_service.h>
#include <lib/fidl/llcpp/service_handler_interface.h>
#include <lib/fidl/llcpp/string_view.h>
#include <lib/fidl/llcpp/sync_call.h>
#include <lib/fidl/llcpp/traits.h>
#include <lib/fidl/llcpp/transaction.h>
#include <lib/fidl/llcpp/vector_view.h>
#include <lib/fit/function.h>
#include <lib/zx/channel.h>
#include <lib/zx/event.h>
#include <lib/zx/eventpair.h>
#include <lib/zx/handle.h>
#include <lib/zx/socket.h>
#include <lib/zx/vmo.h>
#include <zircon/fidl.h>

#include <fuchsia/mem/llcpp/fidl.h>

namespace llcpp {

namespace fuchsia {
namespace io {

struct WatchedEvent;
struct Vmofile;
struct Tty;
struct StreamSocket;
class DirectoryWatcher;
struct Socket;
struct Service;
enum class SeekOrigin : uint32_t {
  START = 0u,
  CURRENT = 1u,
  END = 2u,
};


struct Pipe;
struct NodeAttributes;
struct FilesystemInfo;
struct FileObject;
struct DirectoryObject;
struct Device;
struct DatagramSocket;
struct NodeInfo;
class Node;
class File;
class Directory;
class DirectoryAdmin;

extern "C" const fidl_type_t v1_fuchsia_io_NodeInfoTable;

// Describes how the connection to an should be handled, as well as
// how to interpret the optional handle.
//
// Refer to `Node.Describe()` and `Node.OnOpen()` for usage.
struct NodeInfo {
  NodeInfo() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kService = 1,  // 0x1
    kFile = 2,  // 0x2
    kDirectory = 3,  // 0x3
    kPipe = 4,  // 0x4
    kVmofile = 5,  // 0x5
    kDevice = 6,  // 0x6
    kTty = 7,  // 0x7
    kSocket = 8,  // 0x8
    kDatagramSocket = 9,  // 0x9
    kStreamSocket = 10,  // 0xa
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_service() const { return ordinal() == Ordinal::kService; }

  static NodeInfo WithService(::llcpp::fuchsia::io::Service* val) {
    NodeInfo result;
    result.set_service(val);
    return result;
  }

  void set_service(::llcpp::fuchsia::io::Service* elem) {
    ordinal_ = Ordinal::kService;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Service& mutable_service() {
    ZX_ASSERT(ordinal() == Ordinal::kService);
    return *static_cast<::llcpp::fuchsia::io::Service*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Service& service() const {
    ZX_ASSERT(ordinal() == Ordinal::kService);
    return *static_cast<::llcpp::fuchsia::io::Service*>(envelope_.data);
  }

  bool is_file() const { return ordinal() == Ordinal::kFile; }

  static NodeInfo WithFile(::llcpp::fuchsia::io::FileObject* val) {
    NodeInfo result;
    result.set_file(val);
    return result;
  }

  void set_file(::llcpp::fuchsia::io::FileObject* elem) {
    ordinal_ = Ordinal::kFile;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::FileObject& mutable_file() {
    ZX_ASSERT(ordinal() == Ordinal::kFile);
    return *static_cast<::llcpp::fuchsia::io::FileObject*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::FileObject& file() const {
    ZX_ASSERT(ordinal() == Ordinal::kFile);
    return *static_cast<::llcpp::fuchsia::io::FileObject*>(envelope_.data);
  }

  bool is_directory() const { return ordinal() == Ordinal::kDirectory; }

  static NodeInfo WithDirectory(::llcpp::fuchsia::io::DirectoryObject* val) {
    NodeInfo result;
    result.set_directory(val);
    return result;
  }

  void set_directory(::llcpp::fuchsia::io::DirectoryObject* elem) {
    ordinal_ = Ordinal::kDirectory;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::DirectoryObject& mutable_directory() {
    ZX_ASSERT(ordinal() == Ordinal::kDirectory);
    return *static_cast<::llcpp::fuchsia::io::DirectoryObject*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::DirectoryObject& directory() const {
    ZX_ASSERT(ordinal() == Ordinal::kDirectory);
    return *static_cast<::llcpp::fuchsia::io::DirectoryObject*>(envelope_.data);
  }

  bool is_pipe() const { return ordinal() == Ordinal::kPipe; }

  static NodeInfo WithPipe(::llcpp::fuchsia::io::Pipe* val) {
    NodeInfo result;
    result.set_pipe(val);
    return result;
  }

  void set_pipe(::llcpp::fuchsia::io::Pipe* elem) {
    ordinal_ = Ordinal::kPipe;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Pipe& mutable_pipe() {
    ZX_ASSERT(ordinal() == Ordinal::kPipe);
    return *static_cast<::llcpp::fuchsia::io::Pipe*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Pipe& pipe() const {
    ZX_ASSERT(ordinal() == Ordinal::kPipe);
    return *static_cast<::llcpp::fuchsia::io::Pipe*>(envelope_.data);
  }

  bool is_vmofile() const { return ordinal() == Ordinal::kVmofile; }

  static NodeInfo WithVmofile(::llcpp::fuchsia::io::Vmofile* val) {
    NodeInfo result;
    result.set_vmofile(val);
    return result;
  }

  void set_vmofile(::llcpp::fuchsia::io::Vmofile* elem) {
    ordinal_ = Ordinal::kVmofile;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Vmofile& mutable_vmofile() {
    ZX_ASSERT(ordinal() == Ordinal::kVmofile);
    return *static_cast<::llcpp::fuchsia::io::Vmofile*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Vmofile& vmofile() const {
    ZX_ASSERT(ordinal() == Ordinal::kVmofile);
    return *static_cast<::llcpp::fuchsia::io::Vmofile*>(envelope_.data);
  }

  bool is_device() const { return ordinal() == Ordinal::kDevice; }

  static NodeInfo WithDevice(::llcpp::fuchsia::io::Device* val) {
    NodeInfo result;
    result.set_device(val);
    return result;
  }

  void set_device(::llcpp::fuchsia::io::Device* elem) {
    ordinal_ = Ordinal::kDevice;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Device& mutable_device() {
    ZX_ASSERT(ordinal() == Ordinal::kDevice);
    return *static_cast<::llcpp::fuchsia::io::Device*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Device& device() const {
    ZX_ASSERT(ordinal() == Ordinal::kDevice);
    return *static_cast<::llcpp::fuchsia::io::Device*>(envelope_.data);
  }

  bool is_tty() const { return ordinal() == Ordinal::kTty; }

  static NodeInfo WithTty(::llcpp::fuchsia::io::Tty* val) {
    NodeInfo result;
    result.set_tty(val);
    return result;
  }

  void set_tty(::llcpp::fuchsia::io::Tty* elem) {
    ordinal_ = Ordinal::kTty;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Tty& mutable_tty() {
    ZX_ASSERT(ordinal() == Ordinal::kTty);
    return *static_cast<::llcpp::fuchsia::io::Tty*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Tty& tty() const {
    ZX_ASSERT(ordinal() == Ordinal::kTty);
    return *static_cast<::llcpp::fuchsia::io::Tty*>(envelope_.data);
  }

  bool is_socket() const { return ordinal() == Ordinal::kSocket; }

  static NodeInfo WithSocket(::llcpp::fuchsia::io::Socket* val) {
    NodeInfo result;
    result.set_socket(val);
    return result;
  }

  void set_socket(::llcpp::fuchsia::io::Socket* elem) {
    ordinal_ = Ordinal::kSocket;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::Socket& mutable_socket() {
    ZX_ASSERT(ordinal() == Ordinal::kSocket);
    return *static_cast<::llcpp::fuchsia::io::Socket*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::Socket& socket() const {
    ZX_ASSERT(ordinal() == Ordinal::kSocket);
    return *static_cast<::llcpp::fuchsia::io::Socket*>(envelope_.data);
  }

  bool is_datagram_socket() const { return ordinal() == Ordinal::kDatagramSocket; }

  static NodeInfo WithDatagramSocket(::llcpp::fuchsia::io::DatagramSocket* val) {
    NodeInfo result;
    result.set_datagram_socket(val);
    return result;
  }

  void set_datagram_socket(::llcpp::fuchsia::io::DatagramSocket* elem) {
    ordinal_ = Ordinal::kDatagramSocket;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::DatagramSocket& mutable_datagram_socket() {
    ZX_ASSERT(ordinal() == Ordinal::kDatagramSocket);
    return *static_cast<::llcpp::fuchsia::io::DatagramSocket*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::DatagramSocket& datagram_socket() const {
    ZX_ASSERT(ordinal() == Ordinal::kDatagramSocket);
    return *static_cast<::llcpp::fuchsia::io::DatagramSocket*>(envelope_.data);
  }

  bool is_stream_socket() const { return ordinal() == Ordinal::kStreamSocket; }

  static NodeInfo WithStreamSocket(::llcpp::fuchsia::io::StreamSocket* val) {
    NodeInfo result;
    result.set_stream_socket(val);
    return result;
  }

  void set_stream_socket(::llcpp::fuchsia::io::StreamSocket* elem) {
    ordinal_ = Ordinal::kStreamSocket;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::io::StreamSocket& mutable_stream_socket() {
    ZX_ASSERT(ordinal() == Ordinal::kStreamSocket);
    return *static_cast<::llcpp::fuchsia::io::StreamSocket*>(envelope_.data);
  }
  const ::llcpp::fuchsia::io::StreamSocket& stream_socket() const {
    ZX_ASSERT(ordinal() == Ordinal::kStreamSocket);
    return *static_cast<::llcpp::fuchsia::io::StreamSocket*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeInfoTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 24;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kService = 1,  // 0x1
    kFile = 2,  // 0x2
    kDirectory = 3,  // 0x3
    kPipe = 4,  // 0x4
    kVmofile = 5,  // 0x5
    kDevice = 6,  // 0x6
    kTty = 7,  // 0x7
    kSocket = 8,  // 0x8
    kDatagramSocket = 9,  // 0x9
    kStreamSocket = 10,  // 0xa
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_io_WatchedEventTable;

// WatchedEvent describes events returned from a DirectoryWatcher.
struct WatchedEvent {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_WatchedEventTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 256;
  static constexpr bool HasPointer = true;

  uint8_t event = {};

  uint8_t len = {};

  ::fidl::VectorView<uint8_t> name = {};
};

// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_REMOVED`.
constexpr uint32_t WATCH_MASK_REMOVED = 4u;

// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_IDLE`.
constexpr uint32_t WATCH_MASK_IDLE = 16u;

// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_EXISTING`.
constexpr uint32_t WATCH_MASK_EXISTING = 8u;

// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_DELETED`.
constexpr uint32_t WATCH_MASK_DELETED = 1u;

// Used by `Directory.Watch`. Requests transmission of all watcher events.
constexpr uint32_t WATCH_MASK_ALL = 31u;

// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_ADDED`.
constexpr uint32_t WATCH_MASK_ADDED = 2u;

// Identifies a node has been removed (either deleted or moved) from the directory.
constexpr uint8_t WATCH_EVENT_REMOVED = 2u;

// Identifies that no more `WATCH_EVENT_EXISTING` events will be sent.
constexpr uint8_t WATCH_EVENT_IDLE = 4u;

// Identifies a node already existed in the directory when watching started.
constexpr uint8_t WATCH_EVENT_EXISTING = 3u;

// Indicates the directory being watched has been deleted.
constexpr uint8_t WATCH_EVENT_DELETED = 0u;

// Indicates a node has been created (either new or moved) into a directory.
constexpr uint8_t WATCH_EVENT_ADDED = 1u;

extern "C" const fidl_type_t v1_fuchsia_io_VmofileTable;

// The object is a file which is represented as an immutable VMO.
// Although a VMO is returned as a part of this structure, this underlying object
// may represent multiple Vmofiles. To identify the logical portion of the VMO
// that represents the single file, an offset and length parameter are also supplied.
struct Vmofile {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_VmofileTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // The VMO which backs this file.
  ::zx::vmo vmo = {};

  // The index into `vmo` which represents the first byte of the file.
  uint64_t offset = {};

  // The number of bytes, starting at `offset`, which may be used to represent this file.
  uint64_t length = {};
};

// Requests that the VMO be writable.
constexpr uint32_t VMO_FLAG_WRITE = 2u;

// Requests that the VMO be readable.
constexpr uint32_t VMO_FLAG_READ = 1u;

// Require a copy-on-write clone of the underlying VMO.
// The request should fail if the VMO is not cloned.
// May not be supplied with fuchsia_io_`VMO_FLAG_EXACT`.
constexpr uint32_t VMO_FLAG_PRIVATE = 65536u;

// Requests that the VMO be executable.
constexpr uint32_t VMO_FLAG_EXEC = 4u;

// Require an exact (non-cloned) handle to the underlying VMO.
// The request should fail if a handle to the exact VMO is not returned.
// May not be supplied with `VMO_FLAG_PRIVATE`.
constexpr uint32_t VMO_FLAG_EXACT = 131072u;

extern "C" const fidl_type_t v1_fuchsia_io_TtyTable;

// The object may be cast to interface 'Tty'
struct Tty {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_TtyTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::zx::eventpair event = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_StreamSocketTable;

// The object may be cast to interface [`fuchsia.posix.socket.StreamSocket`].
struct StreamSocket {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_StreamSocketTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::zx::socket socket = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventResponseTable;

// 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.
class DirectoryWatcher final {
  DirectoryWatcher() = delete;
 public:

  struct OnEventRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::VectorView<uint8_t> events;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatcherOnEventRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class OnEvent_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events);
      ~OnEvent_Impl() = default;
      OnEvent_Impl(OnEvent_Impl&& other) = default;
      OnEvent_Impl& operator=(OnEvent_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using OnEvent = OnEvent_Impl;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    class OnEvent_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
      ~OnEvent_Impl() = default;
      OnEvent_Impl(OnEvent_Impl&& other) = default;
      OnEvent_Impl& operator=(OnEvent_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using OnEvent = OnEvent_Impl;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Request is heap-allocated.
    ResultOf::OnEvent OnEvent(::fidl::VectorView<uint8_t> events);

    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::OnEvent OnEvent(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);

   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Request is heap-allocated.
    static ResultOf::OnEvent OnEvent(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events);

    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::OnEvent OnEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);

  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    static ::fidl::internal::StatusAndError OnEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnEventRequest> params);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = DirectoryWatcher;
    using _Base = ::fidl::CompleterBase;

    using OnEventCompleter = ::fidl::Completer<>;

    virtual void OnEvent(::fidl::VectorView<uint8_t> events, OnEventCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void OnEventRequest(const ::fidl::DecodedMessage<DirectoryWatcher::OnEventRequest>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_io_SocketTable;

// The object may be cast to interface [`fuchsia.posix.socket.Control`].
struct Socket {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_SocketTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::zx::socket socket = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_ServiceTable;

// The default protocol, interface information must be acquired some
// other way.
struct Service {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_ServiceTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_PipeTable;

// The object is accompanied by a pipe.
struct Pipe {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_PipeTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::zx::socket socket = {};
};

// Can write to target object.
constexpr uint32_t OPEN_RIGHT_WRITABLE = 2u;

// Can read from target object.
constexpr uint32_t OPEN_RIGHT_READABLE = 1u;

// Connection can map target object executable.
constexpr uint32_t OPEN_RIGHT_EXECUTABLE = 8u;

// Connection can mount/umount filesystem.
constexpr uint32_t OPEN_RIGHT_ADMIN = 4u;

// Truncate the object before usage.
constexpr uint32_t OPEN_FLAG_TRUNCATE = 262144u;

// Specify this flag to request POSIX-compatibility. Currently, it affects permission handling.
// During Open:
// - If the target path is a directory, the rights on the new connection expand to include
//   `OPEN_RIGHT_WRITABLE` if and only if the current connection and all intermediate mount points
//   are writable, and to include `OPEN_RIGHT_EXECUTABLE` if and only if the current connection and
//   all intermediate mount points are executable.
// - Otherwise, this flag is ignored. It is an access denied error to request more rights
//   than those on the current connection, or any intermediate mount points.
//
// If the posix compatibility flag is not specified, opening always uses the requested rights,
// failing the operation with access denied error if requested rights exceeds the rights attached
// to the current connection.
//
// If the requesting connection is read-only and the requested rights are read-only, the flag
// may be ignored by the server, and is not forwarded downstream. This is an implementation detail,
// necessary to enforce hierarchical permissions across mount points, and should have no effect
// on the expected behavior for clients.
constexpr uint32_t OPEN_FLAG_POSIX = 16777216u;

// If the object is a mount point, open the local directory.
constexpr uint32_t OPEN_FLAG_NO_REMOTE = 2097152u;

// Assert that the object to be opened is not a directory.
// Return an error if the target object is a directory.
constexpr uint32_t OPEN_FLAG_NOT_DIRECTORY = 33554432u;

// Open a reference to the object, not the object itself.
// It is ONLY valid to pass the following flags together with `OPEN_FLAG_NODE_REFERENCE`:
// - `OPEN_FLAG_DIRECTORY`
// - `OPEN_FLAG_NOT_DIRECTORY`
// - `OPEN_FLAG_DESCRIBE`
// otherwise an error is returned.
// If an object is opened or cloned using this method, the resulting connection does not carry
// any permission flags.
// The resulting node allows a limited set of operations: `GetAttr`, `Clone`, `Close`, `Describe`,
// and, if the node is a file, these extra operations: `GetFlags`, `SetFlags`.
constexpr uint32_t OPEN_FLAG_NODE_REFERENCE = 4194304u;

// Assert that the object to be opened is a directory.
// Return an error if the target object is not a directory.
constexpr uint32_t OPEN_FLAG_DIRECTORY = 524288u;

// Requests that an "OnOpen" event is sent to the interface request.
// The event will contain a non-null NodeInfo if the open/clone is successful.
constexpr uint32_t OPEN_FLAG_DESCRIBE = 8388608u;

// (with Create) Fail if the object already exists.
constexpr uint32_t OPEN_FLAG_CREATE_IF_ABSENT = 131072u;

// Create the object if it doesn't exist.
constexpr uint32_t OPEN_FLAG_CREATE = 65536u;

// Seek to the end of the object before all writes.
constexpr uint32_t OPEN_FLAG_APPEND = 1048576u;

// Binary OR of `OPEN_FLAG_DIRECTORY`, OPEN_FLAG_NOT_DIRECTORY, OPEN_FLAG_DESCRIBE, and
// `OPEN_FLAG_NODE_REFERENCE`. Flags used when opening a node reference must fall within this mask.
constexpr uint32_t OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE = 46661632u;

extern "C" const fidl_type_t v1_fuchsia_io_NodeAttributesTable;

// NodeAttributes defines generic information about a filesystem node.
struct NodeAttributes {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeAttributesTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 56;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // Protection bits and node type information describe in 'mode'.
  uint32_t mode = {};

  // A filesystem-unique ID.
  uint64_t id = {};

  // Node size, in bytes.
  uint64_t content_size = {};

  // Space needed to store node (possibly larger than size), in bytes.
  uint64_t storage_size = {};

  // Hard link count.
  uint64_t link_count = {};

  // Time of creation (may be updated manually after creation) in ns since Unix epoch, UTC.
  uint64_t creation_time = {};

  // Time of last modification in ns since Unix epoch, UTC.
  uint64_t modification_time = {};
};

constexpr uint32_t NODE_ATTRIBUTE_FLAG_MODIFICATION_TIME = 2u;

// The fields of 'attributes' which are used to update the Node are indicated
// by the 'flags' argument.
constexpr uint32_t NODE_ATTRIBUTE_FLAG_CREATION_TIME = 1u;

constexpr uint32_t MOUNT_CREATE_FLAG_REPLACE = 1u;

constexpr uint32_t MODE_TYPE_SOCKET = 49152u;

constexpr uint32_t MODE_TYPE_SERVICE = 65536u;

// 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.
constexpr uint32_t MODE_TYPE_MASK = 1044480u;

constexpr uint32_t MODE_TYPE_FILE = 32768u;

constexpr uint32_t MODE_TYPE_DIRECTORY = 16384u;

constexpr uint32_t MODE_TYPE_BLOCK_DEVICE = 24576u;

// 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.
constexpr uint32_t MODE_PROTECTION_MASK = 4095u;

// The maximum length, in bytes, of a filesystem string.
constexpr uint64_t MAX_PATH = 4096u;

constexpr uint64_t MAX_FS_NAME_BUFFER = 32u;

// The maximum length, in bytes, of a single filesystem component.
constexpr uint64_t MAX_FILENAME = 255u;

// The maximal buffer size which can be transmitted for buffered operations.
// This capacity is currently set somewhat arbitrarily.
constexpr uint64_t MAX_BUF = 8192u;

// Nodes which do not have ino values should return this value
// from Readdir and GetAttr.
constexpr uint64_t INO_UNKNOWN = 18446744073709551615u;

extern "C" const fidl_type_t v1_fuchsia_io_FilesystemInfoTable;

struct FilesystemInfo {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FilesystemInfoTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 96;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // The number of data bytes which may be stored in a filesystem.
  uint64_t total_bytes = {};

  // The number of data bytes which are in use by the filesystem.
  uint64_t used_bytes = {};

  // The number of nodes which may be stored in the filesystem.
  uint64_t total_nodes = {};

  // The number of nodes used by the filesystem.
  uint64_t used_nodes = {};

  // The amount of space which may be allocated from the underlying
  // volume manager. If unsupported, this will be zero.
  uint64_t free_shared_pool_bytes = {};

  // A unique identifier for this filesystem instance. Will not be preserved
  // across reboots.
  uint64_t fs_id = {};

  // The size of a single filesystem block.
  uint32_t block_size = {};

  // The maximum length of a filesystem name.
  uint32_t max_filename_size = {};

  // A unique identifier for the type of the underlying filesystem.
  uint32_t fs_type = {};

  uint32_t padding = {};

  ::fidl::Array<int8_t, 32> name = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_FileObjectTable;

// The object may be cast to interface 'File'.
struct FileObject {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileObjectTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // 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.
  ::zx::event event = {};
};

// Indicates the file is ready for writing.
constexpr uint32_t FILE_SIGNAL_WRITABLE = 33554432u;

// Indicates the file is ready for reading.
constexpr uint32_t FILE_SIGNAL_READABLE = 16777216u;

extern "C" const fidl_type_t v1_fuchsia_io_DirectoryObjectTable;

// The object may be cast to interface 'Directory'.
struct DirectoryObject {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryObjectTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_DeviceTable;

// The object may be cast to interface 'Device'.
struct Device {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DeviceTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // An optional event which transmits information about a device's state.
  //
  // The "`DEVICE_SIGNAL_`" values may be observed on this event.
  ::zx::eventpair event = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_DatagramSocketTable;

// The object may be cast to interface [`fuchsia.posix.socket.DatagramSocket`].
struct DatagramSocket {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DatagramSocketTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 4;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  // See [`fuchsia.posix.socket.DatagramSocket`] for details.
  ::zx::eventpair event = {};
};

extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenEventTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsResponseTable;

// Node defines the minimal interface for entities which can be accessed in a filesystem.
class Node final {
  Node() = delete;
 public:

  struct CloneRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeCloneRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct CloseResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeCloseResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using CloseRequest = ::fidl::AnyZeroArgMessage;

  struct DescribeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeDescribeResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using DescribeRequest = ::fidl::AnyZeroArgMessage;

  struct OnOpenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeOnOpenEventTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SyncResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSyncResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using SyncRequest = ::fidl::AnyZeroArgMessage;

  struct GetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeGetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetAttrRequest = ::fidl::AnyZeroArgMessage;

  struct SetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetAttrRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSetAttrRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 80;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetAttrResponse;
  };

  struct NodeGetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeGetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct NodeSetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeSetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct NodeSetFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeSetFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = NodeSetFlagsResponse;
  };


  struct EventHandlers {
    // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
    fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;

    // Fallback handler when an unknown ordinal is received.
    // Caller may put custom error handling logic here.
    fit::callback<zx_status_t()> unknown;
  };

  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Close Close();

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Describe Describe();

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Sync Sync();

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetAttr GetAttr();

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeGetFlags NodeGetFlags();

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    zx_status_t HandleEvents(EventHandlers handlers);
   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Close Close(::zx::unowned_channel _client_end);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Describe Describe(::zx::unowned_channel _client_end);

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Sync Sync(::zx::unowned_channel _client_end);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // 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.
    static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = Node;
    using _Base = ::fidl::CompleterBase;

    using CloneCompleter = ::fidl::Completer<>;

    virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;

    class CloseCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<CloseResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;

    virtual void Close(CloseCompleter::Sync _completer) = 0;

    class DescribeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::DecodedMessage<DescribeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;

    virtual void Describe(DescribeCompleter::Sync _completer) = 0;

    class SyncCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SyncResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;

    virtual void Sync(SyncCompleter::Sync _completer) = 0;

    class GetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::DecodedMessage<GetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;

    virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;

    class SetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;

    virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;

    class NodeGetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
      void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;

    virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    class NodeSetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;

    virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Caller provides the backing storage for FIDL message via response buffers.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Messages are encoded in-place.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void CloneRequest(const ::fidl::DecodedMessage<Node::CloneRequest>& _msg);
    static void CloseRequest(const ::fidl::DecodedMessage<Node::CloseRequest>& _msg);
    static void CloseResponse(const ::fidl::DecodedMessage<Node::CloseResponse>& _msg);
    static void DescribeRequest(const ::fidl::DecodedMessage<Node::DescribeRequest>& _msg);
    static void DescribeResponse(const ::fidl::DecodedMessage<Node::DescribeResponse>& _msg);
    static void OnOpenResponse(const ::fidl::DecodedMessage<Node::OnOpenResponse>& _msg);
    static void SyncRequest(const ::fidl::DecodedMessage<Node::SyncRequest>& _msg);
    static void SyncResponse(const ::fidl::DecodedMessage<Node::SyncResponse>& _msg);
    static void GetAttrRequest(const ::fidl::DecodedMessage<Node::GetAttrRequest>& _msg);
    static void GetAttrResponse(const ::fidl::DecodedMessage<Node::GetAttrResponse>& _msg);
    static void SetAttrRequest(const ::fidl::DecodedMessage<Node::SetAttrRequest>& _msg);
    static void SetAttrResponse(const ::fidl::DecodedMessage<Node::SetAttrResponse>& _msg);
    static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeGetFlagsRequest>& _msg);
    static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeGetFlagsResponse>& _msg);
    static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeSetFlagsRequest>& _msg);
    static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeSetFlagsResponse>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_io_FileCloneRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileCloneResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileCloseRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileCloseResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenEventTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSyncRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSyncResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileReadRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileReadResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileWriteRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileWriteResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSeekRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSeekResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferResponseTable;

// File defines the interface of a node which contains a flat layout of data.
class File final {
  File() = delete;
 public:

  struct CloneRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileCloneRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct CloseResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileCloseResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using CloseRequest = ::fidl::AnyZeroArgMessage;

  struct DescribeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileDescribeResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using DescribeRequest = ::fidl::AnyZeroArgMessage;

  struct OnOpenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileOnOpenEventTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SyncResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSyncResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using SyncRequest = ::fidl::AnyZeroArgMessage;

  struct GetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetAttrRequest = ::fidl::AnyZeroArgMessage;

  struct SetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetAttrRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetAttrRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 80;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetAttrResponse;
  };

  struct NodeGetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeGetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct NodeSetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeSetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct NodeSetFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeSetFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = NodeSetFlagsResponse;
  };

  struct ReadResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ReadRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint64_t count;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ReadResponse;
  };

  struct ReadAtResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadAtResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ReadAtRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint64_t count;
    uint64_t offset;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadAtRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ReadAtResponse;
  };

  struct WriteResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint64_t actual;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct WriteRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = WriteResponse;
  };

  struct WriteAtResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint64_t actual;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteAtResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct WriteAtRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::VectorView<uint8_t> data;
    uint64_t offset;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteAtRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 40;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = WriteAtResponse;
  };

  struct SeekResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint64_t offset;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSeekResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SeekRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int64_t offset;
    ::llcpp::fuchsia::io::SeekOrigin start;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSeekRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SeekResponse;
  };

  struct TruncateResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileTruncateResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct TruncateRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint64_t length;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileTruncateRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = TruncateResponse;
  };

  struct GetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct SetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetFlagsResponse;
  };

  struct GetBufferResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::mem::Buffer* buffer;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetBufferResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 16;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct GetBufferRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetBufferRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = GetBufferResponse;
  };


  struct EventHandlers {
    // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
    fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;

    // Fallback handler when an unknown ordinal is received.
    // Caller may put custom error handling logic here.
    fit::callback<zx_status_t()> unknown;
  };

  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Read_Impl(::zx::unowned_channel _client_end, uint64_t count);
      ~Read_Impl() = default;
      Read_Impl(Read_Impl&& other) = default;
      Read_Impl& operator=(Read_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
      ~ReadAt_Impl() = default;
      ReadAt_Impl(ReadAt_Impl&& other) = default;
      ReadAt_Impl& operator=(ReadAt_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
      ~Write_Impl() = default;
      Write_Impl(Write_Impl&& other) = default;
      Write_Impl& operator=(Write_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class WriteAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
      ~WriteAt_Impl() = default;
      WriteAt_Impl(WriteAt_Impl&& other) = default;
      WriteAt_Impl& operator=(WriteAt_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Seek_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
      ~Seek_Impl() = default;
      Seek_Impl(Seek_Impl&& other) = default;
      Seek_Impl& operator=(Seek_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Truncate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length);
      ~Truncate_Impl() = default;
      Truncate_Impl(Truncate_Impl&& other) = default;
      Truncate_Impl& operator=(Truncate_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetFlags_Impl(::zx::unowned_channel _client_end);
      ~GetFlags_Impl() = default;
      GetFlags_Impl(GetFlags_Impl&& other) = default;
      GetFlags_Impl& operator=(GetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~SetFlags_Impl() = default;
      SetFlags_Impl(SetFlags_Impl&& other) = default;
      SetFlags_Impl& operator=(SetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetBuffer_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~GetBuffer_Impl() = default;
      GetBuffer_Impl(GetBuffer_Impl&& other) = default;
      GetBuffer_Impl& operator=(GetBuffer_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Read = Read_Impl<ReadResponse>;
    using ReadAt = ReadAt_Impl<ReadAtResponse>;
    using Write = Write_Impl<WriteResponse>;
    using WriteAt = WriteAt_Impl<WriteAtResponse>;
    using Seek = Seek_Impl<SeekResponse>;
    using Truncate = Truncate_Impl<TruncateResponse>;
    using GetFlags = GetFlags_Impl<GetFlagsResponse>;
    using SetFlags = SetFlags_Impl<SetFlagsResponse>;
    using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
      ~Read_Impl() = default;
      Read_Impl(Read_Impl&& other) = default;
      Read_Impl& operator=(Read_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
      ~ReadAt_Impl() = default;
      ReadAt_Impl(ReadAt_Impl&& other) = default;
      ReadAt_Impl& operator=(ReadAt_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
      ~Write_Impl() = default;
      Write_Impl(Write_Impl&& other) = default;
      Write_Impl& operator=(Write_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class WriteAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
      ~WriteAt_Impl() = default;
      WriteAt_Impl(WriteAt_Impl&& other) = default;
      WriteAt_Impl& operator=(WriteAt_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Seek_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
      ~Seek_Impl() = default;
      Seek_Impl(Seek_Impl&& other) = default;
      Seek_Impl& operator=(Seek_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Truncate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
      ~Truncate_Impl() = default;
      Truncate_Impl(Truncate_Impl&& other) = default;
      Truncate_Impl& operator=(Truncate_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetFlags_Impl() = default;
      GetFlags_Impl(GetFlags_Impl&& other) = default;
      GetFlags_Impl& operator=(GetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~SetFlags_Impl() = default;
      SetFlags_Impl(SetFlags_Impl&& other) = default;
      SetFlags_Impl& operator=(SetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~GetBuffer_Impl() = default;
      GetBuffer_Impl(GetBuffer_Impl&& other) = default;
      GetBuffer_Impl& operator=(GetBuffer_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Read = Read_Impl<ReadResponse>;
    using ReadAt = ReadAt_Impl<ReadAtResponse>;
    using Write = Write_Impl<WriteResponse>;
    using WriteAt = WriteAt_Impl<WriteAtResponse>;
    using Seek = Seek_Impl<SeekResponse>;
    using Truncate = Truncate_Impl<TruncateResponse>;
    using GetFlags = GetFlags_Impl<GetFlagsResponse>;
    using SetFlags = SetFlags_Impl<SetFlagsResponse>;
    using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Close Close();

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Describe Describe();

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Sync Sync();

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetAttr GetAttr();

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeGetFlags NodeGetFlags();

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Reads `count` bytes at the seek offset.
    // The seek offset is moved forward by the number of bytes read.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::Read Read(uint64_t count);

    // Reads `count` bytes at the seek offset.
    // The seek offset is moved forward by the number of bytes read.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);

    // Reads `count` bytes at the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::ReadAt ReadAt(uint64_t count, uint64_t offset);

    // Reads `count` bytes at the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ReadAt ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);

    // Writes data at the seek offset.
    // The seek offset is moved forward by the number of bytes written.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Write Write(::fidl::VectorView<uint8_t> data);

    // Writes data at the seek offset.
    // The seek offset is moved forward by the number of bytes written.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Writes data to the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::WriteAt WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset);

    // Writes data to the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::WriteAt WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);

    // Moves the offset at which the next invocation of `Read()` or `Write()` will
    // occur.
    //
    // This method does not require any rights.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Seek Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);

    // Moves the offset at which the next invocation of `Read()` or `Write()` will
    // occur.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Seek Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);

    // Shrinks the file size to 'length' bytes.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Truncate Truncate(uint64_t length);

    // Shrinks the file size to 'length' bytes.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Truncate Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetFlags GetFlags();

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetFlags GetFlags(::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetFlags SetFlags(uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetFlags SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Acquires a buffer representing this file, if there is one, with the
    // requested access rights.
    //
    // `flags` may be any of `VMO_FLAG_*`.
    //
    // This method requires following rights:
    //
    // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
    // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetBuffer GetBuffer(uint32_t flags);

    // Acquires a buffer representing this file, if there is one, with the
    // requested access rights.
    //
    // `flags` may be any of `VMO_FLAG_*`.
    //
    // This method requires following rights:
    //
    // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
    // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetBuffer GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    zx_status_t HandleEvents(EventHandlers handlers);
   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Close Close(::zx::unowned_channel _client_end);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Describe Describe(::zx::unowned_channel _client_end);

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Sync Sync(::zx::unowned_channel _client_end);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Reads `count` bytes at the seek offset.
    // The seek offset is moved forward by the number of bytes read.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::Read Read(::zx::unowned_channel _client_end, uint64_t count);

    // Reads `count` bytes at the seek offset.
    // The seek offset is moved forward by the number of bytes read.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);

    // Reads `count` bytes at the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);

    // Reads `count` bytes at the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);

    // Writes data at the seek offset.
    // The seek offset is moved forward by the number of bytes written.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);

    // Writes data at the seek offset.
    // The seek offset is moved forward by the number of bytes written.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Writes data to the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);

    // Writes data to the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);

    // Moves the offset at which the next invocation of `Read()` or `Write()` will
    // occur.
    //
    // This method does not require any rights.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Seek Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);

    // Moves the offset at which the next invocation of `Read()` or `Write()` will
    // occur.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Seek Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);

    // Shrinks the file size to 'length' bytes.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Truncate Truncate(::zx::unowned_channel _client_end, uint64_t length);

    // Shrinks the file size to 'length' bytes.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Truncate Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Acquires a buffer representing this file, if there is one, with the
    // requested access rights.
    //
    // `flags` may be any of `VMO_FLAG_*`.
    //
    // This method requires following rights:
    //
    // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
    // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, uint32_t flags);

    // Acquires a buffer representing this file, if there is one, with the
    // requested access rights.
    //
    // `flags` may be any of `VMO_FLAG_*`.
    //
    // This method requires following rights:
    //
    // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
    // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // 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.
    static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);

    // Reads `count` bytes at the seek offset.
    // The seek offset is moved forward by the number of bytes read.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);

    // Reads `count` bytes at the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_READABLE`.
    static ::fidl::DecodeResult<ReadAtResponse> ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer);

    // Writes data at the seek offset.
    // The seek offset is moved forward by the number of bytes written.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);

    // Writes data to the provided offset.
    // Does not affect the seek offset.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<WriteAtResponse> WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer);

    // Moves the offset at which the next invocation of `Read()` or `Write()` will
    // occur.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SeekResponse> Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer);

    // Shrinks the file size to 'length' bytes.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<TruncateResponse> Truncate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<GetFlagsResponse> GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SetFlagsResponse> SetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer);

    // Acquires a buffer representing this file, if there is one, with the
    // requested access rights.
    //
    // `flags` may be any of `VMO_FLAG_*`.
    //
    // This method requires following rights:
    //
    // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
    // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
    static ::fidl::DecodeResult<GetBufferResponse> GetBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = File;
    using _Base = ::fidl::CompleterBase;

    using CloneCompleter = ::fidl::Completer<>;

    virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;

    class CloseCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<CloseResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;

    virtual void Close(CloseCompleter::Sync _completer) = 0;

    class DescribeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::DecodedMessage<DescribeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;

    virtual void Describe(DescribeCompleter::Sync _completer) = 0;

    class SyncCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SyncResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;

    virtual void Sync(SyncCompleter::Sync _completer) = 0;

    class GetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::DecodedMessage<GetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;

    virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;

    class SetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;

    virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;

    class NodeGetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
      void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;

    virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    class NodeSetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;

    virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    class ReadCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::DecodedMessage<ReadResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;

    virtual void Read(uint64_t count, ReadCompleter::Sync _completer) = 0;

    class ReadAtCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::DecodedMessage<ReadAtResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ReadAtCompleter = ::fidl::Completer<ReadAtCompleterBase>;

    virtual void ReadAt(uint64_t count, uint64_t offset, ReadAtCompleter::Sync _completer) = 0;

    class WriteCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint64_t actual);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
      void Reply(::fidl::DecodedMessage<WriteResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;

    virtual void Write(::fidl::VectorView<uint8_t> data, WriteCompleter::Sync _completer) = 0;

    class WriteAtCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint64_t actual);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
      void Reply(::fidl::DecodedMessage<WriteAtResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using WriteAtCompleter = ::fidl::Completer<WriteAtCompleterBase>;

    virtual void WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, WriteAtCompleter::Sync _completer) = 0;

    class SeekCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint64_t offset);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset);
      void Reply(::fidl::DecodedMessage<SeekResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SeekCompleter = ::fidl::Completer<SeekCompleterBase>;

    virtual void Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, SeekCompleter::Sync _completer) = 0;

    class TruncateCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<TruncateResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using TruncateCompleter = ::fidl::Completer<TruncateCompleterBase>;

    virtual void Truncate(uint64_t length, TruncateCompleter::Sync _completer) = 0;

    class GetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
      void Reply(::fidl::DecodedMessage<GetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetFlagsCompleter = ::fidl::Completer<GetFlagsCompleterBase>;

    virtual void GetFlags(GetFlagsCompleter::Sync _completer) = 0;

    class SetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetFlagsCompleter = ::fidl::Completer<SetFlagsCompleterBase>;

    virtual void SetFlags(uint32_t flags, SetFlagsCompleter::Sync _completer) = 0;

    class GetBufferCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
      void Reply(::fidl::DecodedMessage<GetBufferResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetBufferCompleter = ::fidl::Completer<GetBufferCompleterBase>;

    virtual void GetBuffer(uint32_t flags, GetBufferCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Caller provides the backing storage for FIDL message via response buffers.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Messages are encoded in-place.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void CloneRequest(const ::fidl::DecodedMessage<File::CloneRequest>& _msg);
    static void CloseRequest(const ::fidl::DecodedMessage<File::CloseRequest>& _msg);
    static void CloseResponse(const ::fidl::DecodedMessage<File::CloseResponse>& _msg);
    static void DescribeRequest(const ::fidl::DecodedMessage<File::DescribeRequest>& _msg);
    static void DescribeResponse(const ::fidl::DecodedMessage<File::DescribeResponse>& _msg);
    static void OnOpenResponse(const ::fidl::DecodedMessage<File::OnOpenResponse>& _msg);
    static void SyncRequest(const ::fidl::DecodedMessage<File::SyncRequest>& _msg);
    static void SyncResponse(const ::fidl::DecodedMessage<File::SyncResponse>& _msg);
    static void GetAttrRequest(const ::fidl::DecodedMessage<File::GetAttrRequest>& _msg);
    static void GetAttrResponse(const ::fidl::DecodedMessage<File::GetAttrResponse>& _msg);
    static void SetAttrRequest(const ::fidl::DecodedMessage<File::SetAttrRequest>& _msg);
    static void SetAttrResponse(const ::fidl::DecodedMessage<File::SetAttrResponse>& _msg);
    static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<File::NodeGetFlagsRequest>& _msg);
    static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<File::NodeGetFlagsResponse>& _msg);
    static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<File::NodeSetFlagsRequest>& _msg);
    static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<File::NodeSetFlagsResponse>& _msg);
    static void ReadRequest(const ::fidl::DecodedMessage<File::ReadRequest>& _msg);
    static void ReadResponse(const ::fidl::DecodedMessage<File::ReadResponse>& _msg);
    static void ReadAtRequest(const ::fidl::DecodedMessage<File::ReadAtRequest>& _msg);
    static void ReadAtResponse(const ::fidl::DecodedMessage<File::ReadAtResponse>& _msg);
    static void WriteRequest(const ::fidl::DecodedMessage<File::WriteRequest>& _msg);
    static void WriteResponse(const ::fidl::DecodedMessage<File::WriteResponse>& _msg);
    static void WriteAtRequest(const ::fidl::DecodedMessage<File::WriteAtRequest>& _msg);
    static void WriteAtResponse(const ::fidl::DecodedMessage<File::WriteAtResponse>& _msg);
    static void SeekRequest(const ::fidl::DecodedMessage<File::SeekRequest>& _msg);
    static void SeekResponse(const ::fidl::DecodedMessage<File::SeekResponse>& _msg);
    static void TruncateRequest(const ::fidl::DecodedMessage<File::TruncateRequest>& _msg);
    static void TruncateResponse(const ::fidl::DecodedMessage<File::TruncateResponse>& _msg);
    static void GetFlagsRequest(const ::fidl::DecodedMessage<File::GetFlagsRequest>& _msg);
    static void GetFlagsResponse(const ::fidl::DecodedMessage<File::GetFlagsResponse>& _msg);
    static void SetFlagsRequest(const ::fidl::DecodedMessage<File::SetFlagsRequest>& _msg);
    static void SetFlagsResponse(const ::fidl::DecodedMessage<File::SetFlagsResponse>& _msg);
    static void GetBufferRequest(const ::fidl::DecodedMessage<File::GetBufferRequest>& _msg);
    static void GetBufferResponse(const ::fidl::DecodedMessage<File::GetBufferResponse>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenEventTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchResponseTable;

// Directory defines a node which is capable of containing other Objects.
class Directory final {
  Directory() = delete;
 public:

  struct CloneRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryCloneRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct CloseResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryCloseResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using CloseRequest = ::fidl::AnyZeroArgMessage;

  struct DescribeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryDescribeResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using DescribeRequest = ::fidl::AnyZeroArgMessage;

  struct OnOpenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryOnOpenEventTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SyncResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySyncResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using SyncRequest = ::fidl::AnyZeroArgMessage;

  struct GetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryGetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetAttrRequest = ::fidl::AnyZeroArgMessage;

  struct SetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetAttrRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySetAttrRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 80;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetAttrResponse;
  };

  struct NodeGetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeGetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct NodeSetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeSetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct NodeSetFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeSetFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = NodeSetFlagsResponse;
  };

  struct OpenRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    uint32_t mode;
    ::fidl::StringView path;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryOpenRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 4096;
    static constexpr uint32_t AltPrimarySize = 48;
    static constexpr uint32_t AltMaxOutOfLine = 4096;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct UnlinkResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryUnlinkResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct UnlinkRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView path;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryUnlinkRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 4096;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 4096;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = UnlinkResponse;
  };

  struct ReadDirentsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::fidl::VectorView<uint8_t> dirents;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryReadDirentsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ReadDirentsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint64_t max_bytes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryReadDirentsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ReadDirentsResponse;
  };

  struct RewindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRewindResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using RewindRequest = ::fidl::AnyZeroArgMessage;

  struct GetTokenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::zx::handle token;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryGetTokenResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetTokenRequest = ::fidl::AnyZeroArgMessage;

  struct RenameResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRenameResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct RenameRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView src;
    ::zx::handle dst_parent_token;
    ::fidl::StringView dst;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRenameRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 56;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = RenameResponse;
  };

  struct LinkResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryLinkResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct LinkRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView src;
    ::zx::handle dst_parent_token;
    ::fidl::StringView dst;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryLinkRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 56;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = LinkResponse;
  };

  struct WatchResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatchResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct WatchRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t mask;
    uint32_t options;
    ::zx::channel watcher;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatchRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = WatchResponse;
  };


  struct EventHandlers {
    // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
    fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;

    // Fallback handler when an unknown ordinal is received.
    // Caller may put custom error handling logic here.
    fit::callback<zx_status_t()> unknown;
  };

  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class Open_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
      ~Open_Impl() = default;
      Open_Impl(Open_Impl&& other) = default;
      Open_Impl& operator=(Open_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
      ~Unlink_Impl() = default;
      Unlink_Impl(Unlink_Impl&& other) = default;
      Unlink_Impl& operator=(Unlink_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadDirents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes);
      ~ReadDirents_Impl() = default;
      ReadDirents_Impl(ReadDirents_Impl&& other) = default;
      ReadDirents_Impl& operator=(ReadDirents_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rewind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Rewind_Impl(::zx::unowned_channel _client_end);
      ~Rewind_Impl() = default;
      Rewind_Impl(Rewind_Impl&& other) = default;
      Rewind_Impl& operator=(Rewind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetToken_Impl(::zx::unowned_channel _client_end);
      ~GetToken_Impl() = default;
      GetToken_Impl(GetToken_Impl&& other) = default;
      GetToken_Impl& operator=(GetToken_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
      ~Rename_Impl() = default;
      Rename_Impl(Rename_Impl&& other) = default;
      Rename_Impl& operator=(Rename_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
      ~Link_Impl() = default;
      Link_Impl(Link_Impl&& other) = default;
      Link_Impl& operator=(Link_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Watch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
      ~Watch_Impl() = default;
      Watch_Impl(Watch_Impl&& other) = default;
      Watch_Impl& operator=(Watch_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Open = Open_Impl;
    using Unlink = Unlink_Impl<UnlinkResponse>;
    using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
    using Rewind = Rewind_Impl<RewindResponse>;
    using GetToken = GetToken_Impl<GetTokenResponse>;
    using Rename = Rename_Impl<RenameResponse>;
    using Link = Link_Impl<LinkResponse>;
    using Watch = Watch_Impl<WatchResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class Open_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
      ~Open_Impl() = default;
      Open_Impl(Open_Impl&& other) = default;
      Open_Impl& operator=(Open_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
      ~Unlink_Impl() = default;
      Unlink_Impl(Unlink_Impl&& other) = default;
      Unlink_Impl& operator=(Unlink_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadDirents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
      ~ReadDirents_Impl() = default;
      ReadDirents_Impl(ReadDirents_Impl&& other) = default;
      ReadDirents_Impl& operator=(ReadDirents_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rewind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Rewind_Impl() = default;
      Rewind_Impl(Rewind_Impl&& other) = default;
      Rewind_Impl& operator=(Rewind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetToken_Impl() = default;
      GetToken_Impl(GetToken_Impl&& other) = default;
      GetToken_Impl& operator=(GetToken_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
      ~Rename_Impl() = default;
      Rename_Impl(Rename_Impl&& other) = default;
      Rename_Impl& operator=(Rename_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
      ~Link_Impl() = default;
      Link_Impl(Link_Impl&& other) = default;
      Link_Impl& operator=(Link_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Watch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
      ~Watch_Impl() = default;
      Watch_Impl(Watch_Impl&& other) = default;
      Watch_Impl& operator=(Watch_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Open = Open_Impl;
    using Unlink = Unlink_Impl<UnlinkResponse>;
    using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
    using Rewind = Rewind_Impl<RewindResponse>;
    using GetToken = GetToken_Impl<GetTokenResponse>;
    using Rename = Rename_Impl<RenameResponse>;
    using Link = Link_Impl<LinkResponse>;
    using Watch = Watch_Impl<WatchResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Close Close();

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Describe Describe();

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Sync Sync();

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetAttr GetAttr();

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeGetFlags NodeGetFlags();

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Request is heap-allocated.
    ResultOf::Open Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Unlink Unlink(::fidl::StringView path);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::ReadDirents ReadDirents(uint64_t max_bytes);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ReadDirents ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Rewind Rewind();

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Rewind Rewind(::fidl::BytePart _response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetToken GetToken();

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Watch Watch(uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    zx_status_t HandleEvents(EventHandlers handlers);
   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Close Close(::zx::unowned_channel _client_end);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Describe Describe(::zx::unowned_channel _client_end);

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Sync Sync(::zx::unowned_channel _client_end);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Request is heap-allocated.
    static ResultOf::Open Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Rewind Rewind(::zx::unowned_channel _client_end);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Rewind Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Watch Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // 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.
    static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    static ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    static ::fidl::DecodeResult<RewindResponse> Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    static ::fidl::DecodeResult<WatchResponse> Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = Directory;
    using _Base = ::fidl::CompleterBase;

    using CloneCompleter = ::fidl::Completer<>;

    virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;

    class CloseCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<CloseResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;

    virtual void Close(CloseCompleter::Sync _completer) = 0;

    class DescribeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::DecodedMessage<DescribeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;

    virtual void Describe(DescribeCompleter::Sync _completer) = 0;

    class SyncCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SyncResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;

    virtual void Sync(SyncCompleter::Sync _completer) = 0;

    class GetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::DecodedMessage<GetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;

    virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;

    class SetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;

    virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;

    class NodeGetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
      void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;

    virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    class NodeSetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;

    virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    using OpenCompleter = ::fidl::Completer<>;

    virtual void Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object, OpenCompleter::Sync _completer) = 0;

    class UnlinkCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<UnlinkResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;

    virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;

    class ReadDirentsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents);
      void Reply(::fidl::DecodedMessage<ReadDirentsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ReadDirentsCompleter = ::fidl::Completer<ReadDirentsCompleterBase>;

    virtual void ReadDirents(uint64_t max_bytes, ReadDirentsCompleter::Sync _completer) = 0;

    class RewindCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<RewindResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RewindCompleter = ::fidl::Completer<RewindCompleterBase>;

    virtual void Rewind(RewindCompleter::Sync _completer) = 0;

    class GetTokenCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::zx::handle token);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token);
      void Reply(::fidl::DecodedMessage<GetTokenResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;

    virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;

    class RenameCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<RenameResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;

    virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;

    class LinkCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<LinkResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;

    virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;

    class WatchCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<WatchResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using WatchCompleter = ::fidl::Completer<WatchCompleterBase>;

    virtual void Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, WatchCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Caller provides the backing storage for FIDL message via response buffers.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Messages are encoded in-place.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void CloneRequest(const ::fidl::DecodedMessage<Directory::CloneRequest>& _msg);
    static void CloseRequest(const ::fidl::DecodedMessage<Directory::CloseRequest>& _msg);
    static void CloseResponse(const ::fidl::DecodedMessage<Directory::CloseResponse>& _msg);
    static void DescribeRequest(const ::fidl::DecodedMessage<Directory::DescribeRequest>& _msg);
    static void DescribeResponse(const ::fidl::DecodedMessage<Directory::DescribeResponse>& _msg);
    static void OnOpenResponse(const ::fidl::DecodedMessage<Directory::OnOpenResponse>& _msg);
    static void SyncRequest(const ::fidl::DecodedMessage<Directory::SyncRequest>& _msg);
    static void SyncResponse(const ::fidl::DecodedMessage<Directory::SyncResponse>& _msg);
    static void GetAttrRequest(const ::fidl::DecodedMessage<Directory::GetAttrRequest>& _msg);
    static void GetAttrResponse(const ::fidl::DecodedMessage<Directory::GetAttrResponse>& _msg);
    static void SetAttrRequest(const ::fidl::DecodedMessage<Directory::SetAttrRequest>& _msg);
    static void SetAttrResponse(const ::fidl::DecodedMessage<Directory::SetAttrResponse>& _msg);
    static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeGetFlagsRequest>& _msg);
    static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeGetFlagsResponse>& _msg);
    static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeSetFlagsRequest>& _msg);
    static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeSetFlagsResponse>& _msg);
    static void OpenRequest(const ::fidl::DecodedMessage<Directory::OpenRequest>& _msg);
    static void UnlinkRequest(const ::fidl::DecodedMessage<Directory::UnlinkRequest>& _msg);
    static void UnlinkResponse(const ::fidl::DecodedMessage<Directory::UnlinkResponse>& _msg);
    static void ReadDirentsRequest(const ::fidl::DecodedMessage<Directory::ReadDirentsRequest>& _msg);
    static void ReadDirentsResponse(const ::fidl::DecodedMessage<Directory::ReadDirentsResponse>& _msg);
    static void RewindRequest(const ::fidl::DecodedMessage<Directory::RewindRequest>& _msg);
    static void RewindResponse(const ::fidl::DecodedMessage<Directory::RewindResponse>& _msg);
    static void GetTokenRequest(const ::fidl::DecodedMessage<Directory::GetTokenRequest>& _msg);
    static void GetTokenResponse(const ::fidl::DecodedMessage<Directory::GetTokenResponse>& _msg);
    static void RenameRequest(const ::fidl::DecodedMessage<Directory::RenameRequest>& _msg);
    static void RenameResponse(const ::fidl::DecodedMessage<Directory::RenameResponse>& _msg);
    static void LinkRequest(const ::fidl::DecodedMessage<Directory::LinkRequest>& _msg);
    static void LinkResponse(const ::fidl::DecodedMessage<Directory::LinkResponse>& _msg);
    static void WatchRequest(const ::fidl::DecodedMessage<Directory::WatchRequest>& _msg);
    static void WatchResponse(const ::fidl::DecodedMessage<Directory::WatchResponse>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenEventTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathRequestTable;
extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathResponseTable;

// DirectoryAdmin defines a directory which is capable of handling
// administrator tasks within the filesystem.
class DirectoryAdmin final {
  DirectoryAdmin() = delete;
 public:

  struct CloneRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminCloneRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct CloseResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminCloseResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using CloseRequest = ::fidl::AnyZeroArgMessage;

  struct DescribeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminDescribeResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using DescribeRequest = ::fidl::AnyZeroArgMessage;

  struct OnOpenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeInfo info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminOnOpenEventTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 24;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SyncResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSyncResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using SyncRequest = ::fidl::AnyZeroArgMessage;

  struct GetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetAttrRequest = ::fidl::AnyZeroArgMessage;

  struct SetAttrResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSetAttrResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetAttrRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    ::llcpp::fuchsia::io::NodeAttributes attributes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSetAttrRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 80;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 80;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetAttrResponse;
  };

  struct NodeGetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeGetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct NodeSetFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeSetFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct NodeSetFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeSetFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = NodeSetFlagsResponse;
  };

  struct OpenRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t flags;
    uint32_t mode;
    ::fidl::StringView path;
    ::zx::channel object;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminOpenRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 4096;
    static constexpr uint32_t AltPrimarySize = 48;
    static constexpr uint32_t AltMaxOutOfLine = 4096;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct UnlinkResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnlinkResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct UnlinkRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView path;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnlinkRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 4096;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 4096;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = UnlinkResponse;
  };

  struct ReadDirentsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::fidl::VectorView<uint8_t> dirents;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminReadDirentsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ReadDirentsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint64_t max_bytes;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminReadDirentsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ReadDirentsResponse;
  };

  struct RewindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRewindResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using RewindRequest = ::fidl::AnyZeroArgMessage;

  struct GetTokenResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::zx::handle token;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetTokenResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetTokenRequest = ::fidl::AnyZeroArgMessage;

  struct RenameResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRenameResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct RenameRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView src;
    ::zx::handle dst_parent_token;
    ::fidl::StringView dst;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRenameRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 56;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = RenameResponse;
  };

  struct LinkResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminLinkResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct LinkRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView src;
    ::zx::handle dst_parent_token;
    ::fidl::StringView dst;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminLinkRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 56;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = LinkResponse;
  };

  struct WatchResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminWatchResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct WatchRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t mask;
    uint32_t options;
    ::zx::channel watcher;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminWatchRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = WatchResponse;
  };

  struct MountResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct MountRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel remote;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = MountResponse;
  };

  struct MountAndCreateResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountAndCreateResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct MountAndCreateRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel remote;
    ::fidl::StringView name;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 48;
    static constexpr uint32_t MaxOutOfLine = 256;
    static constexpr uint32_t AltPrimarySize = 48;
    static constexpr uint32_t AltMaxOutOfLine = 256;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = MountAndCreateResponse;
  };

  struct UnmountResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnmountResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using UnmountRequest = ::fidl::AnyZeroArgMessage;

  struct UnmountNodeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::zx::channel remote;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using UnmountNodeRequest = ::fidl::AnyZeroArgMessage;

  struct QueryFilesystemResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::llcpp::fuchsia::io::FilesystemInfo* info;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 96;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using QueryFilesystemRequest = ::fidl::AnyZeroArgMessage;

  struct GetDevicePathResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t s;
    ::fidl::StringView path;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 4096;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDevicePathRequest = ::fidl::AnyZeroArgMessage;


  struct EventHandlers {
    // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
    fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;

    // Fallback handler when an unknown ordinal is received.
    // Caller may put custom error handling logic here.
    fit::callback<zx_status_t()> unknown;
  };

  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class Open_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
      ~Open_Impl() = default;
      Open_Impl(Open_Impl&& other) = default;
      Open_Impl& operator=(Open_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
      ~Unlink_Impl() = default;
      Unlink_Impl(Unlink_Impl&& other) = default;
      Unlink_Impl& operator=(Unlink_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadDirents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes);
      ~ReadDirents_Impl() = default;
      ReadDirents_Impl(ReadDirents_Impl&& other) = default;
      ReadDirents_Impl& operator=(ReadDirents_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rewind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Rewind_Impl(::zx::unowned_channel _client_end);
      ~Rewind_Impl() = default;
      Rewind_Impl(Rewind_Impl&& other) = default;
      Rewind_Impl& operator=(Rewind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetToken_Impl(::zx::unowned_channel _client_end);
      ~GetToken_Impl() = default;
      GetToken_Impl(GetToken_Impl&& other) = default;
      GetToken_Impl& operator=(GetToken_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
      ~Rename_Impl() = default;
      Rename_Impl(Rename_Impl&& other) = default;
      Rename_Impl& operator=(Rename_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
      ~Link_Impl() = default;
      Link_Impl(Link_Impl&& other) = default;
      Link_Impl& operator=(Link_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Watch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
      ~Watch_Impl() = default;
      Watch_Impl(Watch_Impl&& other) = default;
      Watch_Impl& operator=(Watch_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Mount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Mount_Impl(::zx::unowned_channel _client_end, ::zx::channel remote);
      ~Mount_Impl() = default;
      Mount_Impl(Mount_Impl&& other) = default;
      Mount_Impl& operator=(Mount_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class MountAndCreate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      MountAndCreate_Impl(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags);
      ~MountAndCreate_Impl() = default;
      MountAndCreate_Impl(MountAndCreate_Impl&& other) = default;
      MountAndCreate_Impl& operator=(MountAndCreate_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Unmount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Unmount_Impl(::zx::unowned_channel _client_end);
      ~Unmount_Impl() = default;
      Unmount_Impl(Unmount_Impl&& other) = default;
      Unmount_Impl& operator=(Unmount_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class UnmountNode_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      UnmountNode_Impl(::zx::unowned_channel _client_end);
      ~UnmountNode_Impl() = default;
      UnmountNode_Impl(UnmountNode_Impl&& other) = default;
      UnmountNode_Impl& operator=(UnmountNode_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class QueryFilesystem_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      QueryFilesystem_Impl(::zx::unowned_channel _client_end);
      ~QueryFilesystem_Impl() = default;
      QueryFilesystem_Impl(QueryFilesystem_Impl&& other) = default;
      QueryFilesystem_Impl& operator=(QueryFilesystem_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePath_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDevicePath_Impl(::zx::unowned_channel _client_end);
      ~GetDevicePath_Impl() = default;
      GetDevicePath_Impl(GetDevicePath_Impl&& other) = default;
      GetDevicePath_Impl& operator=(GetDevicePath_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Open = Open_Impl;
    using Unlink = Unlink_Impl<UnlinkResponse>;
    using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
    using Rewind = Rewind_Impl<RewindResponse>;
    using GetToken = GetToken_Impl<GetTokenResponse>;
    using Rename = Rename_Impl<RenameResponse>;
    using Link = Link_Impl<LinkResponse>;
    using Watch = Watch_Impl<WatchResponse>;
    using Mount = Mount_Impl<MountResponse>;
    using MountAndCreate = MountAndCreate_Impl<MountAndCreateResponse>;
    using Unmount = Unmount_Impl<UnmountResponse>;
    using UnmountNode = UnmountNode_Impl<UnmountNodeResponse>;
    using QueryFilesystem = QueryFilesystem_Impl<QueryFilesystemResponse>;
    using GetDevicePath = GetDevicePath_Impl<GetDevicePathResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    class Clone_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
      ~Clone_Impl() = default;
      Clone_Impl(Clone_Impl&& other) = default;
      Clone_Impl& operator=(Clone_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Close_Impl() = default;
      Close_Impl(Close_Impl&& other) = default;
      Close_Impl& operator=(Close_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Describe_Impl() = default;
      Describe_Impl(Describe_Impl&& other) = default;
      Describe_Impl& operator=(Describe_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Sync_Impl() = default;
      Sync_Impl(Sync_Impl&& other) = default;
      Sync_Impl& operator=(Sync_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetAttr_Impl() = default;
      GetAttr_Impl(GetAttr_Impl&& other) = default;
      GetAttr_Impl& operator=(GetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
      ~SetAttr_Impl() = default;
      SetAttr_Impl(SetAttr_Impl&& other) = default;
      SetAttr_Impl& operator=(SetAttr_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~NodeGetFlags_Impl() = default;
      NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
      NodeGetFlags_Impl& operator=(NodeGetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~NodeSetFlags_Impl() = default;
      NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
      NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class Open_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
      ~Open_Impl() = default;
      Open_Impl(Open_Impl&& other) = default;
      Open_Impl& operator=(Open_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
      ~Unlink_Impl() = default;
      Unlink_Impl(Unlink_Impl&& other) = default;
      Unlink_Impl& operator=(Unlink_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ReadDirents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
      ~ReadDirents_Impl() = default;
      ReadDirents_Impl(ReadDirents_Impl&& other) = default;
      ReadDirents_Impl& operator=(ReadDirents_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rewind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Rewind_Impl() = default;
      Rewind_Impl(Rewind_Impl&& other) = default;
      Rewind_Impl& operator=(Rewind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetToken_Impl() = default;
      GetToken_Impl(GetToken_Impl&& other) = default;
      GetToken_Impl& operator=(GetToken_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
      ~Rename_Impl() = default;
      Rename_Impl(Rename_Impl&& other) = default;
      Rename_Impl& operator=(Rename_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
      ~Link_Impl() = default;
      Link_Impl(Link_Impl&& other) = default;
      Link_Impl& operator=(Link_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Watch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
      ~Watch_Impl() = default;
      Watch_Impl(Watch_Impl&& other) = default;
      Watch_Impl& operator=(Watch_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Mount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Mount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);
      ~Mount_Impl() = default;
      Mount_Impl(Mount_Impl&& other) = default;
      Mount_Impl& operator=(Mount_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class MountAndCreate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      MountAndCreate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);
      ~MountAndCreate_Impl() = default;
      MountAndCreate_Impl(MountAndCreate_Impl&& other) = default;
      MountAndCreate_Impl& operator=(MountAndCreate_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Unmount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Unmount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Unmount_Impl() = default;
      Unmount_Impl(Unmount_Impl&& other) = default;
      Unmount_Impl& operator=(Unmount_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class UnmountNode_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      UnmountNode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~UnmountNode_Impl() = default;
      UnmountNode_Impl(UnmountNode_Impl&& other) = default;
      UnmountNode_Impl& operator=(UnmountNode_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class QueryFilesystem_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      QueryFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~QueryFilesystem_Impl() = default;
      QueryFilesystem_Impl(QueryFilesystem_Impl&& other) = default;
      QueryFilesystem_Impl& operator=(QueryFilesystem_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePath_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDevicePath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDevicePath_Impl() = default;
      GetDevicePath_Impl(GetDevicePath_Impl&& other) = default;
      GetDevicePath_Impl& operator=(GetDevicePath_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Clone = Clone_Impl;
    using Close = Close_Impl<CloseResponse>;
    using Describe = Describe_Impl<DescribeResponse>;
    using Sync = Sync_Impl<SyncResponse>;
    using GetAttr = GetAttr_Impl<GetAttrResponse>;
    using SetAttr = SetAttr_Impl<SetAttrResponse>;
    using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
    using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
    using Open = Open_Impl;
    using Unlink = Unlink_Impl<UnlinkResponse>;
    using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
    using Rewind = Rewind_Impl<RewindResponse>;
    using GetToken = GetToken_Impl<GetTokenResponse>;
    using Rename = Rename_Impl<RenameResponse>;
    using Link = Link_Impl<LinkResponse>;
    using Watch = Watch_Impl<WatchResponse>;
    using Mount = Mount_Impl<MountResponse>;
    using MountAndCreate = MountAndCreate_Impl<MountAndCreateResponse>;
    using Unmount = Unmount_Impl<UnmountResponse>;
    using UnmountNode = UnmountNode_Impl<UnmountNodeResponse>;
    using QueryFilesystem = QueryFilesystem_Impl<QueryFilesystemResponse>;
    using GetDevicePath = GetDevicePath_Impl<GetDevicePathResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Close Close();

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Describe Describe();

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Sync Sync();

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetAttr GetAttr();

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeGetFlags NodeGetFlags();

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Request is heap-allocated.
    ResultOf::Open Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Unlink Unlink(::fidl::StringView path);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::ReadDirents ReadDirents(uint64_t max_bytes);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ReadDirents ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Rewind Rewind();

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Rewind Rewind(::fidl::BytePart _response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetToken GetToken();

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Watch Watch(uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Mount a channel representing a remote filesystem onto this directory.
    // All future requests to this node will be forwarded to the remote filesystem.
    // To re-open a node without forwarding to the remote target, the node
    // should be opened with `OPEN_FLAG_NO_REMOTE`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Mount Mount(::zx::channel remote);

    // Mount a channel representing a remote filesystem onto this directory.
    // All future requests to this node will be forwarded to the remote filesystem.
    // To re-open a node without forwarding to the remote target, the node
    // should be opened with `OPEN_FLAG_NO_REMOTE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Mount Mount(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);

    // Atomically create a directory with a provided path, and mount the
    // remote handle to the newly created directory.
    // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::MountAndCreate MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags);

    // Atomically create a directory with a provided path, and mount the
    // remote handle to the newly created directory.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::MountAndCreate MountAndCreate(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Unmount this filesystem. After this function returns successfully,
    // all connections to the filesystem will be terminated.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Unmount Unmount();

    // Unmount this filesystem. After this function returns successfully,
    // all connections to the filesystem will be terminated.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Unmount Unmount(::fidl::BytePart _response_buffer);

    // Detach a node which was previously attached to this directory
    // with Mount.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::UnmountNode UnmountNode();

    // Detach a node which was previously attached to this directory
    // with Mount.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::UnmountNode UnmountNode(::fidl::BytePart _response_buffer);

    // Query the filesystem for filesystem-specific information.
    // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::QueryFilesystem QueryFilesystem();

    // Query the filesystem for filesystem-specific information.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::QueryFilesystem QueryFilesystem(::fidl::BytePart _response_buffer);

    // Acquire the path to the device backing this filesystem, if there is one.
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetDevicePath GetDevicePath();

    // Acquire the path to the device backing this filesystem, if there is one.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDevicePath GetDevicePath(::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    zx_status_t HandleEvents(EventHandlers handlers);
   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Close Close(::zx::unowned_channel _client_end);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // 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.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Describe Describe(::zx::unowned_channel _client_end);

    // 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Sync Sync(::zx::unowned_channel _client_end);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Request is heap-allocated.
    static ResultOf::Open Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Rewind Rewind(::zx::unowned_channel _client_end);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Rewind Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);

    // 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: `OPEN_RIGHT_WRITABLE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Watch Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Mount a channel representing a remote filesystem onto this directory.
    // All future requests to this node will be forwarded to the remote filesystem.
    // To re-open a node without forwarding to the remote target, the node
    // should be opened with `OPEN_FLAG_NO_REMOTE`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Mount Mount(::zx::unowned_channel _client_end, ::zx::channel remote);

    // Mount a channel representing a remote filesystem onto this directory.
    // All future requests to this node will be forwarded to the remote filesystem.
    // To re-open a node without forwarding to the remote target, the node
    // should be opened with `OPEN_FLAG_NO_REMOTE`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Mount Mount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);

    // Atomically create a directory with a provided path, and mount the
    // remote handle to the newly created directory.
    // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::MountAndCreate MountAndCreate(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags);

    // Atomically create a directory with a provided path, and mount the
    // remote handle to the newly created directory.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::MountAndCreate MountAndCreate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Unmount this filesystem. After this function returns successfully,
    // all connections to the filesystem will be terminated.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Unmount Unmount(::zx::unowned_channel _client_end);

    // Unmount this filesystem. After this function returns successfully,
    // all connections to the filesystem will be terminated.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Unmount Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Detach a node which was previously attached to this directory
    // with Mount.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::UnmountNode UnmountNode(::zx::unowned_channel _client_end);

    // Detach a node which was previously attached to this directory
    // with Mount.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::UnmountNode UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Query the filesystem for filesystem-specific information.
    // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::QueryFilesystem QueryFilesystem(::zx::unowned_channel _client_end);

    // Query the filesystem for filesystem-specific information.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::QueryFilesystem QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Acquire the path to the device backing this filesystem, if there is one.
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetDevicePath GetDevicePath(::zx::unowned_channel _client_end);

    // Acquire the path to the device backing this filesystem, if there is one.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDevicePath GetDevicePath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding handler
    // defined in |EventHandlers|. The return status of the handler function is folded with any
    // transport-level errors and returned.
    static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Create another connection to the same remote object.
    //
    // `flags` may be any of:
    //
    // - `OPEN_RIGHT_*`
    // - `OPEN_FLAG_APPEND`
    // - `OPEN_FLAG_NO_REMOTE`
    // - `OPEN_FLAG_DESCRIBE`
    // - `CLONE_FLAG_SAME_RIGHTS`
    //
    // All other flags are ignored.
    //
    // The `OPEN_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.
    // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
    // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
    // `CLONE_FLAG_SAME_RIGHTS`.
    static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);

    // Terminates connection with object.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // 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.
    static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Synchronizes updates to the node to the underlying media, if it exists.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires information about the node.
    //
    // This method does not require any rights.
    static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Updates information about the node.
    // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);

    // Acquires the `Directory.Open` rights and flags used to access this file.
    //
    // This method does not require any rights.
    // This method has the same functionality as GetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Changes the `Directory.Open` flags used to access the file.
    // Supported flags which can be turned on / off:
    // - `OPEN_FLAG_APPEND`
    //
    // This method does not require any rights.
    // This method has the same functionality as SetFlags for File and is
    // meant as an in-progress replacement.
    static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);

    // 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.
    //
    // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
    // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
    // on the `object` handle, indicating the type of object opened.
    //
    // If an unknown value is sent for either flags or mode, the connection should
    // be closed.
    //
    // `OPEN_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.
    //
    // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
    // the `OPEN_FLAG_NODE_REFERENCE` flag.
    static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);

    // Detaches an object from this directory object.
    //
    // The underlying object may or may not be deleted after this method
    // completes: 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 removed.
    //
    // If a directory is unlinked while it still has an open reference,
    // it must become read-only, preventing new entries from being created
    // until all references close and the directory is destroyed.
    //
    // `path` identifies the file which should be detached.
    // If `path` contains multiple segments, separated by "/" characters,
    // then the directory is traversed, one segment at a time, relative to the
    // originally accessed Directory.
    //
    // Returns:
    //   `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
    //     allow writable access.
    //   `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
    //   `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
    //   `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
    //   `ZX_ERR_UNAVAILABLE` if `path` is ".".
    //
    // Other errors may be returned for filesystem-specific reasons.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);

    // 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.
    //
    // 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 `DIRENT_TYPE_*` 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.
    static ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);

    // Resets the directory seek offset.
    //
    // This method does not require any rights, similar to ReadDirents.
    static ::fidl::DecodeResult<RewindResponse> Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquires a token to a Directory which can be used to identify
    // access to it at a later point in time.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Renames an object named src to the name dst, in a directory represented by token.
    //
    // `src/dst` must be resolved object names. Including "/" in any position
    // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
    // Returning "/" at the end of either string implies that it must be a
    // directory, or else `ZX_ERR_NOT_DIR` should be returned.
    //
    // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);

    // 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: `OPEN_RIGHT_WRITABLE`.
    static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    //
    // The `watcher` handle will send messages of the form:
    // ```
    // struct {
    //   uint8 event;
    //   uint8 len;
    //   char name[];
    // };
    // ```
    // Where names are NOT null-terminated.
    //
    // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
    //
    // Mask specifies a bitmask of events to observe.
    // Options must be zero; it is reserved.
    //
    // This method does not require any rights, similar to ReadDirents.
    static ::fidl::DecodeResult<WatchResponse> Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);

    // Mount a channel representing a remote filesystem onto this directory.
    // All future requests to this node will be forwarded to the remote filesystem.
    // To re-open a node without forwarding to the remote target, the node
    // should be opened with `OPEN_FLAG_NO_REMOTE`.
    static ::fidl::DecodeResult<MountResponse> Mount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountRequest> params, ::fidl::BytePart response_buffer);

    // Atomically create a directory with a provided path, and mount the
    // remote handle to the newly created directory.
    static ::fidl::DecodeResult<MountAndCreateResponse> MountAndCreate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer);

    // Unmount this filesystem. After this function returns successfully,
    // all connections to the filesystem will be terminated.
    static ::fidl::DecodeResult<UnmountResponse> Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Detach a node which was previously attached to this directory
    // with Mount.
    static ::fidl::DecodeResult<UnmountNodeResponse> UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Query the filesystem for filesystem-specific information.
    static ::fidl::DecodeResult<QueryFilesystemResponse> QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Acquire the path to the device backing this filesystem, if there is one.
    static ::fidl::DecodeResult<GetDevicePathResponse> GetDevicePath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = DirectoryAdmin;
    using _Base = ::fidl::CompleterBase;

    using CloneCompleter = ::fidl::Completer<>;

    virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;

    class CloseCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<CloseResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;

    virtual void Close(CloseCompleter::Sync _completer) = 0;

    class DescribeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
      void Reply(::fidl::DecodedMessage<DescribeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;

    virtual void Describe(DescribeCompleter::Sync _completer) = 0;

    class SyncCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SyncResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;

    virtual void Sync(SyncCompleter::Sync _completer) = 0;

    class GetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
      void Reply(::fidl::DecodedMessage<GetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;

    virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;

    class SetAttrCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<SetAttrResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;

    virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;

    class NodeGetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
      void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;

    virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    class NodeSetFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;

    virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }

    using OpenCompleter = ::fidl::Completer<>;

    virtual void Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object, OpenCompleter::Sync _completer) = 0;

    class UnlinkCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<UnlinkResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;

    virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;

    class ReadDirentsCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents);
      void Reply(::fidl::DecodedMessage<ReadDirentsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ReadDirentsCompleter = ::fidl::Completer<ReadDirentsCompleterBase>;

    virtual void ReadDirents(uint64_t max_bytes, ReadDirentsCompleter::Sync _completer) = 0;

    class RewindCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<RewindResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RewindCompleter = ::fidl::Completer<RewindCompleterBase>;

    virtual void Rewind(RewindCompleter::Sync _completer) = 0;

    class GetTokenCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::zx::handle token);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token);
      void Reply(::fidl::DecodedMessage<GetTokenResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;

    virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;

    class RenameCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<RenameResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;

    virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;

    class LinkCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<LinkResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;

    virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;

    class WatchCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<WatchResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using WatchCompleter = ::fidl::Completer<WatchCompleterBase>;

    virtual void Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, WatchCompleter::Sync _completer) = 0;

    class MountCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<MountResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using MountCompleter = ::fidl::Completer<MountCompleterBase>;

    virtual void Mount(::zx::channel remote, MountCompleter::Sync _completer) = 0;

    class MountAndCreateCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<MountAndCreateResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using MountAndCreateCompleter = ::fidl::Completer<MountAndCreateCompleterBase>;

    virtual void MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags, MountAndCreateCompleter::Sync _completer) = 0;

    class UnmountCompleterBase : public _Base {
     public:
      void Reply(int32_t s);
      void Reply(::fidl::BytePart _buffer, int32_t s);
      void Reply(::fidl::DecodedMessage<UnmountResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using UnmountCompleter = ::fidl::Completer<UnmountCompleterBase>;

    virtual void Unmount(UnmountCompleter::Sync _completer) = 0;

    class UnmountNodeCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::zx::channel remote);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::channel remote);
      void Reply(::fidl::DecodedMessage<UnmountNodeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using UnmountNodeCompleter = ::fidl::Completer<UnmountNodeCompleterBase>;

    virtual void UnmountNode(UnmountNodeCompleter::Sync _completer) = 0;

    class QueryFilesystemCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info);
      void Reply(::fidl::DecodedMessage<QueryFilesystemResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using QueryFilesystemCompleter = ::fidl::Completer<QueryFilesystemCompleterBase>;

    virtual void QueryFilesystem(QueryFilesystemCompleter::Sync _completer) = 0;

    class GetDevicePathCompleterBase : public _Base {
     public:
      void Reply(int32_t s, ::fidl::StringView path);
      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView path);
      void Reply(::fidl::DecodedMessage<GetDevicePathResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDevicePathCompleter = ::fidl::Completer<GetDevicePathCompleterBase>;

    virtual void GetDevicePath(GetDevicePathCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Caller provides the backing storage for FIDL message via response buffers.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);

  // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_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`).
  // Messages are encoded in-place.
  static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void CloneRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloneRequest>& _msg);
    static void CloseRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloseRequest>& _msg);
    static void CloseResponse(const ::fidl::DecodedMessage<DirectoryAdmin::CloseResponse>& _msg);
    static void DescribeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeRequest>& _msg);
    static void DescribeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeResponse>& _msg);
    static void OnOpenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::OnOpenResponse>& _msg);
    static void SyncRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SyncRequest>& _msg);
    static void SyncResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SyncResponse>& _msg);
    static void GetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrRequest>& _msg);
    static void GetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrResponse>& _msg);
    static void SetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrRequest>& _msg);
    static void SetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrResponse>& _msg);
    static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsRequest>& _msg);
    static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsResponse>& _msg);
    static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsRequest>& _msg);
    static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsResponse>& _msg);
    static void OpenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::OpenRequest>& _msg);
    static void UnlinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkRequest>& _msg);
    static void UnlinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkResponse>& _msg);
    static void ReadDirentsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsRequest>& _msg);
    static void ReadDirentsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsResponse>& _msg);
    static void RewindRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RewindRequest>& _msg);
    static void RewindResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RewindResponse>& _msg);
    static void GetTokenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenRequest>& _msg);
    static void GetTokenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenResponse>& _msg);
    static void RenameRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RenameRequest>& _msg);
    static void RenameResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RenameResponse>& _msg);
    static void LinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::LinkRequest>& _msg);
    static void LinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::LinkResponse>& _msg);
    static void WatchRequest(const ::fidl::DecodedMessage<DirectoryAdmin::WatchRequest>& _msg);
    static void WatchResponse(const ::fidl::DecodedMessage<DirectoryAdmin::WatchResponse>& _msg);
    static void MountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountRequest>& _msg);
    static void MountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountResponse>& _msg);
    static void MountAndCreateRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateRequest>& _msg);
    static void MountAndCreateResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateResponse>& _msg);
    static void UnmountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountRequest>& _msg);
    static void UnmountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountResponse>& _msg);
    static void UnmountNodeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeRequest>& _msg);
    static void UnmountNodeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeResponse>& _msg);
    static void QueryFilesystemRequest(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemRequest>& _msg);
    static void QueryFilesystemResponse(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemResponse>& _msg);
    static void GetDevicePathRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathRequest>& _msg);
    static void GetDevicePathResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathResponse>& _msg);
  };
};

// A dirent with an unknown type.
constexpr uint8_t DIRENT_TYPE_UNKNOWN = 0u;

// A dirent representing a socket object.
constexpr uint8_t DIRENT_TYPE_SOCKET = 12u;

// A dirent representing a service object.
constexpr uint8_t DIRENT_TYPE_SERVICE = 16u;

// A dirent representing a file object.
constexpr uint8_t DIRENT_TYPE_FILE = 8u;

// A dirent representing a directory object.
constexpr uint8_t DIRENT_TYPE_DIRECTORY = 4u;

// A dirent representing a block device object.
constexpr uint8_t DIRENT_TYPE_BLOCK_DEVICE = 6u;

// Indicates the device is ready for writing.
constexpr uint32_t DEVICE_SIGNAL_WRITABLE = 67108864u;

// Indicates the device is ready for reading.
constexpr uint32_t DEVICE_SIGNAL_READABLE = 16777216u;

// Indicates an out-of-band state transition has occurred.
constexpr uint32_t DEVICE_SIGNAL_OOB = 33554432u;

// Indicates the device has hung up on the current connection.
constexpr uint32_t DEVICE_SIGNAL_HANGUP = 268435456u;

// Indicates the device has encountered an error state.
constexpr uint32_t DEVICE_SIGNAL_ERROR = 134217728u;

// When used during clone, the new connection inherits the rights on the source connection,
// regardless if it is a file or directory. Otherwise, clone attempts to use the requested rights.
// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with `CLONE_FLAG_SAME_RIGHTS`.
constexpr uint32_t CLONE_FLAG_SAME_RIGHTS = 67108864u;

}  // namespace io
}  // namespace fuchsia
}  // namespace llcpp

namespace fidl {

template <>
struct IsFidlType<::llcpp::fuchsia::io::WatchedEvent> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::WatchedEvent>);
static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, event) == 0);
static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, len) == 1);
static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, name) == 8);
static_assert(sizeof(::llcpp::fuchsia::io::WatchedEvent) == ::llcpp::fuchsia::io::WatchedEvent::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Vmofile> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Vmofile>);
static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, vmo) == 0);
static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, offset) == 8);
static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, length) == 16);
static_assert(sizeof(::llcpp::fuchsia::io::Vmofile) == ::llcpp::fuchsia::io::Vmofile::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Tty> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Tty>);
static_assert(offsetof(::llcpp::fuchsia::io::Tty, event) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::Tty) == ::llcpp::fuchsia::io::Tty::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::StreamSocket> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::StreamSocket>);
static_assert(offsetof(::llcpp::fuchsia::io::StreamSocket, socket) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::StreamSocket) == ::llcpp::fuchsia::io::StreamSocket::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest)
    == ::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest, events) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Socket> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Socket>);
static_assert(offsetof(::llcpp::fuchsia::io::Socket, socket) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::Socket) == ::llcpp::fuchsia::io::Socket::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Service> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Service>);
static_assert(offsetof(::llcpp::fuchsia::io::Service, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::Service) == ::llcpp::fuchsia::io::Service::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Pipe> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Pipe>);
static_assert(offsetof(::llcpp::fuchsia::io::Pipe, socket) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::Pipe) == ::llcpp::fuchsia::io::Pipe::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::NodeAttributes> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::NodeAttributes>);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, mode) == 0);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, id) == 8);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, content_size) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, storage_size) == 24);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, link_count) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, creation_time) == 40);
static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, modification_time) == 48);
static_assert(sizeof(::llcpp::fuchsia::io::NodeAttributes) == ::llcpp::fuchsia::io::NodeAttributes::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::FilesystemInfo> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::FilesystemInfo>);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, total_bytes) == 0);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, used_bytes) == 8);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, total_nodes) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, used_nodes) == 24);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, free_shared_pool_bytes) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, fs_id) == 40);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, block_size) == 48);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, max_filename_size) == 52);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, fs_type) == 56);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, padding) == 60);
static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, name) == 64);
static_assert(sizeof(::llcpp::fuchsia::io::FilesystemInfo) == ::llcpp::fuchsia::io::FilesystemInfo::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::FileObject> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::FileObject>);
static_assert(offsetof(::llcpp::fuchsia::io::FileObject, event) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::FileObject) == ::llcpp::fuchsia::io::FileObject::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryObject> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::DirectoryObject>);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryObject, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryObject) == ::llcpp::fuchsia::io::DirectoryObject::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Device> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Device>);
static_assert(offsetof(::llcpp::fuchsia::io::Device, event) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::Device) == ::llcpp::fuchsia::io::Device::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DatagramSocket> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::DatagramSocket>);
static_assert(offsetof(::llcpp::fuchsia::io::DatagramSocket, event) == 0);
static_assert(sizeof(::llcpp::fuchsia::io::DatagramSocket) == ::llcpp::fuchsia::io::DatagramSocket::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::io::NodeInfo> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::NodeInfo>);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::CloneRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::CloneRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::CloneRequest)
    == ::llcpp::fuchsia::io::Node::CloneRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::CloneRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Node::CloneRequest, object) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::CloseResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::CloseResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::CloseResponse)
    == ::llcpp::fuchsia::io::Node::CloseResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::CloseResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::DescribeResponse)
    == ::llcpp::fuchsia::io::Node::DescribeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::DescribeResponse, info) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::OnOpenResponse)
    == ::llcpp::fuchsia::io::Node::OnOpenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::OnOpenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Node::OnOpenResponse, info) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::SyncResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::SyncResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::SyncResponse)
    == ::llcpp::fuchsia::io::Node::SyncResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::SyncResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::GetAttrResponse)
    == ::llcpp::fuchsia::io::Node::GetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::GetAttrResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Node::GetAttrResponse, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::SetAttrRequest)
    == ::llcpp::fuchsia::io::Node::SetAttrRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrRequest, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::SetAttrResponse)
    == ::llcpp::fuchsia::io::Node::SetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::NodeGetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeGetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse)
    == ::llcpp::fuchsia::io::Node::NodeGetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::NodeSetFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeSetFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeSetFlagsRequest)
    == ::llcpp::fuchsia::io::Node::NodeSetFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeSetFlagsRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Node::NodeSetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeSetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeSetFlagsResponse)
    == ::llcpp::fuchsia::io::Node::NodeSetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeSetFlagsResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::CloneRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::CloneRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::CloneRequest)
    == ::llcpp::fuchsia::io::File::CloneRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::CloneRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::CloneRequest, object) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::CloseResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::CloseResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::CloseResponse)
    == ::llcpp::fuchsia::io::File::CloseResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::CloseResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::DescribeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::DescribeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::DescribeResponse)
    == ::llcpp::fuchsia::io::File::DescribeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::DescribeResponse, info) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::OnOpenResponse)
    == ::llcpp::fuchsia::io::File::OnOpenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::OnOpenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::OnOpenResponse, info) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SyncResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SyncResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SyncResponse)
    == ::llcpp::fuchsia::io::File::SyncResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SyncResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::GetAttrResponse)
    == ::llcpp::fuchsia::io::File::GetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetAttrResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetAttrResponse, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SetAttrRequest)
    == ::llcpp::fuchsia::io::File::SetAttrRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrRequest, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SetAttrResponse)
    == ::llcpp::fuchsia::io::File::SetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::NodeGetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeGetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse)
    == ::llcpp::fuchsia::io::File::NodeGetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::NodeSetFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeSetFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::NodeSetFlagsRequest)
    == ::llcpp::fuchsia::io::File::NodeSetFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::NodeSetFlagsRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::NodeSetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeSetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::NodeSetFlagsResponse)
    == ::llcpp::fuchsia::io::File::NodeSetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::NodeSetFlagsResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::ReadRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::ReadRequest)
    == ::llcpp::fuchsia::io::File::ReadRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadRequest, count) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::ReadResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::ReadResponse)
    == ::llcpp::fuchsia::io::File::ReadResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadResponse, data) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::ReadAtRequest)
    == ::llcpp::fuchsia::io::File::ReadAtRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtRequest, count) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtRequest, offset) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::ReadAtResponse)
    == ::llcpp::fuchsia::io::File::ReadAtResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtResponse, data) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::WriteRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::WriteRequest)
    == ::llcpp::fuchsia::io::File::WriteRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteRequest, data) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::WriteResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::WriteResponse)
    == ::llcpp::fuchsia::io::File::WriteResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteResponse, actual) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::WriteAtRequest)
    == ::llcpp::fuchsia::io::File::WriteAtRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtRequest, data) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtRequest, offset) == 32);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::WriteAtResponse)
    == ::llcpp::fuchsia::io::File::WriteAtResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtResponse, actual) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SeekRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SeekRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SeekRequest)
    == ::llcpp::fuchsia::io::File::SeekRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SeekRequest, offset) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::SeekRequest, start) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SeekResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SeekResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SeekResponse)
    == ::llcpp::fuchsia::io::File::SeekResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SeekResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::SeekResponse, offset) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::TruncateRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::TruncateRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::TruncateRequest)
    == ::llcpp::fuchsia::io::File::TruncateRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::TruncateRequest, length) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::TruncateResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::TruncateResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::TruncateResponse)
    == ::llcpp::fuchsia::io::File::TruncateResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::TruncateResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::GetFlagsResponse)
    == ::llcpp::fuchsia::io::File::GetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetFlagsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SetFlagsRequest)
    == ::llcpp::fuchsia::io::File::SetFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SetFlagsRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::SetFlagsResponse)
    == ::llcpp::fuchsia::io::File::SetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::SetFlagsResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::GetBufferRequest)
    == ::llcpp::fuchsia::io::File::GetBufferRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::File::GetBufferResponse)
    == ::llcpp::fuchsia::io::File::GetBufferResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferResponse, buffer) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::CloneRequest)
    == ::llcpp::fuchsia::io::Directory::CloneRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloneRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloneRequest, object) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::CloseResponse)
    == ::llcpp::fuchsia::io::Directory::CloseResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloseResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::DescribeResponse)
    == ::llcpp::fuchsia::io::Directory::DescribeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::DescribeResponse, info) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::OnOpenResponse)
    == ::llcpp::fuchsia::io::Directory::OnOpenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OnOpenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OnOpenResponse, info) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::SyncResponse)
    == ::llcpp::fuchsia::io::Directory::SyncResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::SyncResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::GetAttrResponse)
    == ::llcpp::fuchsia::io::Directory::GetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetAttrResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetAttrResponse, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::SetAttrRequest)
    == ::llcpp::fuchsia::io::Directory::SetAttrRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrRequest, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::SetAttrResponse)
    == ::llcpp::fuchsia::io::Directory::SetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse)
    == ::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest)
    == ::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse)
    == ::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::OpenRequest)
    == ::llcpp::fuchsia::io::Directory::OpenRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, mode) == 20);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, path) == 24);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, object) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::UnlinkRequest)
    == ::llcpp::fuchsia::io::Directory::UnlinkRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::UnlinkRequest, path) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::UnlinkResponse)
    == ::llcpp::fuchsia::io::Directory::UnlinkResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::UnlinkResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::ReadDirentsRequest)
    == ::llcpp::fuchsia::io::Directory::ReadDirentsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsRequest, max_bytes) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse)
    == ::llcpp::fuchsia::io::Directory::ReadDirentsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse, dirents) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::RewindResponse)
    == ::llcpp::fuchsia::io::Directory::RewindResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::RewindResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::GetTokenResponse)
    == ::llcpp::fuchsia::io::Directory::GetTokenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetTokenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetTokenResponse, token) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::RenameRequest)
    == ::llcpp::fuchsia::io::Directory::RenameRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, src) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, dst_parent_token) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, dst) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::RenameResponse)
    == ::llcpp::fuchsia::io::Directory::RenameResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::LinkRequest)
    == ::llcpp::fuchsia::io::Directory::LinkRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, src) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, dst_parent_token) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, dst) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::LinkResponse)
    == ::llcpp::fuchsia::io::Directory::LinkResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::WatchRequest)
    == ::llcpp::fuchsia::io::Directory::WatchRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, mask) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, options) == 20);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, watcher) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::Directory::WatchResponse)
    == ::llcpp::fuchsia::io::Directory::WatchResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest, object) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse, info) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse, info) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest, attributes) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest, flags) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, mode) == 20);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, path) == 24);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, object) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest, path) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest, max_bytes) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, dirents) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse, token) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, src) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, dst_parent_token) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, dst) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, src) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, dst_parent_token) == 32);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, dst) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, mask) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, options) == 20);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, watcher) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::MountRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountRequest, remote) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::MountResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest)
    == ::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, remote) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, name) == 24);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, flags) == 40);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse, s) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, remote) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, info) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse)
    == ::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, s) == 16);
static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, path) == 24);

}  // namespace fidl