diff --git a/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0aea8bb96da8178e361ba0174901fde909873471
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc
@@ -0,0 +1,7922 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/io/llcpp/fidl.h>
+#include <memory>
+
+namespace fuchsia {
+namespace io {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kDirectoryWatcher_OnEvent_Ordinal = 546032797u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryWatcherOnEventRequestTable;
+
+}  // namespace
+
+zx_status_t DirectoryWatcher::SyncClient::OnEvent(::fidl::VectorView<uint8_t> events) {
+  return DirectoryWatcher::Call::OnEvent(zx::unowned_channel(this->channel_), std::move(events));
+}
+
+zx_status_t DirectoryWatcher::Call::OnEvent(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnEventRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  OnEventRequest _request = {};
+  _request._hdr.ordinal = kDirectoryWatcher_OnEvent_Ordinal;
+  _request.events = std::move(events);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OnEventRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryWatcher::SyncClient::OnEvent(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events) {
+  return DirectoryWatcher::Call::OnEvent(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(events));
+}
+
+zx_status_t DirectoryWatcher::Call::OnEvent(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events) {
+  if (_request_buffer.capacity() < OnEventRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OnEventRequest _request = {};
+  _request._hdr.ordinal = kDirectoryWatcher_OnEvent_Ordinal;
+  _request.events = std::move(events);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OnEventRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryWatcher::SyncClient::OnEvent(::fidl::DecodedMessage<OnEventRequest> params) {
+  return DirectoryWatcher::Call::OnEvent(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t DirectoryWatcher::Call::OnEvent(zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnEventRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryWatcher_OnEvent_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+bool DirectoryWatcher::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_INVALID_ARGS);
+    return true;
+  }
+  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+  switch (hdr->ordinal) {
+    case kDirectoryWatcher_OnEvent_Ordinal: {
+      auto result = ::fidl::DecodeAs<OnEventRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->OnEvent(std::move(message->events),
+        Interface::OnEventCompleter::Sync(txn));
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool DirectoryWatcher::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  bool found = TryDispatch(impl, msg, txn);
+  if (!found) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_NOT_SUPPORTED);
+  }
+  return found;
+}
+
+
+::fuchsia::io::NodeInfo::NodeInfo() {
+  memset(this, 0, sizeof(NodeInfo));
+  tag_ = Tag::Invalid;
+}
+
+::fuchsia::io::NodeInfo::~NodeInfo() {
+  Destroy();
+}
+
+void ::fuchsia::io::NodeInfo::Destroy() {
+  switch (which()) {
+  case Tag::kService:
+    service_.~Service();
+    break;
+  case Tag::kFile:
+    file_.~FileObject();
+    break;
+  case Tag::kDirectory:
+    directory_.~DirectoryObject();
+    break;
+  case Tag::kPipe:
+    pipe_.~Pipe();
+    break;
+  case Tag::kVmofile:
+    vmofile_.~Vmofile();
+    break;
+  case Tag::kDevice:
+    device_.~Device();
+    break;
+  case Tag::kTty:
+    tty_.~Tty();
+    break;
+  default:
+    break;
+  }
+}
+
+void ::fuchsia::io::NodeInfo::MoveImpl_(NodeInfo&& other) {
+  switch (other.which()) {
+  case Tag::kService:
+    mutable_service() = std::move(other.mutable_service());
+    break;
+  case Tag::kFile:
+    mutable_file() = std::move(other.mutable_file());
+    break;
+  case Tag::kDirectory:
+    mutable_directory() = std::move(other.mutable_directory());
+    break;
+  case Tag::kPipe:
+    mutable_pipe() = std::move(other.mutable_pipe());
+    break;
+  case Tag::kVmofile:
+    mutable_vmofile() = std::move(other.mutable_vmofile());
+    break;
+  case Tag::kDevice:
+    mutable_device() = std::move(other.mutable_device());
+    break;
+  case Tag::kTty:
+    mutable_tty() = std::move(other.mutable_tty());
+    break;
+  default:
+    break;
+  }
+  other.tag_ = Tag::Invalid;
+}
+
+void ::fuchsia::io::NodeInfo::SizeAndOffsetAssertionHelper() {
+  static_assert(offsetof(::fuchsia::io::NodeInfo, service_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, file_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, directory_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, pipe_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, vmofile_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, device_) == 8);
+  static_assert(offsetof(::fuchsia::io::NodeInfo, tty_) == 8);
+  static_assert(sizeof(::fuchsia::io::NodeInfo) == ::fuchsia::io::NodeInfo::PrimarySize);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kNode_Clone_Ordinal = 402549324u;
+extern "C" const fidl_type_t fuchsia_io_NodeCloneRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kNode_Close_Ordinal = 1387878023u;
+[[maybe_unused]]
+constexpr uint32_t kNode_Describe_Ordinal = 526573406u;
+extern "C" const fidl_type_t fuchsia_io_NodeDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kNode_OnOpen_Ordinal = 1191225277u;
+extern "C" const fidl_type_t fuchsia_io_NodeOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint32_t kNode_Sync_Ordinal = 1648508842u;
+[[maybe_unused]]
+constexpr uint32_t kNode_GetAttr_Ordinal = 1166403528u;
+[[maybe_unused]]
+constexpr uint32_t kNode_SetAttr_Ordinal = 198530458u;
+[[maybe_unused]]
+constexpr uint32_t kNode_Ioctl_Ordinal = 905161895u;
+extern "C" const fidl_type_t fuchsia_io_NodeIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_NodeIoctlResponseTable;
+
+}  // namespace
+
+zx_status_t Node::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+  return Node::Call::Clone(zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+zx_status_t Node::Call::Clone(zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Node::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  return Node::Call::Clone(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+zx_status_t Node::Call::Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  _request_buffer.set_actual(sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Node::SyncClient::Clone(::fidl::DecodedMessage<CloneRequest> params) {
+  return Node::Call::Clone(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t Node::Call::Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Clone_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t Node::SyncClient::Close(int32_t* out_s) {
+  return Node::Call::Close(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t Node::Call::Close(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloseRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_Close_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Node::SyncClient::Close(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Node::Call::Close(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Node::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<CloseRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_Close_Ordinal;
+  _request_buffer.set_actual(sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::CloseResponse> Node::SyncClient::Close(::fidl::BytePart response_buffer) {
+  return Node::Call::Close(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::CloseResponse> Node::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Close_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::CloseResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::CloseResponse>());
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::CloseResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::CloseResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Node::SyncClient::Describe(NodeInfo* out_info) {
+  return Node::Call::Describe(zx::unowned_channel(this->channel_), out_info);
+}
+
+zx_status_t Node::Call::Describe(zx::unowned_channel _client_end, NodeInfo* out_info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_Describe_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+zx_status_t Node::SyncClient::Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  return Node::Call::Describe(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_info);
+}
+
+zx_status_t Node::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_Describe_Ordinal;
+  _request_buffer.set_actual(sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::DescribeResponse> Node::SyncClient::Describe(::fidl::BytePart response_buffer) {
+  return Node::Call::Describe(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::DescribeResponse> Node::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Describe_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::DescribeResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::DescribeResponse>());
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::DescribeResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::DescribeResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Node::SyncClient::Sync(int32_t* out_s) {
+  return Node::Call::Sync(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t Node::Call::Sync(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SyncRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_Sync_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Node::SyncClient::Sync(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Node::Call::Sync(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Node::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<SyncRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_Sync_Ordinal;
+  _request_buffer.set_actual(sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::SyncResponse> Node::SyncClient::Sync(::fidl::BytePart response_buffer) {
+  return Node::Call::Sync(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::SyncResponse> Node::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Sync_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::SyncResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::SyncResponse>());
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::SyncResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::SyncResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Node::SyncClient::GetAttr(int32_t* out_s, NodeAttributes* out_attributes) {
+  return Node::Call::GetAttr(zx::unowned_channel(this->channel_), out_s, out_attributes);
+}
+
+zx_status_t Node::Call::GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_GetAttr_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+zx_status_t Node::SyncClient::GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  return Node::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_attributes);
+}
+
+zx_status_t Node::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_GetAttr_Ordinal;
+  _request_buffer.set_actual(sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::GetAttrResponse> Node::SyncClient::GetAttr(::fidl::BytePart response_buffer) {
+  return Node::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::GetAttrResponse> Node::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_GetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::GetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::GetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::GetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::GetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Node::SyncClient::SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  return Node::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes), out_s);
+}
+
+zx_status_t Node::Call::SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kNode_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Node::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Node::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Node::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kNode_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  _request_buffer.set_actual(sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::SetAttrResponse> Node::SyncClient::SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  return Node::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::SetAttrResponse> Node::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_SetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::SetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::SetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::SetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::SetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Node::SyncClient::Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  return Node::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(opcode), std::move(max_out), std::move(handles), std::move(in), std::move(_response_buffer), out_s, out_handles, out_out);
+}
+
+zx_status_t Node::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  if (_request_buffer.capacity() < IoctlRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  IoctlRequest _request = {};
+  _request._hdr.ordinal = kNode_Ioctl_Ordinal;
+  _request.opcode = std::move(opcode);
+  _request.max_out = std::move(max_out);
+  _request.handles = std::move(handles);
+  _request.in = std::move(in);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<IoctlRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_handles = std::move(_response.handles);
+  *out_out = std::move(_response.out);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Node::IoctlResponse> Node::SyncClient::Ioctl(::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  return Node::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Node::IoctlResponse> Node::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Ioctl_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::IoctlResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Node::IoctlResponse>());
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Node::IoctlResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Node::IoctlResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Node::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_INVALID_ARGS);
+    return true;
+  }
+  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+  switch (hdr->ordinal) {
+    case kNode_Clone_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Clone(std::move(message->flags), std::move(message->object),
+        Interface::CloneCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_Close_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Close(
+        Interface::CloseCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_Describe_Ordinal: {
+      auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Describe(
+        Interface::DescribeCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_Sync_Ordinal: {
+      auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Sync(
+        Interface::SyncCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_GetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetAttr(
+        Interface::GetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_SetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+        Interface::SetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kNode_Ioctl_Ordinal: {
+      auto result = ::fidl::DecodeAs<IoctlRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Ioctl(std::move(message->opcode), std::move(message->max_out), std::move(message->handles), std::move(message->in),
+        Interface::IoctlCompleter::Sync(txn));
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool Node::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  bool found = TryDispatch(impl, msg, txn);
+  if (!found) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_NOT_SUPPORTED);
+  }
+  return found;
+}
+
+
+void Node::Interface::CloseCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+  _response._hdr.ordinal = kNode_Close_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < CloseResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+  _response._hdr.ordinal = kNode_Close_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Close_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::DescribeCompleterBase::Reply(NodeInfo info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_write_bytes);
+  _response._hdr.ordinal = kNode_Describe_Ordinal;
+  _response.info = std::move(info);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, NodeInfo info) {
+  if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_buffer.data());
+  _response._hdr.ordinal = kNode_Describe_Ordinal;
+  _response.info = std::move(info);
+  _buffer.set_actual(sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Describe_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, NodeInfo* info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kNode_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, NodeInfo* info) {
+  if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kNode_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+	return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_OnOpen_Ordinal;
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Node::Interface::SyncCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+  _response._hdr.ordinal = kNode_Sync_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SyncResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+  _response._hdr.ordinal = kNode_Sync_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Sync_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::GetAttrCompleterBase::Reply(int32_t s, NodeAttributes attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kNode_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, NodeAttributes attributes) {
+  if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kNode_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  _buffer.set_actual(sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_GetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kNode_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kNode_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_SetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::IoctlCompleterBase::Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IoctlResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kNode_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::IoctlCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  if (_buffer.capacity() < IoctlResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kNode_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::IoctlCompleterBase::Reply(::fidl::DecodedMessage<IoctlResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kNode_Ioctl_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kFile_Clone_Ordinal = 402549324u;
+extern "C" const fidl_type_t fuchsia_io_FileCloneRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_Close_Ordinal = 1387878023u;
+[[maybe_unused]]
+constexpr uint32_t kFile_Describe_Ordinal = 526573406u;
+extern "C" const fidl_type_t fuchsia_io_FileDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_OnOpen_Ordinal = 1191225277u;
+extern "C" const fidl_type_t fuchsia_io_FileOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_Sync_Ordinal = 1648508842u;
+[[maybe_unused]]
+constexpr uint32_t kFile_GetAttr_Ordinal = 1166403528u;
+[[maybe_unused]]
+constexpr uint32_t kFile_SetAttr_Ordinal = 198530458u;
+[[maybe_unused]]
+constexpr uint32_t kFile_Ioctl_Ordinal = 905161895u;
+extern "C" const fidl_type_t fuchsia_io_FileIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_FileIoctlResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_Read_Ordinal = 636961156u;
+extern "C" const fidl_type_t fuchsia_io_FileReadResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_ReadAt_Ordinal = 2087865796u;
+extern "C" const fidl_type_t fuchsia_io_FileReadAtResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_Write_Ordinal = 85125024u;
+extern "C" const fidl_type_t fuchsia_io_FileWriteRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_WriteAt_Ordinal = 1045766885u;
+extern "C" const fidl_type_t fuchsia_io_FileWriteAtRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kFile_Seek_Ordinal = 2016048965u;
+[[maybe_unused]]
+constexpr uint32_t kFile_Truncate_Ordinal = 1118517818u;
+[[maybe_unused]]
+constexpr uint32_t kFile_GetFlags_Ordinal = 1679205366u;
+[[maybe_unused]]
+constexpr uint32_t kFile_SetFlags_Ordinal = 1059310710u;
+[[maybe_unused]]
+constexpr uint32_t kFile_GetBuffer_Ordinal = 1958938995u;
+extern "C" const fidl_type_t fuchsia_io_FileGetBufferResponseTable;
+
+}  // namespace
+
+zx_status_t File::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+  return File::Call::Clone(zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+zx_status_t File::Call::Clone(zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t File::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  return File::Call::Clone(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+zx_status_t File::Call::Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  _request_buffer.set_actual(sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t File::SyncClient::Clone(::fidl::DecodedMessage<CloneRequest> params) {
+  return File::Call::Clone(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t File::Call::Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Clone_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t File::SyncClient::Close(int32_t* out_s) {
+  return File::Call::Close(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t File::Call::Close(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloseRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Close_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Close(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return File::Call::Close(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t File::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<CloseRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Close_Ordinal;
+  _request_buffer.set_actual(sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::CloseResponse> File::SyncClient::Close(::fidl::BytePart response_buffer) {
+  return File::Call::Close(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::CloseResponse> File::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Close_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::CloseResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::CloseResponse>());
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::CloseResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::CloseResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Describe(NodeInfo* out_info) {
+  return File::Call::Describe(zx::unowned_channel(this->channel_), out_info);
+}
+
+zx_status_t File::Call::Describe(zx::unowned_channel _client_end, NodeInfo* out_info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Describe_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  return File::Call::Describe(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_info);
+}
+
+zx_status_t File::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Describe_Ordinal;
+  _request_buffer.set_actual(sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::DescribeResponse> File::SyncClient::Describe(::fidl::BytePart response_buffer) {
+  return File::Call::Describe(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::DescribeResponse> File::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Describe_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::DescribeResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::DescribeResponse>());
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::DescribeResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::DescribeResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Sync(int32_t* out_s) {
+  return File::Call::Sync(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t File::Call::Sync(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SyncRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Sync_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Sync(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return File::Call::Sync(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t File::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<SyncRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Sync_Ordinal;
+  _request_buffer.set_actual(sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::SyncResponse> File::SyncClient::Sync(::fidl::BytePart response_buffer) {
+  return File::Call::Sync(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::SyncResponse> File::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Sync_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SyncResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::SyncResponse>());
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SyncResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::SyncResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::GetAttr(int32_t* out_s, NodeAttributes* out_attributes) {
+  return File::Call::GetAttr(zx::unowned_channel(this->channel_), out_s, out_attributes);
+}
+
+zx_status_t File::Call::GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_GetAttr_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  return File::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_attributes);
+}
+
+zx_status_t File::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_GetAttr_Ordinal;
+  _request_buffer.set_actual(sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::GetAttrResponse> File::SyncClient::GetAttr(::fidl::BytePart response_buffer) {
+  return File::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::GetAttrResponse> File::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::GetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::GetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  return File::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes), out_s);
+}
+
+zx_status_t File::Call::SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return File::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer), out_s);
+}
+
+zx_status_t File::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  _request_buffer.set_actual(sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::SetAttrResponse> File::SyncClient::SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::SetAttrResponse> File::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_SetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::SetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::SetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  return File::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(opcode), std::move(max_out), std::move(handles), std::move(in), std::move(_response_buffer), out_s, out_handles, out_out);
+}
+
+zx_status_t File::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  if (_request_buffer.capacity() < IoctlRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  IoctlRequest _request = {};
+  _request._hdr.ordinal = kFile_Ioctl_Ordinal;
+  _request.opcode = std::move(opcode);
+  _request.max_out = std::move(max_out);
+  _request.handles = std::move(handles);
+  _request.in = std::move(in);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<IoctlRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_handles = std::move(_response.handles);
+  *out_out = std::move(_response.out);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::IoctlResponse> File::SyncClient::Ioctl(::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::IoctlResponse> File::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Ioctl_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::IoctlResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::IoctlResponse>());
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::IoctlResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::IoctlResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data) {
+  return File::Call::Read(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(_response_buffer), out_s, out_data);
+}
+
+zx_status_t File::Call::Read(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data) {
+  if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Read_Ordinal;
+  _request.count = std::move(count);
+  _request_buffer.set_actual(sizeof(ReadRequest));
+  ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_data = std::move(_response.data);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::ReadResponse> File::SyncClient::Read(::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::Read(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadResponse> File::Call::Read(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Read_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::ReadResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::ReadResponse>());
+  }
+  auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::ReadResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::ReadResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data) {
+  return File::Call::ReadAt(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer), out_s, out_data);
+}
+
+zx_status_t File::Call::ReadAt(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data) {
+  if (_request_buffer.capacity() < ReadAtRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<ReadAtRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_ReadAt_Ordinal;
+  _request.count = std::move(count);
+  _request.offset = std::move(offset);
+  _request_buffer.set_actual(sizeof(ReadAtRequest));
+  ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<ReadAtRequest, ReadAtResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_data = std::move(_response.data);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::ReadAtResponse> File::SyncClient::ReadAt(::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::ReadAt(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadAtResponse> File::Call::ReadAt(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_ReadAt_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::ReadAtResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::ReadAtResponse>());
+  }
+  auto _call_result = ::fidl::Call<ReadAtRequest, ReadAtResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::ReadAtResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::ReadAtResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Write(::fidl::VectorView<uint8_t> data, int32_t* out_s, uint64_t* out_actual) {
+  return File::Call::Write(zx::unowned_channel(this->channel_), std::move(data), out_s, out_actual);
+}
+
+zx_status_t File::Call::Write(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, int32_t* out_s, uint64_t* out_actual) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  WriteRequest _request = {};
+  _request._hdr.ordinal = kFile_Write_Ordinal;
+  _request.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_actual = std::move(_response.actual);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual) {
+  return File::Call::Write(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer), out_s, out_actual);
+}
+
+zx_status_t File::Call::Write(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual) {
+  if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  WriteRequest _request = {};
+  _request._hdr.ordinal = kFile_Write_Ordinal;
+  _request.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_actual = std::move(_response.actual);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::WriteResponse> File::SyncClient::Write(::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::Write(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteResponse> File::Call::Write(zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Write_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::WriteResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::WriteResponse>());
+  }
+  auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::WriteResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::WriteResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, int32_t* out_s, uint64_t* out_actual) {
+  return File::Call::WriteAt(zx::unowned_channel(this->channel_), std::move(data), std::move(offset), out_s, out_actual);
+}
+
+zx_status_t File::Call::WriteAt(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset, int32_t* out_s, uint64_t* out_actual) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  WriteAtRequest _request = {};
+  _request._hdr.ordinal = kFile_WriteAt_Ordinal;
+  _request.data = std::move(data);
+  _request.offset = std::move(offset);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_actual = std::move(_response.actual);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual) {
+  return File::Call::WriteAt(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer), out_s, out_actual);
+}
+
+zx_status_t File::Call::WriteAt(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual) {
+  if (_request_buffer.capacity() < WriteAtRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  WriteAtRequest _request = {};
+  _request._hdr.ordinal = kFile_WriteAt_Ordinal;
+  _request.data = std::move(data);
+  _request.offset = std::move(offset);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_actual = std::move(_response.actual);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::WriteAtResponse> File::SyncClient::WriteAt(::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::WriteAt(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteAtResponse> File::Call::WriteAt(zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_WriteAt_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::WriteAtResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::WriteAtResponse>());
+  }
+  auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::WriteAtResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::WriteAtResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Seek(int64_t offset, SeekOrigin start, int32_t* out_s, uint64_t* out_offset) {
+  return File::Call::Seek(zx::unowned_channel(this->channel_), std::move(offset), std::move(start), out_s, out_offset);
+}
+
+zx_status_t File::Call::Seek(zx::unowned_channel _client_end, int64_t offset, SeekOrigin start, int32_t* out_s, uint64_t* out_offset) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SeekRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Seek_Ordinal;
+  _request.offset = std::move(offset);
+  _request.start = std::move(start);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekRequest));
+  ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SeekResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_offset = std::move(_response.offset);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Seek(::fidl::BytePart _request_buffer, int64_t offset, SeekOrigin start, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_offset) {
+  return File::Call::Seek(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer), out_s, out_offset);
+}
+
+zx_status_t File::Call::Seek(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, SeekOrigin start, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_offset) {
+  if (_request_buffer.capacity() < SeekRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SeekRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Seek_Ordinal;
+  _request.offset = std::move(offset);
+  _request.start = std::move(start);
+  _request_buffer.set_actual(sizeof(SeekRequest));
+  ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_offset = std::move(_response.offset);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::SeekResponse> File::SyncClient::Seek(::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::Seek(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::SeekResponse> File::Call::Seek(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Seek_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SeekResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::SeekResponse>());
+  }
+  auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SeekResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::SeekResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::Truncate(uint64_t length, int32_t* out_s) {
+  return File::Call::Truncate(zx::unowned_channel(this->channel_), std::move(length), out_s);
+}
+
+zx_status_t File::Call::Truncate(zx::unowned_channel _client_end, uint64_t length, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<TruncateRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_Truncate_Ordinal;
+  _request.length = std::move(length);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateRequest));
+  ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<TruncateResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<TruncateRequest, TruncateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return File::Call::Truncate(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(length), std::move(_response_buffer), out_s);
+}
+
+zx_status_t File::Call::Truncate(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < TruncateRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<TruncateRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_Truncate_Ordinal;
+  _request.length = std::move(length);
+  _request_buffer.set_actual(sizeof(TruncateRequest));
+  ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<TruncateRequest, TruncateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::TruncateResponse> File::SyncClient::Truncate(::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::Truncate(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::TruncateResponse> File::Call::Truncate(zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Truncate_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::TruncateResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::TruncateResponse>());
+  }
+  auto _call_result = ::fidl::Call<TruncateRequest, TruncateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::TruncateResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::TruncateResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::GetFlags(int32_t* out_s, uint32_t* out_flags) {
+  return File::Call::GetFlags(zx::unowned_channel(this->channel_), out_s, out_flags);
+}
+
+zx_status_t File::Call::GetFlags(zx::unowned_channel _client_end, int32_t* out_s, uint32_t* out_flags) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetFlagsRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_GetFlags_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsRequest));
+  ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetFlagsRequest, GetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_flags = std::move(_response.flags);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::GetFlags(::fidl::BytePart _response_buffer, int32_t* out_s, uint32_t* out_flags) {
+  return File::Call::GetFlags(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_flags);
+}
+
+zx_status_t File::Call::GetFlags(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, uint32_t* out_flags) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFlagsRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetFlagsRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_GetFlags_Ordinal;
+  _request_buffer.set_actual(sizeof(GetFlagsRequest));
+  ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetFlagsRequest, GetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_flags = std::move(_response.flags);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::GetFlagsResponse> File::SyncClient::GetFlags(::fidl::BytePart response_buffer) {
+  return File::Call::GetFlags(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::GetFlagsResponse> File::Call::GetFlags(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFlagsRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetFlagsRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetFlagsRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetFlags_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetFlagsResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::GetFlagsResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetFlagsRequest, GetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetFlagsResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::GetFlagsResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::SetFlags(uint32_t flags, int32_t* out_s) {
+  return File::Call::SetFlags(zx::unowned_channel(this->channel_), std::move(flags), out_s);
+}
+
+zx_status_t File::Call::SetFlags(zx::unowned_channel _client_end, uint32_t flags, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SetFlagsRequest*>(_write_bytes);
+  _request._hdr.ordinal = kFile_SetFlags_Ordinal;
+  _request.flags = std::move(flags);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsRequest));
+  ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SetFlagsRequest, SetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t File::SyncClient::SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return File::Call::SetFlags(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer), out_s);
+}
+
+zx_status_t File::Call::SetFlags(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < SetFlagsRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SetFlagsRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_SetFlags_Ordinal;
+  _request.flags = std::move(flags);
+  _request_buffer.set_actual(sizeof(SetFlagsRequest));
+  ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SetFlagsRequest, SetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::SetFlagsResponse> File::SyncClient::SetFlags(::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::SetFlags(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::SetFlagsResponse> File::Call::SetFlags(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_SetFlags_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SetFlagsResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::SetFlagsResponse>());
+  }
+  auto _call_result = ::fidl::Call<SetFlagsRequest, SetFlagsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::SetFlagsResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::SetFlagsResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t File::SyncClient::GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fuchsia::mem::Buffer** out_buffer) {
+  return File::Call::GetBuffer(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer), out_s, out_buffer);
+}
+
+zx_status_t File::Call::GetBuffer(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fuchsia::mem::Buffer** out_buffer) {
+  if (_request_buffer.capacity() < GetBufferRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<GetBufferRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kFile_GetBuffer_Ordinal;
+  _request.flags = std::move(flags);
+  _request_buffer.set_actual(sizeof(GetBufferRequest));
+  ::fidl::DecodedMessage<GetBufferRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetBufferRequest, GetBufferResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_buffer = std::move(_response.buffer);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<File::GetBufferResponse> File::SyncClient::GetBuffer(::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer) {
+  return File::Call::GetBuffer(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<File::GetBufferResponse> File::Call::GetBuffer(zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetBuffer_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetBufferResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<File::GetBufferResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetBufferRequest, GetBufferResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<File::GetBufferResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<File::GetBufferResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool File::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_INVALID_ARGS);
+    return true;
+  }
+  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+  switch (hdr->ordinal) {
+    case kFile_Clone_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Clone(std::move(message->flags), std::move(message->object),
+        Interface::CloneCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Close_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Close(
+        Interface::CloseCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Describe_Ordinal: {
+      auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Describe(
+        Interface::DescribeCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Sync_Ordinal: {
+      auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Sync(
+        Interface::SyncCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_GetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetAttr(
+        Interface::GetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_SetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+        Interface::SetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Ioctl_Ordinal: {
+      auto result = ::fidl::DecodeAs<IoctlRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Ioctl(std::move(message->opcode), std::move(message->max_out), std::move(message->handles), std::move(message->in),
+        Interface::IoctlCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Read_Ordinal: {
+      auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Read(std::move(message->count),
+        Interface::ReadCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_ReadAt_Ordinal: {
+      auto result = ::fidl::DecodeAs<ReadAtRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->ReadAt(std::move(message->count), std::move(message->offset),
+        Interface::ReadAtCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Write_Ordinal: {
+      auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Write(std::move(message->data),
+        Interface::WriteCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_WriteAt_Ordinal: {
+      auto result = ::fidl::DecodeAs<WriteAtRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->WriteAt(std::move(message->data), std::move(message->offset),
+        Interface::WriteAtCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Seek_Ordinal: {
+      auto result = ::fidl::DecodeAs<SeekRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Seek(std::move(message->offset), std::move(message->start),
+        Interface::SeekCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_Truncate_Ordinal: {
+      auto result = ::fidl::DecodeAs<TruncateRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Truncate(std::move(message->length),
+        Interface::TruncateCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_GetFlags_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetFlagsRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetFlags(
+        Interface::GetFlagsCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_SetFlags_Ordinal: {
+      auto result = ::fidl::DecodeAs<SetFlagsRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->SetFlags(std::move(message->flags),
+        Interface::SetFlagsCompleter::Sync(txn));
+      return true;
+    }
+    case kFile_GetBuffer_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetBufferRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->GetBuffer(std::move(message->flags),
+        Interface::GetBufferCompleter::Sync(txn));
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool File::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  bool found = TryDispatch(impl, msg, txn);
+  if (!found) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_NOT_SUPPORTED);
+  }
+  return found;
+}
+
+
+void File::Interface::CloseCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Close_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < CloseResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Close_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void File::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Close_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::DescribeCompleterBase::Reply(NodeInfo info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Describe_Ordinal;
+  _response.info = std::move(info);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, NodeInfo info) {
+  if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Describe_Ordinal;
+  _response.info = std::move(info);
+  _buffer.set_actual(sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_buffer)));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Describe_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, NodeInfo* info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kFile_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, NodeInfo* info) {
+  if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kFile_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+	return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_OnOpen_Ordinal;
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void File::Interface::SyncCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Sync_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SyncResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Sync_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Sync_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetAttrCompleterBase::Reply(int32_t s, NodeAttributes attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, NodeAttributes attributes) {
+  if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  _buffer.set_actual(sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void File::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_SetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::IoctlCompleterBase::Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IoctlResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kFile_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::IoctlCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  if (_buffer.capacity() < IoctlResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kFile_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::IoctlCompleterBase::Reply(::fidl::DecodedMessage<IoctlResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Ioctl_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  ReadResponse _response = {};
+  _response._hdr.ordinal = kFile_Read_Ordinal;
+  _response.s = std::move(s);
+  _response.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+  if (_buffer.capacity() < ReadResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  ReadResponse _response = {};
+  _response._hdr.ordinal = kFile_Read_Ordinal;
+  _response.s = std::move(s);
+  _response.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Read_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadAtCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  ReadAtResponse _response = {};
+  _response._hdr.ordinal = kFile_ReadAt_Ordinal;
+  _response.s = std::move(s);
+  _response.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+  if (_buffer.capacity() < ReadAtResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  ReadAtResponse _response = {};
+  _response._hdr.ordinal = kFile_ReadAt_Ordinal;
+  _response.s = std::move(s);
+  _response.data = std::move(data);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::DecodedMessage<ReadAtResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_ReadAt_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteCompleterBase::Reply(int32_t s, uint64_t actual) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<WriteResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Write_Ordinal;
+  _response.s = std::move(s);
+  _response.actual = std::move(actual);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+  if (_buffer.capacity() < WriteResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<WriteResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Write_Ordinal;
+  _response.s = std::move(s);
+  _response.actual = std::move(actual);
+  _buffer.set_actual(sizeof(WriteResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_buffer)));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Write_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteAtCompleterBase::Reply(int32_t s, uint64_t actual) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<WriteAtResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_WriteAt_Ordinal;
+  _response.s = std::move(s);
+  _response.actual = std::move(actual);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAtResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+  if (_buffer.capacity() < WriteAtResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<WriteAtResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_WriteAt_Ordinal;
+  _response.s = std::move(s);
+  _response.actual = std::move(actual);
+  _buffer.set_actual(sizeof(WriteAtResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_buffer)));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::DecodedMessage<WriteAtResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_WriteAt_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SeekCompleterBase::Reply(int32_t s, uint64_t offset) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SeekResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Seek_Ordinal;
+  _response.s = std::move(s);
+  _response.offset = std::move(offset);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset) {
+  if (_buffer.capacity() < SeekResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SeekResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Seek_Ordinal;
+  _response.s = std::move(s);
+  _response.offset = std::move(offset);
+  _buffer.set_actual(sizeof(SeekResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::DecodedMessage<SeekResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Seek_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::TruncateCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<TruncateResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_Truncate_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::TruncateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < TruncateResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<TruncateResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_Truncate_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(TruncateResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_buffer)));
+}
+
+void File::Interface::TruncateCompleterBase::Reply(::fidl::DecodedMessage<TruncateResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_Truncate_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetFlagsResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_GetFlags_Ordinal;
+  _response.s = std::move(s);
+  _response.flags = std::move(flags);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::GetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+  if (_buffer.capacity() < GetFlagsResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetFlagsResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_GetFlags_Ordinal;
+  _response.s = std::move(s);
+  _response.flags = std::move(flags);
+  _buffer.set_actual(sizeof(GetFlagsResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::GetFlagsCompleterBase::Reply(::fidl::DecodedMessage<GetFlagsResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetFlags_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SetFlagsCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SetFlagsResponse*>(_write_bytes);
+  _response._hdr.ordinal = kFile_SetFlags_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SetFlagsResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SetFlagsResponse*>(_buffer.data());
+  _response._hdr.ordinal = kFile_SetFlags_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SetFlagsResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SetFlagsCompleterBase::Reply(::fidl::DecodedMessage<SetFlagsResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_SetFlags_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetBufferCompleterBase::Reply(int32_t s, ::fuchsia::mem::Buffer* buffer) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  GetBufferResponse _response = {};
+  _response._hdr.ordinal = kFile_GetBuffer_Ordinal;
+  _response.s = std::move(s);
+  _response.buffer = std::move(buffer);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::GetBufferCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fuchsia::mem::Buffer* buffer) {
+  if (_buffer.capacity() < GetBufferResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  GetBufferResponse _response = {};
+  _response._hdr.ordinal = kFile_GetBuffer_Ordinal;
+  _response.s = std::move(s);
+  _response.buffer = std::move(buffer);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::GetBufferCompleterBase::Reply(::fidl::DecodedMessage<GetBufferResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kFile_GetBuffer_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Clone_Ordinal = 402549324u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryCloneRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Close_Ordinal = 1387878023u;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Describe_Ordinal = 526573406u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_OnOpen_Ordinal = 1191225277u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Sync_Ordinal = 1648508842u;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_GetAttr_Ordinal = 1166403528u;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_SetAttr_Ordinal = 198530458u;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Ioctl_Ordinal = 905161895u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryIoctlResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Open_Ordinal = 2011483371u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryOpenRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Unlink_Ordinal = 750443289u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryUnlinkRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_ReadDirents_Ordinal = 782580781u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryReadDirentsResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Rewind_Ordinal = 1886584199u;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_GetToken_Ordinal = 840416493u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Rename_Ordinal = 1251258540u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryRenameRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Link_Ordinal = 462052964u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryLinkRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectory_Watch_Ordinal = 1522700084u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryWatchRequestTable;
+
+}  // namespace
+
+zx_status_t Directory::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+  return Directory::Call::Clone(zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+zx_status_t Directory::Call::Clone(zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Directory::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  return Directory::Call::Clone(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+zx_status_t Directory::Call::Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  _request_buffer.set_actual(sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Directory::SyncClient::Clone(::fidl::DecodedMessage<CloneRequest> params) {
+  return Directory::Call::Clone(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t Directory::Call::Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Clone_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Close(int32_t* out_s) {
+  return Directory::Call::Close(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t Directory::Call::Close(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloseRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Close_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Close(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Close(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<CloseRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Close_Ordinal;
+  _request_buffer.set_actual(sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::CloseResponse> Directory::SyncClient::Close(::fidl::BytePart response_buffer) {
+  return Directory::Call::Close(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::CloseResponse> Directory::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Close_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::CloseResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::CloseResponse>());
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::CloseResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::CloseResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Describe(NodeInfo* out_info) {
+  return Directory::Call::Describe(zx::unowned_channel(this->channel_), out_info);
+}
+
+zx_status_t Directory::Call::Describe(zx::unowned_channel _client_end, NodeInfo* out_info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Describe_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  return Directory::Call::Describe(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_info);
+}
+
+zx_status_t Directory::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Describe_Ordinal;
+  _request_buffer.set_actual(sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::DescribeResponse> Directory::SyncClient::Describe(::fidl::BytePart response_buffer) {
+  return Directory::Call::Describe(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::DescribeResponse> Directory::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Describe_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::DescribeResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::DescribeResponse>());
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::DescribeResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::DescribeResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Sync(int32_t* out_s) {
+  return Directory::Call::Sync(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t Directory::Call::Sync(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SyncRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Sync_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Sync(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Sync(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<SyncRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Sync_Ordinal;
+  _request_buffer.set_actual(sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::SyncResponse> Directory::SyncClient::Sync(::fidl::BytePart response_buffer) {
+  return Directory::Call::Sync(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::SyncResponse> Directory::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Sync_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::SyncResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::SyncResponse>());
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::SyncResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::SyncResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::GetAttr(int32_t* out_s, NodeAttributes* out_attributes) {
+  return Directory::Call::GetAttr(zx::unowned_channel(this->channel_), out_s, out_attributes);
+}
+
+zx_status_t Directory::Call::GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  return Directory::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_attributes);
+}
+
+zx_status_t Directory::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  _request_buffer.set_actual(sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::GetAttrResponse> Directory::SyncClient::GetAttr(::fidl::BytePart response_buffer) {
+  return Directory::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetAttrResponse> Directory::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::GetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::GetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::GetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::GetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  return Directory::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes), out_s);
+}
+
+zx_status_t Directory::Call::SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  _request_buffer.set_actual(sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::SetAttrResponse> Directory::SyncClient::SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::SetAttrResponse> Directory::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::SetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::SetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::SetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::SetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  return Directory::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(opcode), std::move(max_out), std::move(handles), std::move(in), std::move(_response_buffer), out_s, out_handles, out_out);
+}
+
+zx_status_t Directory::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  if (_request_buffer.capacity() < IoctlRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  IoctlRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Ioctl_Ordinal;
+  _request.opcode = std::move(opcode);
+  _request.max_out = std::move(max_out);
+  _request.handles = std::move(handles);
+  _request.in = std::move(in);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<IoctlRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_handles = std::move(_response.handles);
+  *out_out = std::move(_response.out);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::IoctlResponse> Directory::SyncClient::Ioctl(::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::IoctlResponse> Directory::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Ioctl_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::IoctlResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::IoctlResponse>());
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::IoctlResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::IoctlResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  return Directory::Call::Open(zx::unowned_channel(this->channel_), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+zx_status_t Directory::Call::Open(zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  OpenRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Open_Ordinal;
+  _request.flags = std::move(flags);
+  _request.mode = std::move(mode);
+  _request.path = std::move(path);
+  _request.object = std::move(object);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Directory::SyncClient::Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  return Directory::Call::Open(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+zx_status_t Directory::Call::Open(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OpenRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Open_Ordinal;
+  _request.flags = std::move(flags);
+  _request.mode = std::move(mode);
+  _request.path = std::move(path);
+  _request.object = std::move(object);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t Directory::SyncClient::Open(::fidl::DecodedMessage<OpenRequest> params) {
+  return Directory::Call::Open(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t Directory::Call::Open(zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Open_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Unlink(::fidl::StringView path, int32_t* out_s) {
+  return Directory::Call::Unlink(zx::unowned_channel(this->channel_), std::move(path), out_s);
+}
+
+zx_status_t Directory::Call::Unlink(zx::unowned_channel _client_end, ::fidl::StringView path, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  UnlinkRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Unlink_Ordinal;
+  _request.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Unlink(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::Unlink(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  UnlinkRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Unlink_Ordinal;
+  _request.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::UnlinkResponse> Directory::SyncClient::Unlink(::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::Unlink(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::UnlinkResponse> Directory::Call::Unlink(zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Unlink_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::UnlinkResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::UnlinkResponse>());
+  }
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::UnlinkResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::UnlinkResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents) {
+  return Directory::Call::ReadDirents(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer), out_s, out_dirents);
+}
+
+zx_status_t Directory::Call::ReadDirents(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents) {
+  if (_request_buffer.capacity() < ReadDirentsRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_ReadDirents_Ordinal;
+  _request.max_bytes = std::move(max_bytes);
+  _request_buffer.set_actual(sizeof(ReadDirentsRequest));
+  ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_dirents = std::move(_response.dirents);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::ReadDirentsResponse> Directory::SyncClient::ReadDirents(::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::ReadDirents(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::ReadDirentsResponse> Directory::Call::ReadDirents(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_ReadDirents_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::ReadDirentsResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::ReadDirentsResponse>());
+  }
+  auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::ReadDirentsResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::ReadDirentsResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Rewind(int32_t* out_s) {
+  return Directory::Call::Rewind(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t Directory::Call::Rewind(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<RewindRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Rewind_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindRequest));
+  ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Rewind(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Rewind(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::Rewind(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<RewindRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Rewind_Ordinal;
+  _request_buffer.set_actual(sizeof(RewindRequest));
+  ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::RewindResponse> Directory::SyncClient::Rewind(::fidl::BytePart response_buffer) {
+  return Directory::Call::Rewind(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::RewindResponse> Directory::Call::Rewind(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(RewindRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<RewindRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Rewind_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::RewindResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::RewindResponse>());
+  }
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::RewindResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::RewindResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::GetToken(int32_t* out_s, ::zx::handle* out_token) {
+  return Directory::Call::GetToken(zx::unowned_channel(this->channel_), out_s, out_token);
+}
+
+zx_status_t Directory::Call::GetToken(zx::unowned_channel _client_end, int32_t* out_s, ::zx::handle* out_token) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetTokenRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_GetToken_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+  ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_token = std::move(_response.token);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::GetToken(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token) {
+  return Directory::Call::GetToken(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_token);
+}
+
+zx_status_t Directory::Call::GetToken(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetTokenRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_GetToken_Ordinal;
+  _request_buffer.set_actual(sizeof(GetTokenRequest));
+  ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_token = std::move(_response.token);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::GetTokenResponse> Directory::SyncClient::GetToken(::fidl::BytePart response_buffer) {
+  return Directory::Call::GetToken(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetTokenResponse> Directory::Call::GetToken(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_GetToken_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::GetTokenResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::GetTokenResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::GetTokenResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::GetTokenResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  return Directory::Call::Rename(zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst), out_s);
+}
+
+zx_status_t Directory::Call::Rename(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  RenameRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Rename_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Rename(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::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, int32_t* out_s) {
+  if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  RenameRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Rename_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::RenameResponse> Directory::SyncClient::Rename(::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::Rename(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::RenameResponse> Directory::Call::Rename(zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Rename_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::RenameResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::RenameResponse>());
+  }
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::RenameResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::RenameResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  return Directory::Call::Link(zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst), out_s);
+}
+
+zx_status_t Directory::Call::Link(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  LinkRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Link_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Link(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::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, int32_t* out_s) {
+  if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  LinkRequest _request = {};
+  _request._hdr.ordinal = kDirectory_Link_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::LinkResponse> Directory::SyncClient::Link(::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::Link(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::LinkResponse> Directory::Call::Link(zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Link_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::LinkResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::LinkResponse>());
+  }
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::LinkResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::LinkResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t Directory::SyncClient::Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s) {
+  return Directory::Call::Watch(zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher), out_s);
+}
+
+zx_status_t Directory::Call::Watch(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<WatchRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectory_Watch_Ordinal;
+  _request.mask = std::move(mask);
+  _request.options = std::move(options);
+  _request.watcher = std::move(watcher);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchRequest));
+  ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t Directory::SyncClient::Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return Directory::Call::Watch(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer), out_s);
+}
+
+zx_status_t Directory::Call::Watch(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<WatchRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectory_Watch_Ordinal;
+  _request.mask = std::move(mask);
+  _request.options = std::move(options);
+  _request.watcher = std::move(watcher);
+  _request_buffer.set_actual(sizeof(WatchRequest));
+  ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<Directory::WatchResponse> Directory::SyncClient::Watch(::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+  return Directory::Call::Watch(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<Directory::WatchResponse> Directory::Call::Watch(zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Watch_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::WatchResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<Directory::WatchResponse>());
+  }
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<Directory::WatchResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<Directory::WatchResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Directory::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_INVALID_ARGS);
+    return true;
+  }
+  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+  switch (hdr->ordinal) {
+    case kDirectory_Clone_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Clone(std::move(message->flags), std::move(message->object),
+        Interface::CloneCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Close_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Close(
+        Interface::CloseCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Describe_Ordinal: {
+      auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Describe(
+        Interface::DescribeCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Sync_Ordinal: {
+      auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Sync(
+        Interface::SyncCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_GetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetAttr(
+        Interface::GetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_SetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+        Interface::SetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Ioctl_Ordinal: {
+      auto result = ::fidl::DecodeAs<IoctlRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Ioctl(std::move(message->opcode), std::move(message->max_out), std::move(message->handles), std::move(message->in),
+        Interface::IoctlCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Open_Ordinal: {
+      auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Open(std::move(message->flags), std::move(message->mode), std::move(message->path), std::move(message->object),
+        Interface::OpenCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Unlink_Ordinal: {
+      auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Unlink(std::move(message->path),
+        Interface::UnlinkCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_ReadDirents_Ordinal: {
+      auto result = ::fidl::DecodeAs<ReadDirentsRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->ReadDirents(std::move(message->max_bytes),
+        Interface::ReadDirentsCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Rewind_Ordinal: {
+      auto result = ::fidl::DecodeAs<RewindRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Rewind(
+        Interface::RewindCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_GetToken_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetToken(
+        Interface::GetTokenCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Rename_Ordinal: {
+      auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+        Interface::RenameCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Link_Ordinal: {
+      auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+        Interface::LinkCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectory_Watch_Ordinal: {
+      auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+        Interface::WatchCompleter::Sync(txn));
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool Directory::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  bool found = TryDispatch(impl, msg, txn);
+  if (!found) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_NOT_SUPPORTED);
+  }
+  return found;
+}
+
+
+void Directory::Interface::CloseCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Close_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < CloseResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Close_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Close_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::DescribeCompleterBase::Reply(NodeInfo info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Describe_Ordinal;
+  _response.info = std::move(info);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, NodeInfo info) {
+  if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Describe_Ordinal;
+  _response.info = std::move(info);
+  _buffer.set_actual(sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Describe_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, NodeInfo* info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kDirectory_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, NodeInfo* info) {
+  if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kDirectory_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+	return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_OnOpen_Ordinal;
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Directory::Interface::SyncCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Sync_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SyncResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Sync_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Sync_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::GetAttrCompleterBase::Reply(int32_t s, NodeAttributes attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, NodeAttributes attributes) {
+  if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  _buffer.set_actual(sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_GetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_SetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::IoctlCompleterBase::Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IoctlResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kDirectory_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::IoctlCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  if (_buffer.capacity() < IoctlResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kDirectory_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::IoctlCompleterBase::Reply(::fidl::DecodedMessage<IoctlResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Ioctl_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::UnlinkCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<UnlinkResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Unlink_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnlinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<UnlinkResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Unlink_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(UnlinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Unlink_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  ReadDirentsResponse _response = {};
+  _response._hdr.ordinal = kDirectory_ReadDirents_Ordinal;
+  _response.s = std::move(s);
+  _response.dirents = std::move(dirents);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+  if (_buffer.capacity() < ReadDirentsResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  ReadDirentsResponse _response = {};
+  _response._hdr.ordinal = kDirectory_ReadDirents_Ordinal;
+  _response.s = std::move(s);
+  _response.dirents = std::move(dirents);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(::fidl::DecodedMessage<ReadDirentsResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_ReadDirents_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::RewindCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<RewindResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Rewind_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::RewindCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < RewindResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<RewindResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Rewind_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(RewindResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::RewindCompleterBase::Reply(::fidl::DecodedMessage<RewindResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Rewind_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::GetTokenCompleterBase::Reply(int32_t s, ::zx::handle token) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetTokenResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_GetToken_Ordinal;
+  _response.s = std::move(s);
+  _response.token = std::move(token);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token) {
+  if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetTokenResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_GetToken_Ordinal;
+  _response.s = std::move(s);
+  _response.token = std::move(token);
+  _buffer.set_actual(sizeof(GetTokenResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_GetToken_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::RenameCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<RenameResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Rename_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RenameResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < RenameResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<RenameResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Rename_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(RenameResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Rename_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::LinkCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<LinkResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Link_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < LinkResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<LinkResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Link_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(LinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Link_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::WatchCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<WatchResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectory_Watch_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::WatchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < WatchResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<WatchResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectory_Watch_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(WatchResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::WatchCompleterBase::Reply(::fidl::DecodedMessage<WatchResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectory_Watch_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Clone_Ordinal = 402549324u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminCloneRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Close_Ordinal = 1387878023u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Describe_Ordinal = 526573406u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_OnOpen_Ordinal = 1191225277u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Sync_Ordinal = 1648508842u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_GetAttr_Ordinal = 1166403528u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_SetAttr_Ordinal = 198530458u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Ioctl_Ordinal = 905161895u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminIoctlResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Open_Ordinal = 2011483371u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminOpenRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Unlink_Ordinal = 750443289u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminUnlinkRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_ReadDirents_Ordinal = 782580781u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Rewind_Ordinal = 1886584199u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_GetToken_Ordinal = 840416493u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Rename_Ordinal = 1251258540u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminRenameRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Link_Ordinal = 462052964u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminLinkRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Watch_Ordinal = 1522700084u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminWatchRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Mount_Ordinal = 2120159974u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminMountRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_MountAndCreate_Ordinal = 841348753u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_Unmount_Ordinal = 620898132u;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_UnmountNode_Ordinal = 383400103u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_QueryFilesystem_Ordinal = 1713999250u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+[[maybe_unused]]
+constexpr uint32_t kDirectoryAdmin_GetDevicePath_Ordinal = 787943096u;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+
+}  // namespace
+
+zx_status_t DirectoryAdmin::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+  return DirectoryAdmin::Call::Clone(zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+zx_status_t DirectoryAdmin::Call::Clone(zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  return DirectoryAdmin::Call::Clone(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+zx_status_t DirectoryAdmin::Call::Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+  if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Clone_Ordinal;
+  _request.flags = std::move(flags);
+  _request.object = std::move(object);
+  _request_buffer.set_actual(sizeof(CloneRequest));
+  ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Clone(::fidl::DecodedMessage<CloneRequest> params) {
+  return DirectoryAdmin::Call::Clone(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t DirectoryAdmin::Call::Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Clone_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Close(int32_t* out_s) {
+  return DirectoryAdmin::Call::Close(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Close(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<CloseRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Close(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Close(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<CloseRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  _request_buffer.set_actual(sizeof(CloseRequest));
+  ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::CloseResponse> DirectoryAdmin::SyncClient::Close(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Close(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::CloseResponse> DirectoryAdmin::Call::Close(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::CloseResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::CloseResponse>());
+  }
+  auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::CloseResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::CloseResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Describe(NodeInfo* out_info) {
+  return DirectoryAdmin::Call::Describe(zx::unowned_channel(this->channel_), out_info);
+}
+
+zx_status_t DirectoryAdmin::Call::Describe(zx::unowned_channel _client_end, NodeInfo* out_info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  return DirectoryAdmin::Call::Describe(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_info);
+}
+
+zx_status_t DirectoryAdmin::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  _request_buffer.set_actual(sizeof(DescribeRequest));
+  ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::DescribeResponse> DirectoryAdmin::SyncClient::Describe(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Describe(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::DescribeResponse> DirectoryAdmin::Call::Describe(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::DescribeResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::DescribeResponse>());
+  }
+  auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::DescribeResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::DescribeResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Sync(int32_t* out_s) {
+  return DirectoryAdmin::Call::Sync(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Sync(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SyncRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Sync(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Sync(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<SyncRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  _request_buffer.set_actual(sizeof(SyncRequest));
+  ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SyncResponse> DirectoryAdmin::SyncClient::Sync(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Sync(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SyncResponse> DirectoryAdmin::Call::Sync(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::SyncResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::SyncResponse>());
+  }
+  auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::SyncResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::SyncResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::GetAttr(int32_t* out_s, NodeAttributes* out_attributes) {
+  return DirectoryAdmin::Call::GetAttr(zx::unowned_channel(this->channel_), out_s, out_attributes);
+}
+
+zx_status_t DirectoryAdmin::Call::GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  return DirectoryAdmin::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_attributes);
+}
+
+zx_status_t DirectoryAdmin::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  _request_buffer.set_actual(sizeof(GetAttrRequest));
+  ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_attributes = std::move(_response.attributes);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse> DirectoryAdmin::SyncClient::GetAttr(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::GetAttr(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse> DirectoryAdmin::Call::GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  return DirectoryAdmin::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  _request.flags = std::move(flags);
+  _request.attributes = std::move(attributes);
+  _request_buffer.set_actual(sizeof(SetAttrRequest));
+  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse> DirectoryAdmin::SyncClient::SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::SetAttr(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse> DirectoryAdmin::Call::SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::SetAttrResponse>());
+  }
+  auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::SetAttrResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  return DirectoryAdmin::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(opcode), std::move(max_out), std::move(handles), std::move(in), std::move(_response_buffer), out_s, out_handles, out_out);
+}
+
+zx_status_t DirectoryAdmin::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out) {
+  if (_request_buffer.capacity() < IoctlRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  IoctlRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Ioctl_Ordinal;
+  _request.opcode = std::move(opcode);
+  _request.max_out = std::move(max_out);
+  _request.handles = std::move(handles);
+  _request.in = std::move(in);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<IoctlRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_handles = std::move(_response.handles);
+  *out_out = std::move(_response.out);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::IoctlResponse> DirectoryAdmin::SyncClient::Ioctl(::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Ioctl(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::IoctlResponse> DirectoryAdmin::Call::Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Ioctl_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::IoctlResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::IoctlResponse>());
+  }
+  auto _call_result = ::fidl::Call<IoctlRequest, IoctlResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::IoctlResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::IoctlResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  return DirectoryAdmin::Call::Open(zx::unowned_channel(this->channel_), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+zx_status_t DirectoryAdmin::Call::Open(zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  OpenRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Open_Ordinal;
+  _request.flags = std::move(flags);
+  _request.mode = std::move(mode);
+  _request.path = std::move(path);
+  _request.object = std::move(object);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  return DirectoryAdmin::Call::Open(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+zx_status_t DirectoryAdmin::Call::Open(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+  if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OpenRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Open_Ordinal;
+  _request.flags = std::move(flags);
+  _request.mode = std::move(mode);
+  _request.path = std::move(path);
+  _request.object = std::move(object);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Open(::fidl::DecodedMessage<OpenRequest> params) {
+  return DirectoryAdmin::Call::Open(zx::unowned_channel(this->channel_), std::move(params));
+}
+
+zx_status_t DirectoryAdmin::Call::Open(zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Open_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  return ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Unlink(::fidl::StringView path, int32_t* out_s) {
+  return DirectoryAdmin::Call::Unlink(zx::unowned_channel(this->channel_), std::move(path), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Unlink(zx::unowned_channel _client_end, ::fidl::StringView path, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  UnlinkRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  _request.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Unlink(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Unlink(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  UnlinkRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  _request.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse> DirectoryAdmin::SyncClient::Unlink(::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Unlink(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse> DirectoryAdmin::Call::Unlink(zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnlinkResponse>());
+  }
+  auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnlinkResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents) {
+  return DirectoryAdmin::Call::ReadDirents(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer), out_s, out_dirents);
+}
+
+zx_status_t DirectoryAdmin::Call::ReadDirents(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents) {
+  if (_request_buffer.capacity() < ReadDirentsRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_ReadDirents_Ordinal;
+  _request.max_bytes = std::move(max_bytes);
+  _request_buffer.set_actual(sizeof(ReadDirentsRequest));
+  ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_dirents = std::move(_response.dirents);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse> DirectoryAdmin::SyncClient::ReadDirents(::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::ReadDirents(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse> DirectoryAdmin::Call::ReadDirents(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_ReadDirents_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsResponse>());
+  }
+  auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Rewind(int32_t* out_s) {
+  return DirectoryAdmin::Call::Rewind(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Rewind(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<RewindRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindRequest));
+  ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Rewind(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Rewind(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Rewind(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<RewindRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  _request_buffer.set_actual(sizeof(RewindRequest));
+  ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RewindResponse> DirectoryAdmin::SyncClient::Rewind(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Rewind(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RewindResponse> DirectoryAdmin::Call::Rewind(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(RewindRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<RewindRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::RewindResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::RewindResponse>());
+  }
+  auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::RewindResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::RewindResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::GetToken(int32_t* out_s, ::zx::handle* out_token) {
+  return DirectoryAdmin::Call::GetToken(zx::unowned_channel(this->channel_), out_s, out_token);
+}
+
+zx_status_t DirectoryAdmin::Call::GetToken(zx::unowned_channel _client_end, int32_t* out_s, ::zx::handle* out_token) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<GetTokenRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+  ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_token = std::move(_response.token);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::GetToken(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token) {
+  return DirectoryAdmin::Call::GetToken(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_token);
+}
+
+zx_status_t DirectoryAdmin::Call::GetToken(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetTokenRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  _request_buffer.set_actual(sizeof(GetTokenRequest));
+  ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_token = std::move(_response.token);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse> DirectoryAdmin::SyncClient::GetToken(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::GetToken(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse> DirectoryAdmin::Call::GetToken(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetTokenResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetTokenResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  return DirectoryAdmin::Call::Rename(zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Rename(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  RenameRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Rename(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::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, int32_t* out_s) {
+  if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  RenameRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RenameResponse> DirectoryAdmin::SyncClient::Rename(::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Rename(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RenameResponse> DirectoryAdmin::Call::Rename(zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::RenameResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::RenameResponse>());
+  }
+  auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::RenameResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::RenameResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  return DirectoryAdmin::Call::Link(zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Link(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  LinkRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Link(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::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, int32_t* out_s) {
+  if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  LinkRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  _request.src = std::move(src);
+  _request.dst_parent_token = std::move(dst_parent_token);
+  _request.dst = std::move(dst);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::LinkResponse> DirectoryAdmin::SyncClient::Link(::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Link(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::LinkResponse> DirectoryAdmin::Call::Link(zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::LinkResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::LinkResponse>());
+  }
+  auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::LinkResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::LinkResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s) {
+  return DirectoryAdmin::Call::Watch(zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Watch(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<WatchRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  _request.mask = std::move(mask);
+  _request.options = std::move(options);
+  _request.watcher = std::move(watcher);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchRequest));
+  ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Watch(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Watch(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<WatchRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  _request.mask = std::move(mask);
+  _request.options = std::move(options);
+  _request.watcher = std::move(watcher);
+  _request_buffer.set_actual(sizeof(WatchRequest));
+  ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::WatchResponse> DirectoryAdmin::SyncClient::Watch(::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Watch(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::WatchResponse> DirectoryAdmin::Call::Watch(zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::WatchResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::WatchResponse>());
+  }
+  auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::WatchResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::WatchResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Mount(::zx::channel remote, int32_t* out_s) {
+  return DirectoryAdmin::Call::Mount(zx::unowned_channel(this->channel_), std::move(remote), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Mount(zx::unowned_channel _client_end, ::zx::channel remote, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<MountRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  _request.remote = std::move(remote);
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountRequest));
+  ::fidl::DecodedMessage<MountRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<MountResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<MountRequest, MountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Mount(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Mount(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(remote), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Mount(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < MountRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  auto& _request = *reinterpret_cast<MountRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  _request.remote = std::move(remote);
+  _request_buffer.set_actual(sizeof(MountRequest));
+  ::fidl::DecodedMessage<MountRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<MountRequest, MountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountResponse> DirectoryAdmin::SyncClient::Mount(::fidl::DecodedMessage<MountRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Mount(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountResponse> DirectoryAdmin::Call::Mount(zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::MountResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::MountResponse>());
+  }
+  auto _call_result = ::fidl::Call<MountRequest, MountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::MountResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::MountResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags, int32_t* out_s) {
+  return DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel(this->channel_), std::move(remote), std::move(name), std::move(flags), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountAndCreateRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  MountAndCreateRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  _request.remote = std::move(remote);
+  _request.name = std::move(name);
+  _request.flags = std::move(flags);
+  auto _linearize_result = ::fidl::Linearize(&_request, ::fidl::BytePart(_write_bytes,
+                                                                         _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<MountAndCreateRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<MountAndCreateResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<MountAndCreateRequest, MountAndCreateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::MountAndCreate(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(remote), std::move(name), std::move(flags), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  if (_request_buffer.capacity() < MountAndCreateRequest::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  MountAndCreateRequest _request = {};
+  _request._hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  _request.remote = std::move(remote);
+  _request.name = std::move(name);
+  _request.flags = std::move(flags);
+  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  ::fidl::DecodedMessage<MountAndCreateRequest> _decoded_request = std::move(_linearize_result.message);
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<MountAndCreateRequest, MountAndCreateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse> DirectoryAdmin::SyncClient::MountAndCreate(::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel(this->channel_), std::move(params), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse> DirectoryAdmin::Call::MountAndCreate(zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateResponse>());
+  }
+  auto _call_result = ::fidl::Call<MountAndCreateRequest, MountAndCreateResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::Unmount(int32_t* out_s) {
+  return DirectoryAdmin::Call::Unmount(zx::unowned_channel(this->channel_), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Unmount(zx::unowned_channel _client_end, int32_t* out_s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<UnmountRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountRequest));
+  ::fidl::DecodedMessage<UnmountRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<UnmountResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<UnmountRequest, UnmountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::Unmount(::fidl::BytePart _response_buffer, int32_t* out_s) {
+  return DirectoryAdmin::Call::Unmount(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s);
+}
+
+zx_status_t DirectoryAdmin::Call::Unmount(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<UnmountRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  _request_buffer.set_actual(sizeof(UnmountRequest));
+  ::fidl::DecodedMessage<UnmountRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<UnmountRequest, UnmountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountResponse> DirectoryAdmin::SyncClient::Unmount(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::Unmount(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountResponse> DirectoryAdmin::Call::Unmount(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(UnmountRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<UnmountRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnmountResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnmountResponse>());
+  }
+  auto _call_result = ::fidl::Call<UnmountRequest, UnmountResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnmountResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnmountResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::UnmountNode(int32_t* out_s, ::zx::channel* out_remote) {
+  return DirectoryAdmin::Call::UnmountNode(zx::unowned_channel(this->channel_), out_s, out_remote);
+}
+
+zx_status_t DirectoryAdmin::Call::UnmountNode(zx::unowned_channel _client_end, int32_t* out_s, ::zx::channel* out_remote) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountNodeRequest>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _request = *reinterpret_cast<UnmountNodeRequest*>(_write_bytes);
+  _request._hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountNodeRequest));
+  ::fidl::DecodedMessage<UnmountNodeRequest> _decoded_request(std::move(_request_bytes));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<UnmountNodeResponse>();
+  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
+  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
+  auto _call_result = ::fidl::Call<UnmountNodeRequest, UnmountNodeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_bytes));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_remote = std::move(_response.remote);
+  return ZX_OK;
+}
+
+zx_status_t DirectoryAdmin::SyncClient::UnmountNode(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::channel* out_remote) {
+  return DirectoryAdmin::Call::UnmountNode(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_remote);
+}
+
+zx_status_t DirectoryAdmin::Call::UnmountNode(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::channel* out_remote) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountNodeRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<UnmountNodeRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  _request_buffer.set_actual(sizeof(UnmountNodeRequest));
+  ::fidl::DecodedMessage<UnmountNodeRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<UnmountNodeRequest, UnmountNodeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_remote = std::move(_response.remote);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse> DirectoryAdmin::SyncClient::UnmountNode(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::UnmountNode(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse> DirectoryAdmin::Call::UnmountNode(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountNodeRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(UnmountNodeRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<UnmountNodeRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeResponse>());
+  }
+  auto _call_result = ::fidl::Call<UnmountNodeRequest, UnmountNodeResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::QueryFilesystem(::fidl::BytePart _response_buffer, int32_t* out_s, FilesystemInfo** out_info) {
+  return DirectoryAdmin::Call::QueryFilesystem(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_info);
+}
+
+zx_status_t DirectoryAdmin::Call::QueryFilesystem(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, FilesystemInfo** out_info) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryFilesystemRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<QueryFilesystemRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_QueryFilesystem_Ordinal;
+  _request_buffer.set_actual(sizeof(QueryFilesystemRequest));
+  ::fidl::DecodedMessage<QueryFilesystemRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<QueryFilesystemRequest, QueryFilesystemResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_info = std::move(_response.info);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse> DirectoryAdmin::SyncClient::QueryFilesystem(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::QueryFilesystem(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse> DirectoryAdmin::Call::QueryFilesystem(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryFilesystemRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(QueryFilesystemRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<QueryFilesystemRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_QueryFilesystem_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemResponse>());
+  }
+  auto _call_result = ::fidl::Call<QueryFilesystemRequest, QueryFilesystemResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+zx_status_t DirectoryAdmin::SyncClient::GetDevicePath(::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::StringView* out_path) {
+  return DirectoryAdmin::Call::GetDevicePath(zx::unowned_channel(this->channel_), std::move(_response_buffer), out_s, out_path);
+}
+
+zx_status_t DirectoryAdmin::Call::GetDevicePath(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::StringView* out_path) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDevicePathRequest)] = {};
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+  auto& _request = *reinterpret_cast<GetDevicePathRequest*>(_request_buffer.data());
+  _request._hdr.ordinal = kDirectoryAdmin_GetDevicePath_Ordinal;
+  _request_buffer.set_actual(sizeof(GetDevicePathRequest));
+  ::fidl::DecodedMessage<GetDevicePathRequest> _decoded_request(std::move(_request_buffer));
+  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
+  if (_encode_request_result.status != ZX_OK) {
+    return _encode_request_result.status;
+  }
+  auto _call_result = ::fidl::Call<GetDevicePathRequest, GetDevicePathResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(_response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return _call_result.status;
+  }
+  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
+  if (_decode_result.status != ZX_OK) {
+    return _decode_result.status;
+  }
+  auto& _response = *_decode_result.message.message();
+  *out_s = std::move(_response.s);
+  *out_path = std::move(_response.path);
+  return ZX_OK;
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse> DirectoryAdmin::SyncClient::GetDevicePath(::fidl::BytePart response_buffer) {
+  return DirectoryAdmin::Call::GetDevicePath(zx::unowned_channel(this->channel_), std::move(response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse> DirectoryAdmin::Call::GetDevicePath(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDevicePathRequest)] = {};
+  constexpr uint32_t _write_num_bytes = sizeof(GetDevicePathRequest);
+  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes), _write_num_bytes);
+  ::fidl::DecodedMessage<GetDevicePathRequest> params(std::move(_request_buffer));
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetDevicePath_Ordinal;
+  auto _encode_request_result = ::fidl::Encode(std::move(params));
+  if (_encode_request_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse>(
+      _encode_request_result.status,
+      _encode_request_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathResponse>());
+  }
+  auto _call_result = ::fidl::Call<GetDevicePathRequest, GetDevicePathResponse>(
+    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+  if (_call_result.status != ZX_OK) {
+    return ::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse>(
+      _call_result.status,
+      _call_result.error,
+      ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathResponse>());
+  }
+  return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DirectoryAdmin::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_INVALID_ARGS);
+    return true;
+  }
+  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+  switch (hdr->ordinal) {
+    case kDirectoryAdmin_Clone_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Clone(std::move(message->flags), std::move(message->object),
+        Interface::CloneCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Close_Ordinal: {
+      auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Close(
+        Interface::CloseCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Describe_Ordinal: {
+      auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Describe(
+        Interface::DescribeCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Sync_Ordinal: {
+      auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Sync(
+        Interface::SyncCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_GetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetAttr(
+        Interface::GetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_SetAttr_Ordinal: {
+      auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+        Interface::SetAttrCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Ioctl_Ordinal: {
+      auto result = ::fidl::DecodeAs<IoctlRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Ioctl(std::move(message->opcode), std::move(message->max_out), std::move(message->handles), std::move(message->in),
+        Interface::IoctlCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Open_Ordinal: {
+      auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Open(std::move(message->flags), std::move(message->mode), std::move(message->path), std::move(message->object),
+        Interface::OpenCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Unlink_Ordinal: {
+      auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Unlink(std::move(message->path),
+        Interface::UnlinkCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_ReadDirents_Ordinal: {
+      auto result = ::fidl::DecodeAs<ReadDirentsRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->ReadDirents(std::move(message->max_bytes),
+        Interface::ReadDirentsCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Rewind_Ordinal: {
+      auto result = ::fidl::DecodeAs<RewindRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Rewind(
+        Interface::RewindCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_GetToken_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetToken(
+        Interface::GetTokenCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Rename_Ordinal: {
+      auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+        Interface::RenameCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Link_Ordinal: {
+      auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+        Interface::LinkCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Watch_Ordinal: {
+      auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+        Interface::WatchCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Mount_Ordinal: {
+      auto result = ::fidl::DecodeAs<MountRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->Mount(std::move(message->remote),
+        Interface::MountCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_MountAndCreate_Ordinal: {
+      auto result = ::fidl::DecodeAs<MountAndCreateRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      auto message = result.message.message();
+      impl->MountAndCreate(std::move(message->remote), std::move(message->name), std::move(message->flags),
+        Interface::MountAndCreateCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_Unmount_Ordinal: {
+      auto result = ::fidl::DecodeAs<UnmountRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->Unmount(
+        Interface::UnmountCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_UnmountNode_Ordinal: {
+      auto result = ::fidl::DecodeAs<UnmountNodeRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->UnmountNode(
+        Interface::UnmountNodeCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_QueryFilesystem_Ordinal: {
+      auto result = ::fidl::DecodeAs<QueryFilesystemRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->QueryFilesystem(
+        Interface::QueryFilesystemCompleter::Sync(txn));
+      return true;
+    }
+    case kDirectoryAdmin_GetDevicePath_Ordinal: {
+      auto result = ::fidl::DecodeAs<GetDevicePathRequest>(msg);
+      if (result.status != ZX_OK) {
+        txn->Close(ZX_ERR_INVALID_ARGS);
+        return true;
+      }
+      impl->GetDevicePath(
+        Interface::GetDevicePathCompleter::Sync(txn));
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+bool DirectoryAdmin::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+  bool found = TryDispatch(impl, msg, txn);
+  if (!found) {
+    zx_handle_close_many(msg->handles, msg->num_handles);
+    txn->Close(ZX_ERR_NOT_SUPPORTED);
+  }
+  return found;
+}
+
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < CloseResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(CloseResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Close_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(NodeInfo info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  _response.info = std::move(info);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, NodeInfo info) {
+  if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<DescribeResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  _response.info = std::move(info);
+  _buffer.set_actual(sizeof(DescribeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<DescribeResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Describe_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, NodeInfo* info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kDirectoryAdmin_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, NodeInfo* info) {
+  if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+  OnOpenResponse _response = {};
+  _response._hdr = {};
+  _response._hdr.ordinal = kDirectoryAdmin_OnOpen_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+	return _linearize_result.status;
+  }
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_OnOpen_Ordinal;
+  return ::fidl::Write(zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SyncResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SyncResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Sync_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(int32_t s, NodeAttributes attributes) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, NodeAttributes attributes) {
+  if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  _response.s = std::move(s);
+  _response.attributes = std::move(attributes);
+  _buffer.set_actual(sizeof(GetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(SetAttrResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_SetAttr_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::IoctlCompleterBase::Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IoctlResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::IoctlCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out) {
+  if (_buffer.capacity() < IoctlResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  IoctlResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_Ioctl_Ordinal;
+  _response.s = std::move(s);
+  _response.handles = std::move(handles);
+  _response.out = std::move(out);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::IoctlCompleterBase::Reply(::fidl::DecodedMessage<IoctlResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Ioctl_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<UnlinkResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnlinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<UnlinkResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(UnlinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Unlink_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  ReadDirentsResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_ReadDirents_Ordinal;
+  _response.s = std::move(s);
+  _response.dirents = std::move(dirents);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+  if (_buffer.capacity() < ReadDirentsResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  ReadDirentsResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_ReadDirents_Ordinal;
+  _response.s = std::move(s);
+  _response.dirents = std::move(dirents);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(::fidl::DecodedMessage<ReadDirentsResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_ReadDirents_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<RewindResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < RewindResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<RewindResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(RewindResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(::fidl::DecodedMessage<RewindResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Rewind_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(int32_t s, ::zx::handle token) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<GetTokenResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  _response.s = std::move(s);
+  _response.token = std::move(token);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token) {
+  if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<GetTokenResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  _response.s = std::move(s);
+  _response.token = std::move(token);
+  _buffer.set_actual(sizeof(GetTokenResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetToken_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<RenameResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RenameResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < RenameResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<RenameResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(RenameResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Rename_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<LinkResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < LinkResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<LinkResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(LinkResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Link_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<WatchResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < WatchResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<WatchResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(WatchResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(::fidl::DecodedMessage<WatchResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Watch_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<MountResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<MountResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < MountResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<MountResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(MountResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<MountResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(::fidl::DecodedMessage<MountResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Mount_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountAndCreateResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<MountAndCreateResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountAndCreateResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<MountAndCreateResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < MountAndCreateResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<MountAndCreateResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(MountAndCreateResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<MountAndCreateResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(::fidl::DecodedMessage<MountAndCreateResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_MountAndCreate_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(int32_t s) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<UnmountResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  _response.s = std::move(s);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnmountResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+  if (_buffer.capacity() < UnmountResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<UnmountResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  _response.s = std::move(s);
+  _buffer.set_actual(sizeof(UnmountResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnmountResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(::fidl::DecodedMessage<UnmountResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_Unmount_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(int32_t s, ::zx::channel remote) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountNodeResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+  auto& _response = *reinterpret_cast<UnmountNodeResponse*>(_write_bytes);
+  _response._hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  _response.s = std::move(s);
+  _response.remote = std::move(remote);
+  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountNodeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnmountNodeResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::channel remote) {
+  if (_buffer.capacity() < UnmountNodeResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  auto& _response = *reinterpret_cast<UnmountNodeResponse*>(_buffer.data());
+  _response._hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  _response.s = std::move(s);
+  _response.remote = std::move(remote);
+  _buffer.set_actual(sizeof(UnmountNodeResponse));
+  CompleterBase::SendReply(::fidl::DecodedMessage<UnmountNodeResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(::fidl::DecodedMessage<UnmountNodeResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_UnmountNode_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(int32_t s, FilesystemInfo* info) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryFilesystemResponse>();
+  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+  QueryFilesystemResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_QueryFilesystem_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, FilesystemInfo* info) {
+  if (_buffer.capacity() < QueryFilesystemResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  QueryFilesystemResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_QueryFilesystem_Ordinal;
+  _response.s = std::move(s);
+  _response.info = std::move(info);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(::fidl::DecodedMessage<QueryFilesystemResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_QueryFilesystem_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(int32_t s, ::fidl::StringView path) {
+  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePathResponse>();
+  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+  GetDevicePathResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_GetDevicePath_Ordinal;
+  _response.s = std::move(s);
+  _response.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+                                                                          _kWriteAllocSize));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView path) {
+  if (_buffer.capacity() < GetDevicePathResponse::PrimarySize) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  GetDevicePathResponse _response = {};
+  _response._hdr.ordinal = kDirectoryAdmin_GetDevicePath_Ordinal;
+  _response.s = std::move(s);
+  _response.path = std::move(path);
+  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+  if (_linearize_result.status != ZX_OK) {
+    CompleterBase::Close(ZX_ERR_INTERNAL);
+    return;
+  }
+  CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(::fidl::DecodedMessage<GetDevicePathResponse> params) {
+  params.message()->_hdr = {};
+  params.message()->_hdr.ordinal = kDirectoryAdmin_GetDevicePath_Ordinal;
+  CompleterBase::SendReply(std::move(params));
+}
+
+
+}  // namespace io
+}  // namespace fuchsia
diff --git a/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h b/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h
new file mode 100644
index 0000000000000000000000000000000000000000..2e567704387e9841a12fff82a17c6852d86878d8
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h
@@ -0,0 +1,7076 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#pragma once
+
+#include <lib/fidl/internal.h>
+#include <lib/fidl/cpp/vector_view.h>
+#include <lib/fidl/cpp/string_view.h>
+#include <lib/fidl/llcpp/array.h>
+#include <lib/fidl/llcpp/coding.h>
+#include <lib/fidl/llcpp/traits.h>
+#include <lib/fidl/llcpp/transaction.h>
+#include <lib/zx/channel.h>
+#include <lib/zx/event.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 fuchsia {
+namespace io {
+
+struct WatchedEvent;
+struct Vmofile;
+struct Tty;
+class DirectoryWatcher;
+struct Service;
+enum class SeekOrigin : uint32_t {
+  START = 0,
+  CURRENT = 1,
+  END = 2,
+};
+
+
+struct Pipe;
+struct NodeAttributes;
+struct FilesystemInfo;
+struct FileObject;
+struct DirectoryObject;
+struct Device;
+struct NodeInfo;
+class Node;
+class File;
+class Directory;
+class DirectoryAdmin;
+
+extern "C" const fidl_type_t fuchsia_io_WatchedEventTable;
+
+// TODO(ZX-2645): Unused.
+//
+// WatchedEvent describes events returned from a DirectoryWatcher.
+struct WatchedEvent {
+  static constexpr const fidl_type_t* Type = &fuchsia_io_WatchedEventTable;
+  static constexpr uint32_t MaxNumHandles = 0;
+  static constexpr uint32_t PrimarySize = 24;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 256;
+
+  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 = 0x00000004;
+
+// Used by Directory::Watch. Requests transmission of WATCH_EVENT_IDLE.
+constexpr uint32_t WATCH_MASK_IDLE = 0x00000010;
+
+// Used by Directory::Watch. Requests transmission of WATCH_EVENT_EXISTING.
+constexpr uint32_t WATCH_MASK_EXISTING = 0x00000008;
+
+// Used by Directory::Watch. Requests transmission of WATCH_EVENT_DELETED.
+constexpr uint32_t WATCH_MASK_DELETED = 0x00000001;
+
+// Used by Directory::Watch. Requests transmission of all watcher events.
+constexpr uint32_t WATCH_MASK_ALL = 0x0000001F;
+
+// Used by Directory::Watch. Requests transmission of WATCH_EVENT_ADDED.
+constexpr uint32_t WATCH_MASK_ADDED = 0x00000002;
+
+// Identifies a node has been removed (either deleted or moved) from the directory.
+constexpr uint8_t WATCH_EVENT_REMOVED = 2;
+
+// Identifies that no more WATCH_EVENT_EXISTING events will be sent.
+constexpr uint8_t WATCH_EVENT_IDLE = 4;
+
+// Identifies a node already existed in the directory when watching started.
+constexpr uint8_t WATCH_EVENT_EXISTING = 3;
+
+// Indicates the directory being watched has been deleted.
+constexpr uint8_t WATCH_EVENT_DELETED = 0;
+
+// Indicates a node has been created (either new or moved) into a directory.
+constexpr uint8_t WATCH_EVENT_ADDED = 1;
+
+extern "C" const fidl_type_t 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 = &fuchsia_io_VmofileTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 24;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  // 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 = 0x00000002;
+
+// Requests that the VMO be readable.
+constexpr uint32_t VMO_FLAG_READ = 0x00000001;
+
+// 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 = 0x00010000;
+
+// Requests that the VMO be executable.
+constexpr uint32_t VMO_FLAG_EXEC = 0x00000004;
+
+// 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 = 0x00020000;
+
+extern "C" const fidl_type_t fuchsia_io_TtyTable;
+
+// The object may be cast to interface 'Tty'
+struct Tty {
+  static constexpr const fidl_type_t* Type = &fuchsia_io_TtyTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 4;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  ::zx::event event{};
+};
+
+extern "C" const fidl_type_t fuchsia_io_DirectoryWatcherOnEventRequestTable;
+
+// TODO(ZX-2645): Unused.
+//
+// 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 {
+ public:
+
+  struct OnEventRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::fidl::VectorView<uint8_t> events;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryWatcherOnEventRequestTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+  };
+
+
+  class SyncClient final {
+   public:
+    SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+    ~SyncClient() {}
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    zx_status_t OnEvent(::fidl::VectorView<uint8_t> events);
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t OnEvent(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    // Messages are encoded and decoded in-place.
+    zx_status_t OnEvent(::fidl::DecodedMessage<OnEventRequest> params);
+
+   private:
+    ::zx::channel channel_;
+  };
+
+  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
+  class Call final {
+   public:
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    static zx_status_t OnEvent(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events);
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t OnEvent(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
+
+    // TODO(smklein): Convert this to a vector of WatchedEvents, when possible.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t 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);
+  }
+
+};
+
+
+
+// The default protocol, interface information must be acquired some
+// other way.
+struct Service {
+  static constexpr const fidl_type_t* Type = nullptr;
+  static constexpr uint32_t MaxNumHandles = 0;
+  static constexpr uint32_t PrimarySize = 1;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  uint8_t __reserved{};
+};
+
+extern "C" const fidl_type_t fuchsia_io_PipeTable;
+
+// The object is accompanied by a pipe.
+struct Pipe {
+  static constexpr const fidl_type_t* Type = &fuchsia_io_PipeTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 4;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  ::zx::socket socket{};
+};
+
+// Can write to target object.
+constexpr uint32_t OPEN_RIGHT_WRITABLE = 0x00000002;
+
+// Can read from target object.
+constexpr uint32_t OPEN_RIGHT_READABLE = 0x00000001;
+
+// Connection can mount/umount filesystem.
+constexpr uint32_t OPEN_RIGHT_ADMIN = 0x00000004;
+
+// Truncate the object before usage.
+constexpr uint32_t OPEN_FLAG_TRUNCATE = 0x00040000;
+
+// 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 expands to include
+//   OPEN_RIGHT_WRITABLE if and only if the current connection and all intermediate mount points
+//   are writable.
+// - 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 = 0x01000000;
+
+// If the object is a mount point, open the local directory.
+constexpr uint32_t OPEN_FLAG_NO_REMOTE = 0x00200000;
+
+// 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 = 0x02000000;
+
+// 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 = 0x00400000;
+
+// 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 = 0x00080000;
+
+// 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 = 0x00800000;
+
+// (with Create) Fail if the object already exists.
+constexpr uint32_t OPEN_FLAG_CREATE_IF_ABSENT = 0x00020000;
+
+// Create the object if it doesn't exist.
+constexpr uint32_t OPEN_FLAG_CREATE = 0x00010000;
+
+// Seek to the end of the object before all writes.
+constexpr uint32_t OPEN_FLAG_APPEND = 0x00100000;
+
+// 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 = 0x02c80000;
+
+
+
+// NodeAttributes defines generic information about a filesystem node.
+struct NodeAttributes {
+  static constexpr const fidl_type_t* Type = nullptr;
+  static constexpr uint32_t MaxNumHandles = 0;
+  static constexpr uint32_t PrimarySize = 56;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  // 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 = 0x00000002;
+
+// 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 = 0x00000001;
+
+constexpr uint32_t MOUNT_CREATE_FLAG_REPLACE = 0x00000001;
+
+constexpr uint32_t MODE_TYPE_SOCKET = 0x0C000;
+
+constexpr uint32_t MODE_TYPE_SERVICE = 0x10000;
+
+// 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 = 0xFF000;
+
+constexpr uint32_t MODE_TYPE_FILE = 0x08000;
+
+constexpr uint32_t MODE_TYPE_DIRECTORY = 0x04000;
+
+constexpr uint32_t MODE_TYPE_BLOCK_DEVICE = 0x06000;
+
+// 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 = 0x00FFF;
+
+// The maximum length, in bytes, of a filesystem string.
+constexpr uint64_t MAX_PATH = 4096;
+
+constexpr uint64_t MAX_IOCTL_HANDLES = 2;
+
+constexpr uint64_t MAX_FS_NAME_BUFFER = 32;
+
+// The maximum length, in bytes, of a single filesystem component.
+constexpr uint64_t MAX_FILENAME = 255;
+
+// The maximal buffer size which can be transmitted for buffered operations.
+// This capacity is currently set somewhat arbitrarily.
+constexpr uint64_t MAX_BUF = 8192;
+
+// Nodes which do not have ino values should return this value
+// from Readdir and GetAttr.
+constexpr uint64_t INO_UNKNOWN = 0xFFFFFFFFFFFFFFFF;
+
+
+
+struct FilesystemInfo {
+  static constexpr const fidl_type_t* Type = nullptr;
+  static constexpr uint32_t MaxNumHandles = 0;
+  static constexpr uint32_t PrimarySize = 96;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  // 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{};
+
+  // TODO(smklein): Replace this field with a string when supported
+  // by the "Simple" interface. At the moment, name is a fixed-size,
+  // null-terminated buffer.
+  ::fidl::Array<int8_t, 32> name{};
+};
+
+extern "C" const fidl_type_t fuchsia_io_FileObjectTable;
+
+// The object may be cast to interface 'File'.
+struct FileObject {
+  static constexpr const fidl_type_t* Type = &fuchsia_io_FileObjectTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 4;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  // 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 = 0x02000000;
+
+// Indicates the file is ready for reading.
+constexpr uint32_t FILE_SIGNAL_READABLE = 0x01000000;
+
+
+
+// The object may be cast to interface 'Directory'.
+struct DirectoryObject {
+  static constexpr const fidl_type_t* Type = nullptr;
+  static constexpr uint32_t MaxNumHandles = 0;
+  static constexpr uint32_t PrimarySize = 1;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  uint8_t __reserved{};
+};
+
+extern "C" const fidl_type_t fuchsia_io_DeviceTable;
+
+// The object may be cast to interface 'Device'.
+struct Device {
+  static constexpr const fidl_type_t* Type = &fuchsia_io_DeviceTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 4;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+  // An optional event which transmits information about a device's state.
+  //
+  // The "DEVICE_SIGNAL_" values may be observed on this event.
+  ::zx::event event{};
+};
+
+extern "C" const fidl_type_t 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 {
+  enum class Tag : fidl_union_tag_t {
+    kService = 0,
+    kFile = 1,
+    kDirectory = 2,
+    kPipe = 3,
+    kVmofile = 4,
+    kDevice = 5,
+    kTty = 6,
+    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+  };
+
+  NodeInfo();
+  ~NodeInfo();
+
+  NodeInfo(NodeInfo&& other) {
+    if (this != &other) {
+      MoveImpl_(std::move(other));
+    }
+  }
+
+  NodeInfo& operator=(NodeInfo&& other) {
+    if (this != &other) {
+      MoveImpl_(std::move(other));
+    }
+    return *this;
+  }
+
+  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }
+
+  bool is_service() const { return tag_ == Tag::kService; }
+
+  Service& mutable_service() {
+    if (which() != Tag::kService) {
+      Destroy();
+    }
+    tag_ = Tag::kService;
+    return service_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Service>::value && std::is_copy_assignable<T>::value>
+  set_service(const T& v) {
+    mutable_service() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Service>::value && std::is_move_assignable<T>::value>
+  set_service(T&& v) {
+    mutable_service() = std::move(v);
+  }
+
+  Service const & service() const { return service_; }
+
+  bool is_file() const { return tag_ == Tag::kFile; }
+
+  FileObject& mutable_file() {
+    if (which() != Tag::kFile) {
+      Destroy();
+    }
+    tag_ = Tag::kFile;
+    return file_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, FileObject>::value && std::is_copy_assignable<T>::value>
+  set_file(const T& v) {
+    mutable_file() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, FileObject>::value && std::is_move_assignable<T>::value>
+  set_file(T&& v) {
+    mutable_file() = std::move(v);
+  }
+
+  FileObject const & file() const { return file_; }
+
+  bool is_directory() const { return tag_ == Tag::kDirectory; }
+
+  DirectoryObject& mutable_directory() {
+    if (which() != Tag::kDirectory) {
+      Destroy();
+    }
+    tag_ = Tag::kDirectory;
+    return directory_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, DirectoryObject>::value && std::is_copy_assignable<T>::value>
+  set_directory(const T& v) {
+    mutable_directory() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, DirectoryObject>::value && std::is_move_assignable<T>::value>
+  set_directory(T&& v) {
+    mutable_directory() = std::move(v);
+  }
+
+  DirectoryObject const & directory() const { return directory_; }
+
+  bool is_pipe() const { return tag_ == Tag::kPipe; }
+
+  Pipe& mutable_pipe() {
+    if (which() != Tag::kPipe) {
+      Destroy();
+    }
+    tag_ = Tag::kPipe;
+    return pipe_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Pipe>::value && std::is_copy_assignable<T>::value>
+  set_pipe(const T& v) {
+    mutable_pipe() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Pipe>::value && std::is_move_assignable<T>::value>
+  set_pipe(T&& v) {
+    mutable_pipe() = std::move(v);
+  }
+
+  Pipe const & pipe() const { return pipe_; }
+
+  bool is_vmofile() const { return tag_ == Tag::kVmofile; }
+
+  Vmofile& mutable_vmofile() {
+    if (which() != Tag::kVmofile) {
+      Destroy();
+    }
+    tag_ = Tag::kVmofile;
+    return vmofile_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Vmofile>::value && std::is_copy_assignable<T>::value>
+  set_vmofile(const T& v) {
+    mutable_vmofile() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Vmofile>::value && std::is_move_assignable<T>::value>
+  set_vmofile(T&& v) {
+    mutable_vmofile() = std::move(v);
+  }
+
+  Vmofile const & vmofile() const { return vmofile_; }
+
+  bool is_device() const { return tag_ == Tag::kDevice; }
+
+  Device& mutable_device() {
+    if (which() != Tag::kDevice) {
+      Destroy();
+    }
+    tag_ = Tag::kDevice;
+    return device_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Device>::value && std::is_copy_assignable<T>::value>
+  set_device(const T& v) {
+    mutable_device() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Device>::value && std::is_move_assignable<T>::value>
+  set_device(T&& v) {
+    mutable_device() = std::move(v);
+  }
+
+  Device const & device() const { return device_; }
+
+  bool is_tty() const { return tag_ == Tag::kTty; }
+
+  Tty& mutable_tty() {
+    if (which() != Tag::kTty) {
+      Destroy();
+    }
+    tag_ = Tag::kTty;
+    return tty_;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Tty>::value && std::is_copy_assignable<T>::value>
+  set_tty(const T& v) {
+    mutable_tty() = v;
+  }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, Tty>::value && std::is_move_assignable<T>::value>
+  set_tty(T&& v) {
+    mutable_tty() = std::move(v);
+  }
+
+  Tty const & tty() const { return tty_; }
+
+  Tag which() const { return tag_; }
+
+  static constexpr const fidl_type_t* Type = &fuchsia_io_NodeInfoTable;
+  static constexpr uint32_t MaxNumHandles = 1;
+  static constexpr uint32_t PrimarySize = 32;
+  [[maybe_unused]]
+  static constexpr uint32_t MaxOutOfLine = 0;
+
+ private:
+  void Destroy();
+  void MoveImpl_(NodeInfo&& other);
+  static void SizeAndOffsetAssertionHelper();
+  Tag tag_;
+  union {
+    Service service_;
+    FileObject file_;
+    DirectoryObject directory_;
+    Pipe pipe_;
+    Vmofile vmofile_;
+    Device device_;
+    Tty tty_;
+  };
+};
+
+extern "C" const fidl_type_t fuchsia_io_NodeCloneRequestTable;
+extern "C" const fidl_type_t fuchsia_io_NodeDescribeResponseTable;
+extern "C" const fidl_type_t fuchsia_io_NodeOnOpenEventTable;
+extern "C" const fidl_type_t fuchsia_io_NodeIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_NodeIoctlResponseTable;
+
+// Node defines the minimal interface for entities which can be accessed in a filesystem.
+class Node final {
+ public:
+
+  struct CloneRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    ::zx::channel object;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_NodeCloneRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+
+  struct CloseResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+  struct DescribeResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    NodeInfo info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_NodeDescribeResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+  struct OnOpenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeInfo* info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_NodeOnOpenEventTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 32;
+  };
+  struct SyncResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+  struct SetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SetAttrRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SetAttrResponse;
+  };
+
+  struct IoctlResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> out;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_NodeIoctlResponseTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+  };
+  struct IoctlRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t opcode;
+    uint64_t max_out;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> in;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_NodeIoctlRequestTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 64;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+    using ResponseType = IoctlResponse;
+  };
+
+
+  class SyncClient final {
+   public:
+    SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+    ~SyncClient() {}
+
+    // 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Clone(::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Clone(::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    zx_status_t Close(int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Close(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<CloseResponse> 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.
+    zx_status_t Describe(NodeInfo* out_info);
+
+    // 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.
+    zx_status_t Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<DescribeResponse> Describe(::fidl::BytePart response_buffer);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    zx_status_t Sync(int32_t* out_s);
+
+    // 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.
+    zx_status_t Sync(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SyncResponse> Sync(::fidl::BytePart response_buffer);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    zx_status_t GetAttr(int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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.
+    zx_status_t GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetAttrResponse> 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.
+    zx_status_t SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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.
+    zx_status_t SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SetAttrResponse> SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<IoctlResponse> Ioctl(::fidl::DecodedMessage<IoctlRequest> params, ::fidl::BytePart response_buffer);
+
+   private:
+    ::zx::channel channel_;
+  };
+
+  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
+  class Call final {
+   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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    static zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    static zx_status_t Close(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Describe(zx::unowned_channel _client_end, NodeInfo* out_info);
+
+    // 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 zx_status_t Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Sync(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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 zx_status_t GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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 zx_status_t SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<IoctlResponse> Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> 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(NodeInfo info);
+      void Reply(::fidl::BytePart _buffer, 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, NodeAttributes attributes);
+      void Reply(::fidl::BytePart _buffer, int32_t s, 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, NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+    class IoctlCompleterBase : public _Base {
+     public:
+      void Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::DecodedMessage<IoctlResponse> params);
+
+     protected:
+      using ::fidl::CompleterBase::CompleterBase;
+    };
+
+    using IoctlCompleter = ::fidl::Completer<IoctlCompleterBase>;
+
+    virtual void Ioctl(uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, IoctlCompleter::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, 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, 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);
+
+};
+
+extern "C" const fidl_type_t fuchsia_io_FileCloneRequestTable;
+extern "C" const fidl_type_t fuchsia_io_FileDescribeResponseTable;
+extern "C" const fidl_type_t fuchsia_io_FileOnOpenEventTable;
+extern "C" const fidl_type_t fuchsia_io_FileIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_FileIoctlResponseTable;
+extern "C" const fidl_type_t fuchsia_io_FileReadResponseTable;
+extern "C" const fidl_type_t fuchsia_io_FileReadAtResponseTable;
+extern "C" const fidl_type_t fuchsia_io_FileWriteRequestTable;
+extern "C" const fidl_type_t fuchsia_io_FileWriteAtRequestTable;
+extern "C" const fidl_type_t fuchsia_io_FileGetBufferResponseTable;
+
+// File defines the interface of a node which contains a flat layout of data.
+class File final {
+ public:
+
+  struct CloneRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    ::zx::channel object;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileCloneRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+
+  struct CloseResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+  struct DescribeResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    NodeInfo info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileDescribeResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+  struct OnOpenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeInfo* info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileOnOpenEventTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 32;
+  };
+  struct SyncResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+  struct SetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SetAttrRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SetAttrResponse;
+  };
+
+  struct IoctlResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> out;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileIoctlResponseTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+  };
+  struct IoctlRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t opcode;
+    uint64_t max_out;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> in;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileIoctlRequestTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 64;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+    using ResponseType = IoctlResponse;
+  };
+
+  struct ReadResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<uint8_t> data;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileReadResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+  };
+  struct ReadRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint64_t count;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = ReadResponse;
+  };
+
+  struct ReadAtResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<uint8_t> data;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileReadAtResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+  };
+  struct ReadAtRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint64_t count;
+    uint64_t offset;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = ReadAtResponse;
+  };
+
+  struct WriteResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    uint64_t actual;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct WriteRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::fidl::VectorView<uint8_t> data;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileWriteRequestTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = WriteResponse;
+  };
+
+  struct WriteAtResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    uint64_t actual;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct WriteAtRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::fidl::VectorView<uint8_t> data;
+    uint64_t offset;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileWriteAtRequestTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = WriteAtResponse;
+  };
+
+  struct SeekResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    uint64_t offset;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SeekRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int64_t offset;
+    SeekOrigin start;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SeekResponse;
+  };
+
+  struct TruncateResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct TruncateRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint64_t length;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = TruncateResponse;
+  };
+
+  struct GetFlagsResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    uint32_t flags;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+  struct SetFlagsResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SetFlagsRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SetFlagsResponse;
+  };
+
+  struct GetBufferResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fuchsia::mem::Buffer* buffer;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_FileGetBufferResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 16;
+  };
+  struct GetBufferRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = GetBufferResponse;
+  };
+
+
+  class SyncClient final {
+   public:
+    SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+    ~SyncClient() {}
+
+    // 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Clone(::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Clone(::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    zx_status_t Close(int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Close(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<CloseResponse> 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.
+    zx_status_t Describe(NodeInfo* out_info);
+
+    // 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.
+    zx_status_t Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<DescribeResponse> Describe(::fidl::BytePart response_buffer);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    zx_status_t Sync(int32_t* out_s);
+
+    // 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.
+    zx_status_t Sync(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SyncResponse> Sync(::fidl::BytePart response_buffer);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    zx_status_t GetAttr(int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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.
+    zx_status_t GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetAttrResponse> 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.
+    zx_status_t SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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.
+    zx_status_t SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SetAttrResponse> SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<IoctlResponse> Ioctl(::fidl::DecodedMessage<IoctlRequest> 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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<ReadResponse> Read(::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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data);
+
+    // Reads 'count' bytes at the provided offset.
+    // Does not affect the seek offset.
+    //
+    // This method requires following rights: OPEN_RIGHT_READABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<ReadAtResponse> ReadAt(::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.
+    zx_status_t Write(::fidl::VectorView<uint8_t> data, int32_t* out_s, uint64_t* out_actual);
+
+    // 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.
+    zx_status_t Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<WriteResponse> Write(::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.
+    zx_status_t WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, int32_t* out_s, uint64_t* out_actual);
+
+    // 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.
+    zx_status_t WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual);
+
+    // Writes data to the provided offset.
+    // Does not affect the seek offset.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<WriteAtResponse> WriteAt(::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.
+    zx_status_t Seek(int64_t offset, SeekOrigin start, int32_t* out_s, uint64_t* out_offset);
+
+    // 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.
+    zx_status_t Seek(::fidl::BytePart _request_buffer, int64_t offset, SeekOrigin start, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_offset);
+
+    // Moves the offset at which the next invocation of |Read()| or |Write()| will
+    // occur.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SeekResponse> Seek(::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer);
+
+    // Shrinks the file size to 'length' bytes.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    zx_status_t Truncate(uint64_t length, int32_t* out_s);
+
+    // 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.
+    zx_status_t Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Shrinks the file size to 'length' bytes.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<TruncateResponse> Truncate(::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.
+    zx_status_t GetFlags(int32_t* out_s, uint32_t* out_flags);
+
+    // 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.
+    zx_status_t GetFlags(::fidl::BytePart _response_buffer, int32_t* out_s, uint32_t* out_flags);
+
+    // Acquires the Directory::Open rights and flags used to access this file.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetFlagsResponse> 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.
+    zx_status_t SetFlags(uint32_t flags, int32_t* out_s);
+
+    // 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.
+    zx_status_t SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SetFlagsResponse> SetFlags(::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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fuchsia::mem::Buffer** out_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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetBufferResponse> GetBuffer(::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer);
+
+   private:
+    ::zx::channel channel_;
+  };
+
+  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
+  class Call final {
+   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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    static zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    static zx_status_t Close(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Describe(zx::unowned_channel _client_end, NodeInfo* out_info);
+
+    // 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 zx_status_t Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Sync(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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 zx_status_t GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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 zx_status_t SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<IoctlResponse> Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> 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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Read(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t ReadAt(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_data);
+
+    // Reads 'count' bytes at the provided offset.
+    // Does not affect the seek offset.
+    //
+    // This method requires following rights: OPEN_RIGHT_READABLE.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Write(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, int32_t* out_s, uint64_t* out_actual);
+
+    // 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 zx_status_t Write(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t WriteAt(zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset, int32_t* out_s, uint64_t* out_actual);
+
+    // 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 zx_status_t WriteAt(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_actual);
+
+    // Writes data to the provided offset.
+    // Does not affect the seek offset.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Seek(zx::unowned_channel _client_end, int64_t offset, SeekOrigin start, int32_t* out_s, uint64_t* out_offset);
+
+    // 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 zx_status_t Seek(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, SeekOrigin start, ::fidl::BytePart _response_buffer, int32_t* out_s, uint64_t* out_offset);
+
+    // Moves the offset at which the next invocation of |Read()| or |Write()| will
+    // occur.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Truncate(zx::unowned_channel _client_end, uint64_t length, int32_t* out_s);
+
+    // 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 zx_status_t Truncate(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Shrinks the file size to 'length' bytes.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetFlags(zx::unowned_channel _client_end, int32_t* out_s, uint32_t* out_flags);
+
+    // 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 zx_status_t GetFlags(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, uint32_t* out_flags);
+
+    // Acquires the Directory::Open rights and flags used to access this file.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t SetFlags(zx::unowned_channel _client_end, uint32_t flags, int32_t* out_s);
+
+    // 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 zx_status_t SetFlags(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t GetBuffer(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fuchsia::mem::Buffer** out_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.
+    // Messages are encoded and decoded in-place.
+    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(NodeInfo info);
+      void Reply(::fidl::BytePart _buffer, 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, NodeAttributes attributes);
+      void Reply(::fidl::BytePart _buffer, int32_t s, 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, NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+    class IoctlCompleterBase : public _Base {
+     public:
+      void Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::DecodedMessage<IoctlResponse> params);
+
+     protected:
+      using ::fidl::CompleterBase::CompleterBase;
+    };
+
+    using IoctlCompleter = ::fidl::Completer<IoctlCompleterBase>;
+
+    virtual void Ioctl(uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, IoctlCompleter::Sync _completer) = 0;
+
+    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, 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, ::fuchsia::mem::Buffer* buffer);
+      void Reply(::fidl::BytePart _buffer, int32_t s, ::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, 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, 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);
+
+};
+
+extern "C" const fidl_type_t fuchsia_io_DirectoryCloneRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryDescribeResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryOnOpenEventTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryIoctlResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryOpenRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryUnlinkRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryReadDirentsResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryGetTokenResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryRenameRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryLinkRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryWatchRequestTable;
+
+// Directory defines a node which is capable of containing other Objects.
+class Directory final {
+ public:
+
+  struct CloneRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    ::zx::channel object;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryCloneRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+
+  struct CloseResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+  struct DescribeResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    NodeInfo info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryDescribeResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+  struct OnOpenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeInfo* info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryOnOpenEventTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 32;
+  };
+  struct SyncResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+  struct SetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SetAttrRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SetAttrResponse;
+  };
+
+  struct IoctlResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> out;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryIoctlResponseTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+  };
+  struct IoctlRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t opcode;
+    uint64_t max_out;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> in;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryIoctlRequestTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 64;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+    using ResponseType = IoctlResponse;
+  };
+
+  struct OpenRequest {
+    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 = &fuchsia_io_DirectoryOpenRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 4096;
+  };
+
+  struct UnlinkResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct UnlinkRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::fidl::StringView path;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryUnlinkRequestTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 4096;
+    using ResponseType = UnlinkResponse;
+  };
+
+  struct ReadDirentsResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<uint8_t> dirents;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryReadDirentsResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+  };
+  struct ReadDirentsRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint64_t max_bytes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = ReadDirentsResponse;
+  };
+
+  struct RewindResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using RewindRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetTokenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::zx::handle token;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryGetTokenResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+  struct RenameResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct RenameRequest {
+    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 = &fuchsia_io_DirectoryRenameRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = RenameResponse;
+  };
+
+  struct LinkResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct LinkRequest {
+    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 = &fuchsia_io_DirectoryLinkRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = LinkResponse;
+  };
+
+  struct WatchResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct WatchRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t mask;
+    uint32_t options;
+    ::zx::channel watcher;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryWatchRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = WatchResponse;
+  };
+
+
+  class SyncClient final {
+   public:
+    SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+    ~SyncClient() {}
+
+    // 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Clone(::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Clone(::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    zx_status_t Close(int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Close(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<CloseResponse> 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.
+    zx_status_t Describe(NodeInfo* out_info);
+
+    // 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.
+    zx_status_t Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<DescribeResponse> Describe(::fidl::BytePart response_buffer);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    zx_status_t Sync(int32_t* out_s);
+
+    // 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.
+    zx_status_t Sync(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SyncResponse> Sync(::fidl::BytePart response_buffer);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    zx_status_t GetAttr(int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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.
+    zx_status_t GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetAttrResponse> 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.
+    zx_status_t SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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.
+    zx_status_t SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SetAttrResponse> SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<IoctlResponse> Ioctl(::fidl::DecodedMessage<IoctlRequest> 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_RIGHTS_* 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.
+    zx_status_t 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_RIGHTS_* 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.
+    zx_status_t Open(::fidl::BytePart _request_buffer, 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_RIGHTS_* 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.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Open(::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.
+    zx_status_t Unlink(::fidl::StringView path, int32_t* out_s);
+
+    // 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.
+    zx_status_t Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<UnlinkResponse> Unlink(::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.
+    //   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.
+    zx_status_t ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents);
+
+    // 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.
+    //   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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    zx_status_t Rewind(int32_t* out_s);
+
+    // 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.
+    zx_status_t Rewind(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<RewindResponse> 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.
+    zx_status_t GetToken(int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    zx_status_t GetToken(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetTokenResponse> 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.
+    zx_status_t Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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.
+    zx_status_t Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<RenameResponse> Rename(::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.
+    zx_status_t Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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.
+    zx_status_t Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<LinkResponse> Link(::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.
+    //
+    // TODO: 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.
+    zx_status_t Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    zx_status_t Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<WatchResponse> Watch(::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);
+
+   private:
+    ::zx::channel channel_;
+  };
+
+  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
+  class Call final {
+   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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    static zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    static zx_status_t Close(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Describe(zx::unowned_channel _client_end, NodeInfo* out_info);
+
+    // 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 zx_status_t Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Sync(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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 zx_status_t GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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 zx_status_t SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<IoctlResponse> Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> 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_RIGHTS_* 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 zx_status_t 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_RIGHTS_* 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 zx_status_t Open(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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_RIGHTS_* 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.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t 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 zx_status_t Unlink(zx::unowned_channel _client_end, ::fidl::StringView path, int32_t* out_s);
+
+    // 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 zx_status_t Unlink(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    //   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 zx_status_t ReadDirents(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents);
+
+    // 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.
+    //   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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Rewind(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Rewind(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetToken(zx::unowned_channel _client_end, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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 zx_status_t GetToken(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Rename(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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 zx_status_t 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, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Link(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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 zx_status_t 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, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    //
+    // TODO: 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 zx_status_t Watch(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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 zx_status_t Watch(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    // Messages are encoded and decoded in-place.
+    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(NodeInfo info);
+      void Reply(::fidl::BytePart _buffer, 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, NodeAttributes attributes);
+      void Reply(::fidl::BytePart _buffer, int32_t s, 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, NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+    class IoctlCompleterBase : public _Base {
+     public:
+      void Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::DecodedMessage<IoctlResponse> params);
+
+     protected:
+      using ::fidl::CompleterBase::CompleterBase;
+    };
+
+    using IoctlCompleter = ::fidl::Completer<IoctlCompleterBase>;
+
+    virtual void Ioctl(uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, IoctlCompleter::Sync _completer) = 0;
+
+    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, 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, 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);
+
+};
+
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminCloneRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminDescribeResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminOnOpenEventTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminIoctlRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminIoctlResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminOpenRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminUnlinkRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminGetTokenResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminRenameRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminLinkRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminWatchRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminMountRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+extern "C" const fidl_type_t fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+
+// DirectoryAdmin defines a directory which is capable of handling
+// administrator tasks within the filesystem.
+class DirectoryAdmin final {
+ public:
+
+  struct CloneRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    ::zx::channel object;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminCloneRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+
+  struct CloseResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+  struct DescribeResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    NodeInfo info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminDescribeResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+  struct OnOpenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeInfo* info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminOnOpenEventTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 32;
+  };
+  struct SyncResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+  struct SetAttrResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct SetAttrRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t flags;
+    NodeAttributes attributes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 80;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = SetAttrResponse;
+  };
+
+  struct IoctlResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> out;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminIoctlResponseTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+  };
+  struct IoctlRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t opcode;
+    uint64_t max_out;
+    ::fidl::VectorView<::zx::handle> handles;
+    ::fidl::VectorView<uint8_t> in;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminIoctlRequestTable;
+    static constexpr uint32_t MaxNumHandles = 2;
+    static constexpr uint32_t PrimarySize = 64;
+    static constexpr uint32_t MaxOutOfLine = 8200;
+    using ResponseType = IoctlResponse;
+  };
+
+  struct OpenRequest {
+    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 = &fuchsia_io_DirectoryAdminOpenRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 4096;
+  };
+
+  struct UnlinkResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct UnlinkRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::fidl::StringView path;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminUnlinkRequestTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 4096;
+    using ResponseType = UnlinkResponse;
+  };
+
+  struct ReadDirentsResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::VectorView<uint8_t> dirents;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+  };
+  struct ReadDirentsRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint64_t max_bytes;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = ReadDirentsResponse;
+  };
+
+  struct RewindResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using RewindRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetTokenResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::zx::handle token;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminGetTokenResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+  struct RenameResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct RenameRequest {
+    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 = &fuchsia_io_DirectoryAdminRenameRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = RenameResponse;
+  };
+
+  struct LinkResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct LinkRequest {
+    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 = &fuchsia_io_DirectoryAdminLinkRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 56;
+    static constexpr uint32_t MaxOutOfLine = 8192;
+    using ResponseType = LinkResponse;
+  };
+
+  struct WatchResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct WatchRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    uint32_t mask;
+    uint32_t options;
+    ::zx::channel watcher;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminWatchRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = WatchResponse;
+  };
+
+  struct MountResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct MountRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::zx::channel remote;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminMountRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+    using ResponseType = MountResponse;
+  };
+
+  struct MountAndCreateResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  struct MountAndCreateRequest {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    ::zx::channel remote;
+    ::fidl::StringView name;
+    uint32_t flags;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 48;
+    static constexpr uint32_t MaxOutOfLine = 256;
+    using ResponseType = MountAndCreateResponse;
+  };
+
+  struct UnmountResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+
+    static constexpr const fidl_type_t* Type = nullptr;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using UnmountRequest = ::fidl::AnyZeroArgMessage;
+
+  struct UnmountNodeResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::zx::channel remote;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+    static constexpr uint32_t MaxNumHandles = 1;
+    static constexpr uint32_t PrimarySize = 24;
+    static constexpr uint32_t MaxOutOfLine = 0;
+  };
+  using UnmountNodeRequest = ::fidl::AnyZeroArgMessage;
+
+  struct QueryFilesystemResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    FilesystemInfo* info;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 32;
+    static constexpr uint32_t MaxOutOfLine = 96;
+  };
+  using QueryFilesystemRequest = ::fidl::AnyZeroArgMessage;
+
+  struct GetDevicePathResponse {
+    FIDL_ALIGNDECL
+    fidl_message_header_t _hdr;
+    int32_t s;
+    ::fidl::StringView path;
+
+    static constexpr const fidl_type_t* Type = &fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+    static constexpr uint32_t MaxNumHandles = 0;
+    static constexpr uint32_t PrimarySize = 40;
+    static constexpr uint32_t MaxOutOfLine = 4096;
+  };
+  using GetDevicePathRequest = ::fidl::AnyZeroArgMessage;
+
+
+  class SyncClient final {
+   public:
+    SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
+
+    ~SyncClient() {}
+
+    // 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Clone(::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Clone(::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    zx_status_t Close(int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Close(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<CloseResponse> 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.
+    zx_status_t Describe(NodeInfo* out_info);
+
+    // 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.
+    zx_status_t Describe(::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<DescribeResponse> Describe(::fidl::BytePart response_buffer);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    zx_status_t Sync(int32_t* out_s);
+
+    // 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.
+    zx_status_t Sync(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SyncResponse> Sync(::fidl::BytePart response_buffer);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    zx_status_t GetAttr(int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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.
+    zx_status_t GetAttr(::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetAttrResponse> 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.
+    zx_status_t SetAttr(uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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.
+    zx_status_t SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<SetAttrResponse> SetAttr(::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t Ioctl(::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<IoctlResponse> Ioctl(::fidl::DecodedMessage<IoctlRequest> 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_RIGHTS_* 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.
+    zx_status_t 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_RIGHTS_* 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.
+    zx_status_t Open(::fidl::BytePart _request_buffer, 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_RIGHTS_* 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.
+    // Messages are encoded and decoded in-place.
+    zx_status_t Open(::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.
+    zx_status_t Unlink(::fidl::StringView path, int32_t* out_s);
+
+    // 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.
+    zx_status_t Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<UnlinkResponse> Unlink(::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.
+    //   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.
+    zx_status_t ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents);
+
+    // 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.
+    //   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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    zx_status_t Rewind(int32_t* out_s);
+
+    // 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.
+    zx_status_t Rewind(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<RewindResponse> 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.
+    zx_status_t GetToken(int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    zx_status_t GetToken(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetTokenResponse> 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.
+    zx_status_t Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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.
+    zx_status_t Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<RenameResponse> Rename(::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.
+    zx_status_t Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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.
+    zx_status_t Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<LinkResponse> Link(::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.
+    //
+    // TODO: 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.
+    zx_status_t Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    zx_status_t Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<WatchResponse> Watch(::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.
+    zx_status_t Mount(::zx::channel remote, int32_t* out_s);
+
+    // 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.
+    zx_status_t Mount(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<MountResponse> Mount(::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.
+    zx_status_t MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags, int32_t* out_s);
+
+    // 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.
+    zx_status_t MountAndCreate(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Atomically create a directory with a provided path, and mount the
+    // remote handle to the newly created directory.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<MountAndCreateResponse> MountAndCreate(::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer);
+
+    // Unmount this filesystem. After this function returns successfully,
+    // all connections to the filesystem will be terminated.
+    zx_status_t Unmount(int32_t* out_s);
+
+    // 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.
+    zx_status_t Unmount(::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Unmount this filesystem. After this function returns successfully,
+    // all connections to the filesystem will be terminated.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<UnmountResponse> Unmount(::fidl::BytePart response_buffer);
+
+    // Detach a node which was previously attached to this directory
+    // with Mount.
+    zx_status_t UnmountNode(int32_t* out_s, ::zx::channel* out_remote);
+
+    // 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.
+    zx_status_t UnmountNode(::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::channel* out_remote);
+
+    // Detach a node which was previously attached to this directory
+    // with Mount.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<UnmountNodeResponse> UnmountNode(::fidl::BytePart response_buffer);
+
+
+    // Query the filesystem for filesystem-specific information.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    zx_status_t QueryFilesystem(::fidl::BytePart _response_buffer, int32_t* out_s, FilesystemInfo** out_info);
+
+    // Query the filesystem for filesystem-specific information.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<QueryFilesystemResponse> QueryFilesystem(::fidl::BytePart response_buffer);
+
+
+    // 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.
+    zx_status_t GetDevicePath(::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::StringView* out_path);
+
+    // Acquire the path to the device backing this filesystem, if there is one.
+    // Messages are encoded and decoded in-place.
+    ::fidl::DecodeResult<GetDevicePathResponse> GetDevicePath(::fidl::BytePart response_buffer);
+
+   private:
+    ::zx::channel channel_;
+  };
+
+  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
+  class Call final {
+   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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    static zx_status_t 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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.
+    //
+    // TODO(ZX-3676): |flags| should restrict the rights on the resulting cloned object.
+    // The cloned object must have rights less than or equal to the original object.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t Clone(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    static zx_status_t Close(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Close(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Terminates connection with object.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Describe(zx::unowned_channel _client_end, NodeInfo* out_info);
+
+    // 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 zx_status_t Describe(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, NodeInfo* out_info);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Sync(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Sync(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Synchronizes updates to the node to the underlying media, if it exists.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetAttr(zx::unowned_channel _client_end, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // 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 zx_status_t GetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, NodeAttributes* out_attributes);
+
+    // Acquires information about the node.
+    //
+    // This method does not require any rights.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t SetAttr(zx::unowned_channel _client_end, uint32_t flags, NodeAttributes attributes, int32_t* out_s);
+
+    // 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 zx_status_t SetAttr(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, NodeAttributes attributes, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Updates information about the node.
+    // |flags| may be any of NODE_ATTRIBUTE_FLAG_*.
+    //
+    // This method requires following rights: OPEN_RIGHT_WRITABLE.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<SetAttrResponse> SetAttr(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t Ioctl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<::zx::handle>* out_handles, ::fidl::VectorView<uint8_t>* out_out);
+
+    // Deprecated. Only for use with compatibility with devhost.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<IoctlResponse> Ioctl(zx::unowned_channel _client_end, ::fidl::DecodedMessage<IoctlRequest> 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_RIGHTS_* 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 zx_status_t 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_RIGHTS_* 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 zx_status_t Open(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, 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_RIGHTS_* 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.
+    // Messages are encoded and decoded in-place.
+    static zx_status_t 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 zx_status_t Unlink(zx::unowned_channel _client_end, ::fidl::StringView path, int32_t* out_s);
+
+    // 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 zx_status_t Unlink(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    //   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 zx_status_t ReadDirents(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::VectorView<uint8_t>* out_dirents);
+
+    // 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.
+    //   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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Rewind(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Rewind(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Resets the directory seek offset.
+    //
+    // This method does not require any rights, similar to ReadDirents.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t GetToken(zx::unowned_channel _client_end, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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 zx_status_t GetToken(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::handle* out_token);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Rename(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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 zx_status_t 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, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Link(zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, int32_t* out_s);
+
+    // 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 zx_status_t 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, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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.
+    //
+    // TODO: 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 zx_status_t Watch(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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 zx_status_t Watch(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    //
+    // TODO: 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Mount(zx::unowned_channel _client_end, ::zx::channel remote, int32_t* out_s);
+
+    // 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 zx_status_t Mount(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // 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.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t MountAndCreate(zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, int32_t* out_s);
+
+    // 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 zx_status_t MountAndCreate(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Atomically create a directory with a provided path, and mount the
+    // remote handle to the newly created directory.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t Unmount(zx::unowned_channel _client_end, int32_t* out_s);
+
+    // 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 zx_status_t Unmount(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s);
+
+    // Unmount this filesystem. After this function returns successfully,
+    // all connections to the filesystem will be terminated.
+    // Messages are encoded and decoded in-place.
+    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 zx_status_t UnmountNode(zx::unowned_channel _client_end, int32_t* out_s, ::zx::channel* out_remote);
+
+    // 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 zx_status_t UnmountNode(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::zx::channel* out_remote);
+
+    // Detach a node which was previously attached to this directory
+    // with Mount.
+    // Messages are encoded and decoded in-place.
+    static ::fidl::DecodeResult<UnmountNodeResponse> UnmountNode(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+
+    // Query the filesystem for filesystem-specific information.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t QueryFilesystem(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, FilesystemInfo** out_info);
+
+    // Query the filesystem for filesystem-specific information.
+    // Messages are encoded and decoded in-place.
+    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.
+    // Caller provides the backing storage for FIDL message via request and response buffers.
+    static zx_status_t GetDevicePath(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer, int32_t* out_s, ::fidl::StringView* out_path);
+
+    // Acquire the path to the device backing this filesystem, if there is one.
+    // Messages are encoded and decoded in-place.
+    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(NodeInfo info);
+      void Reply(::fidl::BytePart _buffer, 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, NodeAttributes attributes);
+      void Reply(::fidl::BytePart _buffer, int32_t s, 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, NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+    class IoctlCompleterBase : public _Base {
+     public:
+      void Reply(int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> out);
+      void Reply(::fidl::DecodedMessage<IoctlResponse> params);
+
+     protected:
+      using ::fidl::CompleterBase::CompleterBase;
+    };
+
+    using IoctlCompleter = ::fidl::Completer<IoctlCompleterBase>;
+
+    virtual void Ioctl(uint32_t opcode, uint64_t max_out, ::fidl::VectorView<::zx::handle> handles, ::fidl::VectorView<uint8_t> in, IoctlCompleter::Sync _completer) = 0;
+
+    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, FilesystemInfo* info);
+      void Reply(::fidl::BytePart _buffer, int32_t s, 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, 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, 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);
+
+};
+
+// A dirent with an unknown type.
+constexpr uint8_t DIRENT_TYPE_UNKNOWN = 0;
+
+// A dirent representing a socket object.
+constexpr uint8_t DIRENT_TYPE_SOCKET = 12;
+
+// A dirent representing a service object.
+constexpr uint8_t DIRENT_TYPE_SERVICE = 16;
+
+// A dirent representing a file object.
+constexpr uint8_t DIRENT_TYPE_FILE = 8;
+
+// A dirent representing a directory object.
+constexpr uint8_t DIRENT_TYPE_DIRECTORY = 4;
+
+// A dirent representing a block device object.
+constexpr uint8_t DIRENT_TYPE_BLOCK_DEVICE = 6;
+
+// Indicates the device is ready for writing.
+constexpr uint32_t DEVICE_SIGNAL_WRITABLE = 0x02000000;
+
+// Indicates the device is ready for reading.
+constexpr uint32_t DEVICE_SIGNAL_READABLE = 0x01000000;
+
+// Indicates an out-of-band state transition has occurred.
+constexpr uint32_t DEVICE_SIGNAL_OOB = 0x10000000;
+
+// Indicates the device has hung up on the current connection.
+constexpr uint32_t DEVICE_SIGNAL_HANGUP = 0x08000000;
+
+// Indicates the device has encountered an error state.
+constexpr uint32_t DEVICE_SIGNAL_ERROR = 0x04000000;
+
+// 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_FLAGS_SAME_RIGHTS.
+constexpr uint32_t CLONE_FLAG_SAME_RIGHTS = 0x04000000;
+
+}  // namespace io
+}  // namespace fuchsia
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::fuchsia::io::WatchedEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::WatchedEvent>);
+static_assert(offsetof(::fuchsia::io::WatchedEvent, event) == 0);
+static_assert(offsetof(::fuchsia::io::WatchedEvent, len) == 1);
+static_assert(offsetof(::fuchsia::io::WatchedEvent, name) == 8);
+static_assert(sizeof(::fuchsia::io::WatchedEvent) == ::fuchsia::io::WatchedEvent::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::Vmofile> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::Vmofile>);
+static_assert(offsetof(::fuchsia::io::Vmofile, vmo) == 0);
+static_assert(offsetof(::fuchsia::io::Vmofile, offset) == 8);
+static_assert(offsetof(::fuchsia::io::Vmofile, length) == 16);
+static_assert(sizeof(::fuchsia::io::Vmofile) == ::fuchsia::io::Vmofile::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::Tty> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::Tty>);
+static_assert(offsetof(::fuchsia::io::Tty, event) == 0);
+static_assert(sizeof(::fuchsia::io::Tty) == ::fuchsia::io::Tty::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryWatcher::OnEventRequest)
+    == ::fuchsia::io::DirectoryWatcher::OnEventRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryWatcher::OnEventRequest, events) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Service> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::Service>);
+static_assert(offsetof(::fuchsia::io::Service, __reserved) == 0);
+static_assert(sizeof(::fuchsia::io::Service) == ::fuchsia::io::Service::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::Pipe> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::Pipe>);
+static_assert(offsetof(::fuchsia::io::Pipe, socket) == 0);
+static_assert(sizeof(::fuchsia::io::Pipe) == ::fuchsia::io::Pipe::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::NodeAttributes> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::NodeAttributes>);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, mode) == 0);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, id) == 8);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, content_size) == 16);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, storage_size) == 24);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, link_count) == 32);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, creation_time) == 40);
+static_assert(offsetof(::fuchsia::io::NodeAttributes, modification_time) == 48);
+static_assert(sizeof(::fuchsia::io::NodeAttributes) == ::fuchsia::io::NodeAttributes::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::FilesystemInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::FilesystemInfo>);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, total_bytes) == 0);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, used_bytes) == 8);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, total_nodes) == 16);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, used_nodes) == 24);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, free_shared_pool_bytes) == 32);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, fs_id) == 40);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, block_size) == 48);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, max_filename_size) == 52);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, fs_type) == 56);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, padding) == 60);
+static_assert(offsetof(::fuchsia::io::FilesystemInfo, name) == 64);
+static_assert(sizeof(::fuchsia::io::FilesystemInfo) == ::fuchsia::io::FilesystemInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::FileObject> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::FileObject>);
+static_assert(offsetof(::fuchsia::io::FileObject, event) == 0);
+static_assert(sizeof(::fuchsia::io::FileObject) == ::fuchsia::io::FileObject::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryObject> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::DirectoryObject>);
+static_assert(offsetof(::fuchsia::io::DirectoryObject, __reserved) == 0);
+static_assert(sizeof(::fuchsia::io::DirectoryObject) == ::fuchsia::io::DirectoryObject::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::Device> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::Device>);
+static_assert(offsetof(::fuchsia::io::Device, event) == 0);
+static_assert(sizeof(::fuchsia::io::Device) == ::fuchsia::io::Device::PrimarySize);
+
+template <>
+struct IsFidlType<::fuchsia::io::NodeInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::fuchsia::io::NodeInfo>);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::CloneRequest)
+    == ::fuchsia::io::Node::CloneRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::CloneRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::Node::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::CloseResponse)
+    == ::fuchsia::io::Node::CloseResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::DescribeResponse)
+    == ::fuchsia::io::Node::DescribeResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::OnOpenResponse)
+    == ::fuchsia::io::Node::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::OnOpenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Node::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::SyncResponse)
+    == ::fuchsia::io::Node::SyncResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::GetAttrResponse)
+    == ::fuchsia::io::Node::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::GetAttrResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Node::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::SetAttrRequest)
+    == ::fuchsia::io::Node::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::Node::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::SetAttrResponse)
+    == ::fuchsia::io::Node::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::IoctlRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::IoctlRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::IoctlRequest)
+    == ::fuchsia::io::Node::IoctlRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::IoctlRequest, opcode) == 16);
+static_assert(offsetof(::fuchsia::io::Node::IoctlRequest, max_out) == 24);
+static_assert(offsetof(::fuchsia::io::Node::IoctlRequest, handles) == 32);
+static_assert(offsetof(::fuchsia::io::Node::IoctlRequest, in) == 48);
+
+template <>
+struct IsFidlType<::fuchsia::io::Node::IoctlResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Node::IoctlResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Node::IoctlResponse)
+    == ::fuchsia::io::Node::IoctlResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Node::IoctlResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Node::IoctlResponse, handles) == 24);
+static_assert(offsetof(::fuchsia::io::Node::IoctlResponse, out) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::CloneRequest)
+    == ::fuchsia::io::File::CloneRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::CloneRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::File::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::CloseResponse)
+    == ::fuchsia::io::File::CloseResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::DescribeResponse)
+    == ::fuchsia::io::File::DescribeResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::OnOpenResponse)
+    == ::fuchsia::io::File::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::OnOpenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SyncResponse)
+    == ::fuchsia::io::File::SyncResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::GetAttrResponse)
+    == ::fuchsia::io::File::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::GetAttrResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SetAttrRequest)
+    == ::fuchsia::io::File::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::File::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SetAttrResponse)
+    == ::fuchsia::io::File::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::IoctlRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::IoctlRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::IoctlRequest)
+    == ::fuchsia::io::File::IoctlRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::IoctlRequest, opcode) == 16);
+static_assert(offsetof(::fuchsia::io::File::IoctlRequest, max_out) == 24);
+static_assert(offsetof(::fuchsia::io::File::IoctlRequest, handles) == 32);
+static_assert(offsetof(::fuchsia::io::File::IoctlRequest, in) == 48);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::IoctlResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::IoctlResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::IoctlResponse)
+    == ::fuchsia::io::File::IoctlResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::IoctlResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::IoctlResponse, handles) == 24);
+static_assert(offsetof(::fuchsia::io::File::IoctlResponse, out) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::ReadRequest)
+    == ::fuchsia::io::File::ReadRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::ReadRequest, count) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::ReadResponse)
+    == ::fuchsia::io::File::ReadResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::ReadResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::ReadResponse, data) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::ReadAtRequest)
+    == ::fuchsia::io::File::ReadAtRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::ReadAtRequest, count) == 16);
+static_assert(offsetof(::fuchsia::io::File::ReadAtRequest, offset) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::ReadAtResponse)
+    == ::fuchsia::io::File::ReadAtResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::ReadAtResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::ReadAtResponse, data) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::WriteRequest)
+    == ::fuchsia::io::File::WriteRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::WriteRequest, data) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::WriteResponse)
+    == ::fuchsia::io::File::WriteResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::WriteResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::WriteResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::WriteAtRequest)
+    == ::fuchsia::io::File::WriteAtRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::WriteAtRequest, data) == 16);
+static_assert(offsetof(::fuchsia::io::File::WriteAtRequest, offset) == 32);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::WriteAtResponse)
+    == ::fuchsia::io::File::WriteAtResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::WriteAtResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::WriteAtResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SeekRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SeekRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SeekRequest)
+    == ::fuchsia::io::File::SeekRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SeekRequest, offset) == 16);
+static_assert(offsetof(::fuchsia::io::File::SeekRequest, start) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SeekResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SeekResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SeekResponse)
+    == ::fuchsia::io::File::SeekResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SeekResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::SeekResponse, offset) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::TruncateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::TruncateRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::TruncateRequest)
+    == ::fuchsia::io::File::TruncateRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::TruncateRequest, length) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::TruncateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::TruncateResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::TruncateResponse)
+    == ::fuchsia::io::File::TruncateResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::TruncateResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::GetFlagsResponse)
+    == ::fuchsia::io::File::GetFlagsResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::GetFlagsResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::GetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SetFlagsRequest)
+    == ::fuchsia::io::File::SetFlagsRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::SetFlagsResponse)
+    == ::fuchsia::io::File::SetFlagsResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::SetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::GetBufferRequest)
+    == ::fuchsia::io::File::GetBufferRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::GetBufferRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::File::GetBufferResponse)
+    == ::fuchsia::io::File::GetBufferResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::File::GetBufferResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::File::GetBufferResponse, buffer) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::CloneRequest)
+    == ::fuchsia::io::Directory::CloneRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::CloneRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::CloseResponse)
+    == ::fuchsia::io::Directory::CloseResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::DescribeResponse)
+    == ::fuchsia::io::Directory::DescribeResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::OnOpenResponse)
+    == ::fuchsia::io::Directory::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::OnOpenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::SyncResponse)
+    == ::fuchsia::io::Directory::SyncResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::GetAttrResponse)
+    == ::fuchsia::io::Directory::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::GetAttrResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::SetAttrRequest)
+    == ::fuchsia::io::Directory::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::SetAttrResponse)
+    == ::fuchsia::io::Directory::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::IoctlRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::IoctlRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::IoctlRequest)
+    == ::fuchsia::io::Directory::IoctlRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlRequest, opcode) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlRequest, max_out) == 24);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlRequest, handles) == 32);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlRequest, in) == 48);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::IoctlResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::IoctlResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::IoctlResponse)
+    == ::fuchsia::io::Directory::IoctlResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlResponse, handles) == 24);
+static_assert(offsetof(::fuchsia::io::Directory::IoctlResponse, out) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::OpenRequest)
+    == ::fuchsia::io::Directory::OpenRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::OpenRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::OpenRequest, mode) == 20);
+static_assert(offsetof(::fuchsia::io::Directory::OpenRequest, path) == 24);
+static_assert(offsetof(::fuchsia::io::Directory::OpenRequest, object) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::UnlinkRequest)
+    == ::fuchsia::io::Directory::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::UnlinkResponse)
+    == ::fuchsia::io::Directory::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::UnlinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::ReadDirentsRequest)
+    == ::fuchsia::io::Directory::ReadDirentsRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::ReadDirentsRequest, max_bytes) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::ReadDirentsResponse)
+    == ::fuchsia::io::Directory::ReadDirentsResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::ReadDirentsResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::ReadDirentsResponse, dirents) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::RewindResponse)
+    == ::fuchsia::io::Directory::RewindResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::RewindResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::GetTokenResponse)
+    == ::fuchsia::io::Directory::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::GetTokenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::GetTokenResponse, token) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::RenameRequest)
+    == ::fuchsia::io::Directory::RenameRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::RenameRequest, src) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::fuchsia::io::Directory::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::RenameResponse)
+    == ::fuchsia::io::Directory::RenameResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::RenameResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::LinkRequest)
+    == ::fuchsia::io::Directory::LinkRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::LinkRequest, src) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::fuchsia::io::Directory::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::LinkResponse)
+    == ::fuchsia::io::Directory::LinkResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::LinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::WatchRequest)
+    == ::fuchsia::io::Directory::WatchRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::WatchRequest, mask) == 16);
+static_assert(offsetof(::fuchsia::io::Directory::WatchRequest, options) == 20);
+static_assert(offsetof(::fuchsia::io::Directory::WatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::Directory::WatchResponse)
+    == ::fuchsia::io::Directory::WatchResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::Directory::WatchResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::CloneRequest)
+    == ::fuchsia::io::DirectoryAdmin::CloneRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::CloneRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::CloseResponse)
+    == ::fuchsia::io::DirectoryAdmin::CloseResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::DescribeResponse)
+    == ::fuchsia::io::DirectoryAdmin::DescribeResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::OnOpenResponse)
+    == ::fuchsia::io::DirectoryAdmin::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OnOpenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::SyncResponse)
+    == ::fuchsia::io::DirectoryAdmin::SyncResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::GetAttrResponse)
+    == ::fuchsia::io::DirectoryAdmin::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetAttrResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::SetAttrRequest)
+    == ::fuchsia::io::DirectoryAdmin::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::SetAttrResponse)
+    == ::fuchsia::io::DirectoryAdmin::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::IoctlRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::IoctlRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::IoctlRequest)
+    == ::fuchsia::io::DirectoryAdmin::IoctlRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlRequest, opcode) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlRequest, max_out) == 24);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlRequest, handles) == 32);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlRequest, in) == 48);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::IoctlResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::IoctlResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::IoctlResponse)
+    == ::fuchsia::io::DirectoryAdmin::IoctlResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlResponse, handles) == 24);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::IoctlResponse, out) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::OpenRequest)
+    == ::fuchsia::io::DirectoryAdmin::OpenRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OpenRequest, flags) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OpenRequest, mode) == 20);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OpenRequest, path) == 24);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::OpenRequest, object) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::UnlinkRequest)
+    == ::fuchsia::io::DirectoryAdmin::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::UnlinkResponse)
+    == ::fuchsia::io::DirectoryAdmin::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::UnlinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::ReadDirentsRequest)
+    == ::fuchsia::io::DirectoryAdmin::ReadDirentsRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::ReadDirentsRequest, max_bytes) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::ReadDirentsResponse)
+    == ::fuchsia::io::DirectoryAdmin::ReadDirentsResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, dirents) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::RewindResponse)
+    == ::fuchsia::io::DirectoryAdmin::RewindResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::RewindResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::GetTokenResponse)
+    == ::fuchsia::io::DirectoryAdmin::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetTokenResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetTokenResponse, token) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::RenameRequest)
+    == ::fuchsia::io::DirectoryAdmin::RenameRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::RenameRequest, src) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::RenameResponse)
+    == ::fuchsia::io::DirectoryAdmin::RenameResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::RenameResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::LinkRequest)
+    == ::fuchsia::io::DirectoryAdmin::LinkRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::LinkRequest, src) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::LinkResponse)
+    == ::fuchsia::io::DirectoryAdmin::LinkResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::LinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::WatchRequest)
+    == ::fuchsia::io::DirectoryAdmin::WatchRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::WatchRequest, mask) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::WatchRequest, options) == 20);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::WatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::WatchResponse)
+    == ::fuchsia::io::DirectoryAdmin::WatchResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::WatchResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::MountRequest)
+    == ::fuchsia::io::DirectoryAdmin::MountRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountRequest, remote) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::MountResponse)
+    == ::fuchsia::io::DirectoryAdmin::MountResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::MountAndCreateRequest)
+    == ::fuchsia::io::DirectoryAdmin::MountAndCreateRequest::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, remote) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, name) == 24);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, flags) == 40);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::MountAndCreateResponse)
+    == ::fuchsia::io::DirectoryAdmin::MountAndCreateResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::MountAndCreateResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::UnmountResponse)
+    == ::fuchsia::io::DirectoryAdmin::UnmountResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::UnmountResponse, s) == 16);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::UnmountNodeResponse)
+    == ::fuchsia::io::DirectoryAdmin::UnmountNodeResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, remote) == 20);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse)
+    == ::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, info) == 24);
+
+template <>
+struct IsFidlType<::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
+static_assert(sizeof(::fuchsia::io::DirectoryAdmin::GetDevicePathResponse)
+    == ::fuchsia::io::DirectoryAdmin::GetDevicePathResponse::PrimarySize);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, s) == 16);
+static_assert(offsetof(::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, path) == 24);
+
+}  // namespace fidl
diff --git a/zircon/system/ulib/fdio/BUILD.gn b/zircon/system/ulib/fdio/BUILD.gn
index 4b403850e6cfedefc0248485ab982b2cf867bba4..62f345cd7f86a22ede08e4042b89f25e7129fde9 100644
--- a/zircon/system/ulib/fdio/BUILD.gn
+++ b/zircon/system/ulib/fdio/BUILD.gn
@@ -42,6 +42,7 @@ library("fdio") {
   deps = [
     "$zx/system/fidl/fuchsia-device:c",
     "$zx/system/fidl/fuchsia-io:c",
+    "$zx/system/fidl/fuchsia-io:llcpp",
     "$zx/system/fidl/fuchsia-ldsvc:c",
     "$zx/system/fidl/fuchsia-net:c",
     "$zx/system/fidl/fuchsia-process:c",