src/syscall/zx/net/stack/impl.go

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Code generated by third_party/go/regen-fidl; DO NOT EDIT.

// +build fuchsia

package stack

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiahardwareethernet "syscall/zx/hardware/ethernet"
	fuchsianet "syscall/zx/net"
)

type PresenceStatus uint32

const (
	PresenceStatusAdded   PresenceStatus = 1
	PresenceStatusRemoved PresenceStatus = 2
)

func (x PresenceStatus) String() string {
	switch x {
	case 1:
		return "Added"
	case 2:
		return "Removed"
	}
	return "Unknown"
}

type PhysicalStatus uint32

const (
	PhysicalStatusDown PhysicalStatus = 1
	PhysicalStatusUp   PhysicalStatus = 2
)

func (x PhysicalStatus) String() string {
	switch x {
	case 1:
		return "Down"
	case 2:
		return "Up"
	}
	return "Unknown"
}

type AdministrativeStatus uint32

const (
	AdministrativeStatusDisabled AdministrativeStatus = 1
	AdministrativeStatusEnabled  AdministrativeStatus = 2
)

func (x AdministrativeStatus) String() string {
	switch x {
	case 1:
		return "Disabled"
	case 2:
		return "Enabled"
	}
	return "Unknown"
}

type Error uint32

const (
	ErrorInternal      Error = 1
	ErrorNotSupported  Error = 2
	ErrorInvalidArgs   Error = 3
	ErrorBadState      Error = 4
	ErrorTimeOut       Error = 5
	ErrorNotFound      Error = 6
	ErrorAlreadyExists Error = 7
	ErrorIo            Error = 8
)

func (x Error) String() string {
	switch x {
	case 1:
		return "Internal"
	case 2:
		return "NotSupported"
	case 3:
		return "InvalidArgs"
	case 4:
		return "BadState"
	case 5:
		return "TimeOut"
	case 6:
		return "NotFound"
	case 7:
		return "AlreadyExists"
	case 8:
		return "Io"
	}
	return "Unknown"
}

// Note LogLevelFilter and protocol Log is transient,
// and is planned to be deprecated by logger.fidl's LogLevelFilter.
// This definition is to support syslog/logger.go and Netstack2.
type LogLevelFilter int32

const (
	LogLevelFilterTrace LogLevelFilter = -2
	LogLevelFilterDebug LogLevelFilter = -1
	LogLevelFilterInfo  LogLevelFilter = 0
	LogLevelFilterWarn  LogLevelFilter = 1
	LogLevelFilterError LogLevelFilter = 2
	LogLevelFilterFatal LogLevelFilter = 3
)

func (x LogLevelFilter) String() string {
	switch x {
	case -2:
		return "Trace"
	case -1:
		return "Debug"
	case 0:
		return "Info"
	case 1:
		return "Warn"
	case 2:
		return "Error"
	case 3:
		return "Fatal"
	}
	return "Unknown"
}

type StackAddEthernetInterfaceResponse struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mStackAddEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(StackAddEthernetInterfaceResponse{})

func (msg *StackAddEthernetInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mStackAddEthernetInterfaceResponse
}

type StackDelEthernetInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackDelEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(StackDelEthernetInterfaceResponse{})

func (msg *StackDelEthernetInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mStackDelEthernetInterfaceResponse
}

type StackGetInterfaceInfoResponse struct {
	_    struct{}      `fidl:"s" fidl_size_v1:"96" fidl_alignment_v1:"8"`
	Info InterfaceInfo `fidl_offset_v1:"0"`
}

var _mStackGetInterfaceInfoResponse = _bindings.CreateLazyMarshaler(StackGetInterfaceInfoResponse{})

func (msg *StackGetInterfaceInfoResponse) Marshaler() _bindings.Marshaler {
	return _mStackGetInterfaceInfoResponse
}

type StackEnableInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackEnableInterfaceResponse = _bindings.CreateLazyMarshaler(StackEnableInterfaceResponse{})

func (msg *StackEnableInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mStackEnableInterfaceResponse
}

type StackDisableInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackDisableInterfaceResponse = _bindings.CreateLazyMarshaler(StackDisableInterfaceResponse{})

func (msg *StackDisableInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mStackDisableInterfaceResponse
}

type StackAddInterfaceAddressResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackAddInterfaceAddressResponse = _bindings.CreateLazyMarshaler(StackAddInterfaceAddressResponse{})

func (msg *StackAddInterfaceAddressResponse) Marshaler() _bindings.Marshaler {
	return _mStackAddInterfaceAddressResponse
}

type StackDelInterfaceAddressResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackDelInterfaceAddressResponse = _bindings.CreateLazyMarshaler(StackDelInterfaceAddressResponse{})

func (msg *StackDelInterfaceAddressResponse) Marshaler() _bindings.Marshaler {
	return _mStackDelInterfaceAddressResponse
}

type StackAddForwardingEntryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackAddForwardingEntryResponse = _bindings.CreateLazyMarshaler(StackAddForwardingEntryResponse{})

func (msg *StackAddForwardingEntryResponse) Marshaler() _bindings.Marshaler {
	return _mStackAddForwardingEntryResponse
}

type StackDelForwardingEntryResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackDelForwardingEntryResponse = _bindings.CreateLazyMarshaler(StackDelForwardingEntryResponse{})

func (msg *StackDelForwardingEntryResponse) Marshaler() _bindings.Marshaler {
	return _mStackDelForwardingEntryResponse
}

type StackEnablePacketFilterResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackEnablePacketFilterResponse = _bindings.CreateLazyMarshaler(StackEnablePacketFilterResponse{})

func (msg *StackEnablePacketFilterResponse) Marshaler() _bindings.Marshaler {
	return _mStackEnablePacketFilterResponse
}

type StackDisablePacketFilterResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mStackDisablePacketFilterResponse = _bindings.CreateLazyMarshaler(StackDisablePacketFilterResponse{})

func (msg *StackDisablePacketFilterResponse) Marshaler() _bindings.Marshaler {
	return _mStackDisablePacketFilterResponse
}

type LogSetLogLevelResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mLogSetLogLevelResponse = _bindings.CreateLazyMarshaler(LogSetLogLevelResponse{})

func (msg *LogSetLogLevelResponse) Marshaler() _bindings.Marshaler {
	return _mLogSetLogLevelResponse
}

type InterfaceAddress struct {
	_ struct{} `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	// The IP address of the interface.
	IpAddress fuchsianet.IpAddress `fidl_offset_v1:"0"`
	// The length of the network portion of the interface IP address.
	PrefixLen uint8 `fidl_offset_v1:"24"`
}

var _mInterfaceAddress = _bindings.CreateLazyMarshaler(InterfaceAddress{})

func (msg *InterfaceAddress) Marshaler() _bindings.Marshaler {
	return _mInterfaceAddress
}

type InterfaceInfo struct {
	_ struct{} `fidl:"s" fidl_size_v1:"96" fidl_alignment_v1:"8"`
	// An opaque identifier for the interface, assigned by the stack.
	// This identifier will never be 0, and will not be reused even if the device is removed and
	// subsequently re-added. It is not stable across netstack instances.
	Id uint64 `fidl_offset_v1:"0"`
	// All info of an interface except the interface name.
	Properties InterfaceProperties `fidl_offset_v1:"8"`
}

var _mInterfaceInfo = _bindings.CreateLazyMarshaler(InterfaceInfo{})

func (msg *InterfaceInfo) Marshaler() _bindings.Marshaler {
	return _mInterfaceInfo
}

type InterfaceProperties struct {
	_ struct{} `fidl:"s" fidl_size_v1:"88" fidl_alignment_v1:"8"`
	// Human-readable name of the interface. eg. eth001, wlanx35.
	Name string `fidl_offset_v1:"0" fidl_bounds:"15"`
	// The topological path to the device, representing a stable identifier for the interface
	// hardware.
	Topopath string `fidl_offset_v1:"16" fidl_bounds:"255"`
	// An unstable file path corresponding to the interface. Used in watching the creation
	// and destruction of the interface, or in accessing the interface using netdump.
	Filepath string `fidl_offset_v1:"32" fidl_bounds:"255"`
	// The MAC address of the interface, if available.
	Mac *fuchsiahardwareethernet.MacAddress `fidl_offset_v1:"48"`
	// The maximum transmission unit for the interface in bytes.
	Mtu uint32 `fidl_offset_v1:"56"`
	// The features present on the interface, as a bitfield. Valid flags are
	// fuchsia.hardware.ethernet.`INFO_FEATURE_*`.
	Features uint32 `fidl_offset_v1:"60"`
	// The administrative status of the interface.
	AdministrativeStatus AdministrativeStatus `fidl_offset_v1:"64"`
	// The physical link status of the interface.
	PhysicalStatus PhysicalStatus `fidl_offset_v1:"68"`
	// The list of addresses currently assigned to the interface.
	Addresses []InterfaceAddress `fidl_offset_v1:"72" fidl_bounds:"255"`
}

var _mInterfaceProperties = _bindings.CreateLazyMarshaler(InterfaceProperties{})

func (msg *InterfaceProperties) Marshaler() _bindings.Marshaler {
	return _mInterfaceProperties
}

// An entry in the forwarding table for the network stack.
type ForwardingEntry struct {
	_ struct{} `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	// The subnet is the key for the entry in the table.
	Subnet fuchsianet.Subnet `fidl_offset_v1:"0"`
	// The destination that will receive the forwarded packet.
	Destination ForwardingDestination `fidl_offset_v1:"32"`
}

var _mForwardingEntry = _bindings.CreateLazyMarshaler(ForwardingEntry{})

func (msg *ForwardingEntry) Marshaler() _bindings.Marshaler {
	return _mForwardingEntry
}

type InterfaceStatusChange struct {
	_ struct{} `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	// The opaque identifier of the device that had its status change.
	Id uint64 `fidl_offset_v1:"0"`
	// The new status.
	Status InterfaceStatus `fidl_offset_v1:"8"`
}

var _mInterfaceStatusChange = _bindings.CreateLazyMarshaler(InterfaceStatusChange{})

func (msg *InterfaceStatusChange) Marshaler() _bindings.Marshaler {
	return _mInterfaceStatusChange
}

type stackWithCtxAddEthernetInterfaceRequest struct {
	_               struct{}                                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	TopologicalPath string                                         `fidl_offset_v1:"0" fidl_bounds:"255"`
	Device          fuchsiahardwareethernet.DeviceWithCtxInterface `fidl_offset_v1:"16" fidl_handle_subtype:"4"`
}

var _mstackWithCtxAddEthernetInterfaceRequest = _bindings.CreateLazyMarshaler(stackWithCtxAddEthernetInterfaceRequest{})

func (msg *stackWithCtxAddEthernetInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddEthernetInterfaceRequest
}

type stackWithCtxAddEthernetInterfaceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackAddEthernetInterfaceResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxAddEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxAddEthernetInterfaceResponse{})

func (msg *stackWithCtxAddEthernetInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddEthernetInterfaceResponse
}

type stackWithCtxDelEthernetInterfaceRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxDelEthernetInterfaceRequest = _bindings.CreateLazyMarshaler(stackWithCtxDelEthernetInterfaceRequest{})

func (msg *stackWithCtxDelEthernetInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelEthernetInterfaceRequest
}

type stackWithCtxDelEthernetInterfaceResponse struct {
	_      struct{}                        `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackDelEthernetInterfaceResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxDelEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxDelEthernetInterfaceResponse{})

func (msg *stackWithCtxDelEthernetInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelEthernetInterfaceResponse
}

type stackWithCtxListInterfacesResponse struct {
	_   struct{}        `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Ifs []InterfaceInfo `fidl_offset_v1:"0" fidl_bounds:"255"`
}

var _mstackWithCtxListInterfacesResponse = _bindings.CreateLazyMarshaler(stackWithCtxListInterfacesResponse{})

func (msg *stackWithCtxListInterfacesResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxListInterfacesResponse
}

type stackWithCtxGetInterfaceInfoRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxGetInterfaceInfoRequest = _bindings.CreateLazyMarshaler(stackWithCtxGetInterfaceInfoRequest{})

func (msg *stackWithCtxGetInterfaceInfoRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetInterfaceInfoRequest
}

type stackWithCtxGetInterfaceInfoResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackGetInterfaceInfoResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxGetInterfaceInfoResponse = _bindings.CreateLazyMarshaler(stackWithCtxGetInterfaceInfoResponse{})

func (msg *stackWithCtxGetInterfaceInfoResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetInterfaceInfoResponse
}

type stackWithCtxEnableInterfaceRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxEnableInterfaceRequest = _bindings.CreateLazyMarshaler(stackWithCtxEnableInterfaceRequest{})

func (msg *stackWithCtxEnableInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxEnableInterfaceRequest
}

type stackWithCtxEnableInterfaceResponse struct {
	_      struct{}                   `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackEnableInterfaceResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxEnableInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxEnableInterfaceResponse{})

func (msg *stackWithCtxEnableInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxEnableInterfaceResponse
}

type stackWithCtxDisableInterfaceRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxDisableInterfaceRequest = _bindings.CreateLazyMarshaler(stackWithCtxDisableInterfaceRequest{})

func (msg *stackWithCtxDisableInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDisableInterfaceRequest
}

type stackWithCtxDisableInterfaceResponse struct {
	_      struct{}                    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackDisableInterfaceResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxDisableInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxDisableInterfaceResponse{})

func (msg *stackWithCtxDisableInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDisableInterfaceResponse
}

type stackWithCtxAddInterfaceAddressRequest struct {
	_    struct{}         `fidl:"s" fidl_size_v1:"40" fidl_alignment_v1:"8"`
	Id   uint64           `fidl_offset_v1:"0"`
	Addr InterfaceAddress `fidl_offset_v1:"8"`
}

var _mstackWithCtxAddInterfaceAddressRequest = _bindings.CreateLazyMarshaler(stackWithCtxAddInterfaceAddressRequest{})

func (msg *stackWithCtxAddInterfaceAddressRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddInterfaceAddressRequest
}

type stackWithCtxAddInterfaceAddressResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackAddInterfaceAddressResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxAddInterfaceAddressResponse = _bindings.CreateLazyMarshaler(stackWithCtxAddInterfaceAddressResponse{})

func (msg *stackWithCtxAddInterfaceAddressResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddInterfaceAddressResponse
}

type stackWithCtxDelInterfaceAddressRequest struct {
	_    struct{}         `fidl:"s" fidl_size_v1:"40" fidl_alignment_v1:"8"`
	Id   uint64           `fidl_offset_v1:"0"`
	Addr InterfaceAddress `fidl_offset_v1:"8"`
}

var _mstackWithCtxDelInterfaceAddressRequest = _bindings.CreateLazyMarshaler(stackWithCtxDelInterfaceAddressRequest{})

func (msg *stackWithCtxDelInterfaceAddressRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelInterfaceAddressRequest
}

type stackWithCtxDelInterfaceAddressResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackDelInterfaceAddressResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxDelInterfaceAddressResponse = _bindings.CreateLazyMarshaler(stackWithCtxDelInterfaceAddressResponse{})

func (msg *stackWithCtxDelInterfaceAddressResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelInterfaceAddressResponse
}

type stackWithCtxGetForwardingTableResponse struct {
	_     struct{}          `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Table []ForwardingEntry `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mstackWithCtxGetForwardingTableResponse = _bindings.CreateLazyMarshaler(stackWithCtxGetForwardingTableResponse{})

func (msg *stackWithCtxGetForwardingTableResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetForwardingTableResponse
}

type stackWithCtxAddForwardingEntryRequest struct {
	_     struct{}        `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	Entry ForwardingEntry `fidl_offset_v1:"0"`
}

var _mstackWithCtxAddForwardingEntryRequest = _bindings.CreateLazyMarshaler(stackWithCtxAddForwardingEntryRequest{})

func (msg *stackWithCtxAddForwardingEntryRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddForwardingEntryRequest
}

type stackWithCtxAddForwardingEntryResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackAddForwardingEntryResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxAddForwardingEntryResponse = _bindings.CreateLazyMarshaler(stackWithCtxAddForwardingEntryResponse{})

func (msg *stackWithCtxAddForwardingEntryResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddForwardingEntryResponse
}

type stackWithCtxDelForwardingEntryRequest struct {
	_      struct{}          `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	Subnet fuchsianet.Subnet `fidl_offset_v1:"0"`
}

var _mstackWithCtxDelForwardingEntryRequest = _bindings.CreateLazyMarshaler(stackWithCtxDelForwardingEntryRequest{})

func (msg *stackWithCtxDelForwardingEntryRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelForwardingEntryRequest
}

type stackWithCtxDelForwardingEntryResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackDelForwardingEntryResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxDelForwardingEntryResponse = _bindings.CreateLazyMarshaler(stackWithCtxDelForwardingEntryResponse{})

func (msg *stackWithCtxDelForwardingEntryResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDelForwardingEntryResponse
}

type stackWithCtxEnablePacketFilterRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxEnablePacketFilterRequest = _bindings.CreateLazyMarshaler(stackWithCtxEnablePacketFilterRequest{})

func (msg *stackWithCtxEnablePacketFilterRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxEnablePacketFilterRequest
}

type stackWithCtxEnablePacketFilterResponse struct {
	_      struct{}                      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackEnablePacketFilterResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxEnablePacketFilterResponse = _bindings.CreateLazyMarshaler(stackWithCtxEnablePacketFilterResponse{})

func (msg *stackWithCtxEnablePacketFilterResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxEnablePacketFilterResponse
}

type stackWithCtxDisablePacketFilterRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Id uint64   `fidl_offset_v1:"0"`
}

var _mstackWithCtxDisablePacketFilterRequest = _bindings.CreateLazyMarshaler(stackWithCtxDisablePacketFilterRequest{})

func (msg *stackWithCtxDisablePacketFilterRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDisablePacketFilterRequest
}

type stackWithCtxDisablePacketFilterResponse struct {
	_      struct{}                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result StackDisablePacketFilterResult `fidl_offset_v1:"0"`
}

var _mstackWithCtxDisablePacketFilterResponse = _bindings.CreateLazyMarshaler(stackWithCtxDisablePacketFilterResponse{})

func (msg *stackWithCtxDisablePacketFilterResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxDisablePacketFilterResponse
}

type stackWithCtxOnInterfaceStatusChangeResponse struct {
	_    struct{}              `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	Info InterfaceStatusChange `fidl_offset_v1:"0"`
}

var _mstackWithCtxOnInterfaceStatusChangeResponse = _bindings.CreateLazyMarshaler(stackWithCtxOnInterfaceStatusChangeResponse{})

func (msg *stackWithCtxOnInterfaceStatusChangeResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxOnInterfaceStatusChangeResponse
}

type logWithCtxSetLogLevelRequest struct {
	_     struct{}       `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Level LogLevelFilter `fidl_offset_v1:"0"`
}

var _mlogWithCtxSetLogLevelRequest = _bindings.CreateLazyMarshaler(logWithCtxSetLogLevelRequest{})

func (msg *logWithCtxSetLogLevelRequest) Marshaler() _bindings.Marshaler {
	return _mlogWithCtxSetLogLevelRequest
}

type logWithCtxSetLogLevelResponse struct {
	_      struct{}             `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result LogSetLogLevelResult `fidl_offset_v1:"0"`
}

var _mlogWithCtxSetLogLevelResponse = _bindings.CreateLazyMarshaler(logWithCtxSetLogLevelResponse{})

func (msg *logWithCtxSetLogLevelResponse) Marshaler() _bindings.Marshaler {
	return _mlogWithCtxSetLogLevelResponse
}

type I_stackAddEthernetInterfaceResultTag uint64

const (
	StackAddEthernetInterfaceResultResponse = 1 // 0x00000001
	StackAddEthernetInterfaceResultErr      = 2 // 0x00000002
)

type StackAddEthernetInterfaceResult struct {
	I_stackAddEthernetInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                             StackAddEthernetInterfaceResponse `fidl_ordinal:"1"`
	Err                                  Error                             `fidl_ordinal:"2"`
}

func (_m *StackAddEthernetInterfaceResult) Which() I_stackAddEthernetInterfaceResultTag {
	return _m.I_stackAddEthernetInterfaceResultTag
}

func (_m *StackAddEthernetInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_stackAddEthernetInterfaceResultTag)
}

func (_m *StackAddEthernetInterfaceResult) SetResponse(response StackAddEthernetInterfaceResponse) {
	_m.I_stackAddEthernetInterfaceResultTag = StackAddEthernetInterfaceResultResponse
	_m.Response = response
}

func StackAddEthernetInterfaceResultWithResponse(response StackAddEthernetInterfaceResponse) StackAddEthernetInterfaceResult {
	var _u StackAddEthernetInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackAddEthernetInterfaceResult) SetErr(err Error) {
	_m.I_stackAddEthernetInterfaceResultTag = StackAddEthernetInterfaceResultErr
	_m.Err = err
}

func StackAddEthernetInterfaceResultWithErr(err Error) StackAddEthernetInterfaceResult {
	var _u StackAddEthernetInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_stackDelEthernetInterfaceResultTag uint64

const (
	StackDelEthernetInterfaceResultResponse = 1 // 0x00000001
	StackDelEthernetInterfaceResultErr      = 2 // 0x00000002
)

type StackDelEthernetInterfaceResult struct {
	I_stackDelEthernetInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                             StackDelEthernetInterfaceResponse `fidl_ordinal:"1"`
	Err                                  Error                             `fidl_ordinal:"2"`
}

func (_m *StackDelEthernetInterfaceResult) Which() I_stackDelEthernetInterfaceResultTag {
	return _m.I_stackDelEthernetInterfaceResultTag
}

func (_m *StackDelEthernetInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_stackDelEthernetInterfaceResultTag)
}

func (_m *StackDelEthernetInterfaceResult) SetResponse(response StackDelEthernetInterfaceResponse) {
	_m.I_stackDelEthernetInterfaceResultTag = StackDelEthernetInterfaceResultResponse
	_m.Response = response
}

func StackDelEthernetInterfaceResultWithResponse(response StackDelEthernetInterfaceResponse) StackDelEthernetInterfaceResult {
	var _u StackDelEthernetInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackDelEthernetInterfaceResult) SetErr(err Error) {
	_m.I_stackDelEthernetInterfaceResultTag = StackDelEthernetInterfaceResultErr
	_m.Err = err
}

func StackDelEthernetInterfaceResultWithErr(err Error) StackDelEthernetInterfaceResult {
	var _u StackDelEthernetInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_stackGetInterfaceInfoResultTag uint64

const (
	StackGetInterfaceInfoResultResponse = 1 // 0x00000001
	StackGetInterfaceInfoResultErr      = 2 // 0x00000002
)

type StackGetInterfaceInfoResult struct {
	I_stackGetInterfaceInfoResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                         StackGetInterfaceInfoResponse `fidl_ordinal:"1"`
	Err                              Error                         `fidl_ordinal:"2"`
}

func (_m *StackGetInterfaceInfoResult) Which() I_stackGetInterfaceInfoResultTag {
	return _m.I_stackGetInterfaceInfoResultTag
}

func (_m *StackGetInterfaceInfoResult) Ordinal() uint64 {
	return uint64(_m.I_stackGetInterfaceInfoResultTag)
}

func (_m *StackGetInterfaceInfoResult) SetResponse(response StackGetInterfaceInfoResponse) {
	_m.I_stackGetInterfaceInfoResultTag = StackGetInterfaceInfoResultResponse
	_m.Response = response
}

func StackGetInterfaceInfoResultWithResponse(response StackGetInterfaceInfoResponse) StackGetInterfaceInfoResult {
	var _u StackGetInterfaceInfoResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackGetInterfaceInfoResult) SetErr(err Error) {
	_m.I_stackGetInterfaceInfoResultTag = StackGetInterfaceInfoResultErr
	_m.Err = err
}

func StackGetInterfaceInfoResultWithErr(err Error) StackGetInterfaceInfoResult {
	var _u StackGetInterfaceInfoResult
	_u.SetErr(err)
	return _u
}

type I_stackEnableInterfaceResultTag uint64

const (
	StackEnableInterfaceResultResponse = 1 // 0x00000001
	StackEnableInterfaceResultErr      = 2 // 0x00000002
)

type StackEnableInterfaceResult struct {
	I_stackEnableInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                        StackEnableInterfaceResponse `fidl_ordinal:"1"`
	Err                             Error                        `fidl_ordinal:"2"`
}

func (_m *StackEnableInterfaceResult) Which() I_stackEnableInterfaceResultTag {
	return _m.I_stackEnableInterfaceResultTag
}

func (_m *StackEnableInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_stackEnableInterfaceResultTag)
}

func (_m *StackEnableInterfaceResult) SetResponse(response StackEnableInterfaceResponse) {
	_m.I_stackEnableInterfaceResultTag = StackEnableInterfaceResultResponse
	_m.Response = response
}

func StackEnableInterfaceResultWithResponse(response StackEnableInterfaceResponse) StackEnableInterfaceResult {
	var _u StackEnableInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackEnableInterfaceResult) SetErr(err Error) {
	_m.I_stackEnableInterfaceResultTag = StackEnableInterfaceResultErr
	_m.Err = err
}

func StackEnableInterfaceResultWithErr(err Error) StackEnableInterfaceResult {
	var _u StackEnableInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_stackDisableInterfaceResultTag uint64

const (
	StackDisableInterfaceResultResponse = 1 // 0x00000001
	StackDisableInterfaceResultErr      = 2 // 0x00000002
)

type StackDisableInterfaceResult struct {
	I_stackDisableInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                         StackDisableInterfaceResponse `fidl_ordinal:"1"`
	Err                              Error                         `fidl_ordinal:"2"`
}

func (_m *StackDisableInterfaceResult) Which() I_stackDisableInterfaceResultTag {
	return _m.I_stackDisableInterfaceResultTag
}

func (_m *StackDisableInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_stackDisableInterfaceResultTag)
}

func (_m *StackDisableInterfaceResult) SetResponse(response StackDisableInterfaceResponse) {
	_m.I_stackDisableInterfaceResultTag = StackDisableInterfaceResultResponse
	_m.Response = response
}

func StackDisableInterfaceResultWithResponse(response StackDisableInterfaceResponse) StackDisableInterfaceResult {
	var _u StackDisableInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackDisableInterfaceResult) SetErr(err Error) {
	_m.I_stackDisableInterfaceResultTag = StackDisableInterfaceResultErr
	_m.Err = err
}

func StackDisableInterfaceResultWithErr(err Error) StackDisableInterfaceResult {
	var _u StackDisableInterfaceResult
	_u.SetErr(err)
	return _u
}

type I_stackAddInterfaceAddressResultTag uint64

const (
	StackAddInterfaceAddressResultResponse = 1 // 0x00000001
	StackAddInterfaceAddressResultErr      = 2 // 0x00000002
)

type StackAddInterfaceAddressResult struct {
	I_stackAddInterfaceAddressResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                            StackAddInterfaceAddressResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackAddInterfaceAddressResult) Which() I_stackAddInterfaceAddressResultTag {
	return _m.I_stackAddInterfaceAddressResultTag
}

func (_m *StackAddInterfaceAddressResult) Ordinal() uint64 {
	return uint64(_m.I_stackAddInterfaceAddressResultTag)
}

func (_m *StackAddInterfaceAddressResult) SetResponse(response StackAddInterfaceAddressResponse) {
	_m.I_stackAddInterfaceAddressResultTag = StackAddInterfaceAddressResultResponse
	_m.Response = response
}

func StackAddInterfaceAddressResultWithResponse(response StackAddInterfaceAddressResponse) StackAddInterfaceAddressResult {
	var _u StackAddInterfaceAddressResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackAddInterfaceAddressResult) SetErr(err Error) {
	_m.I_stackAddInterfaceAddressResultTag = StackAddInterfaceAddressResultErr
	_m.Err = err
}

func StackAddInterfaceAddressResultWithErr(err Error) StackAddInterfaceAddressResult {
	var _u StackAddInterfaceAddressResult
	_u.SetErr(err)
	return _u
}

type I_stackDelInterfaceAddressResultTag uint64

const (
	StackDelInterfaceAddressResultResponse = 1 // 0x00000001
	StackDelInterfaceAddressResultErr      = 2 // 0x00000002
)

type StackDelInterfaceAddressResult struct {
	I_stackDelInterfaceAddressResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                            StackDelInterfaceAddressResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackDelInterfaceAddressResult) Which() I_stackDelInterfaceAddressResultTag {
	return _m.I_stackDelInterfaceAddressResultTag
}

func (_m *StackDelInterfaceAddressResult) Ordinal() uint64 {
	return uint64(_m.I_stackDelInterfaceAddressResultTag)
}

func (_m *StackDelInterfaceAddressResult) SetResponse(response StackDelInterfaceAddressResponse) {
	_m.I_stackDelInterfaceAddressResultTag = StackDelInterfaceAddressResultResponse
	_m.Response = response
}

func StackDelInterfaceAddressResultWithResponse(response StackDelInterfaceAddressResponse) StackDelInterfaceAddressResult {
	var _u StackDelInterfaceAddressResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackDelInterfaceAddressResult) SetErr(err Error) {
	_m.I_stackDelInterfaceAddressResultTag = StackDelInterfaceAddressResultErr
	_m.Err = err
}

func StackDelInterfaceAddressResultWithErr(err Error) StackDelInterfaceAddressResult {
	var _u StackDelInterfaceAddressResult
	_u.SetErr(err)
	return _u
}

type I_stackAddForwardingEntryResultTag uint64

const (
	StackAddForwardingEntryResultResponse = 1 // 0x00000001
	StackAddForwardingEntryResultErr      = 2 // 0x00000002
)

type StackAddForwardingEntryResult struct {
	I_stackAddForwardingEntryResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                           StackAddForwardingEntryResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackAddForwardingEntryResult) Which() I_stackAddForwardingEntryResultTag {
	return _m.I_stackAddForwardingEntryResultTag
}

func (_m *StackAddForwardingEntryResult) Ordinal() uint64 {
	return uint64(_m.I_stackAddForwardingEntryResultTag)
}

func (_m *StackAddForwardingEntryResult) SetResponse(response StackAddForwardingEntryResponse) {
	_m.I_stackAddForwardingEntryResultTag = StackAddForwardingEntryResultResponse
	_m.Response = response
}

func StackAddForwardingEntryResultWithResponse(response StackAddForwardingEntryResponse) StackAddForwardingEntryResult {
	var _u StackAddForwardingEntryResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackAddForwardingEntryResult) SetErr(err Error) {
	_m.I_stackAddForwardingEntryResultTag = StackAddForwardingEntryResultErr
	_m.Err = err
}

func StackAddForwardingEntryResultWithErr(err Error) StackAddForwardingEntryResult {
	var _u StackAddForwardingEntryResult
	_u.SetErr(err)
	return _u
}

type I_stackDelForwardingEntryResultTag uint64

const (
	StackDelForwardingEntryResultResponse = 1 // 0x00000001
	StackDelForwardingEntryResultErr      = 2 // 0x00000002
)

type StackDelForwardingEntryResult struct {
	I_stackDelForwardingEntryResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                           StackDelForwardingEntryResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackDelForwardingEntryResult) Which() I_stackDelForwardingEntryResultTag {
	return _m.I_stackDelForwardingEntryResultTag
}

func (_m *StackDelForwardingEntryResult) Ordinal() uint64 {
	return uint64(_m.I_stackDelForwardingEntryResultTag)
}

func (_m *StackDelForwardingEntryResult) SetResponse(response StackDelForwardingEntryResponse) {
	_m.I_stackDelForwardingEntryResultTag = StackDelForwardingEntryResultResponse
	_m.Response = response
}

func StackDelForwardingEntryResultWithResponse(response StackDelForwardingEntryResponse) StackDelForwardingEntryResult {
	var _u StackDelForwardingEntryResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackDelForwardingEntryResult) SetErr(err Error) {
	_m.I_stackDelForwardingEntryResultTag = StackDelForwardingEntryResultErr
	_m.Err = err
}

func StackDelForwardingEntryResultWithErr(err Error) StackDelForwardingEntryResult {
	var _u StackDelForwardingEntryResult
	_u.SetErr(err)
	return _u
}

type I_stackEnablePacketFilterResultTag uint64

const (
	StackEnablePacketFilterResultResponse = 1 // 0x00000001
	StackEnablePacketFilterResultErr      = 2 // 0x00000002
)

type StackEnablePacketFilterResult struct {
	I_stackEnablePacketFilterResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                           StackEnablePacketFilterResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackEnablePacketFilterResult) Which() I_stackEnablePacketFilterResultTag {
	return _m.I_stackEnablePacketFilterResultTag
}

func (_m *StackEnablePacketFilterResult) Ordinal() uint64 {
	return uint64(_m.I_stackEnablePacketFilterResultTag)
}

func (_m *StackEnablePacketFilterResult) SetResponse(response StackEnablePacketFilterResponse) {
	_m.I_stackEnablePacketFilterResultTag = StackEnablePacketFilterResultResponse
	_m.Response = response
}

func StackEnablePacketFilterResultWithResponse(response StackEnablePacketFilterResponse) StackEnablePacketFilterResult {
	var _u StackEnablePacketFilterResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackEnablePacketFilterResult) SetErr(err Error) {
	_m.I_stackEnablePacketFilterResultTag = StackEnablePacketFilterResultErr
	_m.Err = err
}

func StackEnablePacketFilterResultWithErr(err Error) StackEnablePacketFilterResult {
	var _u StackEnablePacketFilterResult
	_u.SetErr(err)
	return _u
}

type I_stackDisablePacketFilterResultTag uint64

const (
	StackDisablePacketFilterResultResponse = 1 // 0x00000001
	StackDisablePacketFilterResultErr      = 2 // 0x00000002
)

type StackDisablePacketFilterResult struct {
	I_stackDisablePacketFilterResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                            StackDisablePacketFilterResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackDisablePacketFilterResult) Which() I_stackDisablePacketFilterResultTag {
	return _m.I_stackDisablePacketFilterResultTag
}

func (_m *StackDisablePacketFilterResult) Ordinal() uint64 {
	return uint64(_m.I_stackDisablePacketFilterResultTag)
}

func (_m *StackDisablePacketFilterResult) SetResponse(response StackDisablePacketFilterResponse) {
	_m.I_stackDisablePacketFilterResultTag = StackDisablePacketFilterResultResponse
	_m.Response = response
}

func StackDisablePacketFilterResultWithResponse(response StackDisablePacketFilterResponse) StackDisablePacketFilterResult {
	var _u StackDisablePacketFilterResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackDisablePacketFilterResult) SetErr(err Error) {
	_m.I_stackDisablePacketFilterResultTag = StackDisablePacketFilterResultErr
	_m.Err = err
}

func StackDisablePacketFilterResultWithErr(err Error) StackDisablePacketFilterResult {
	var _u StackDisablePacketFilterResult
	_u.SetErr(err)
	return _u
}

type I_logSetLogLevelResultTag uint64

const (
	LogSetLogLevelResultResponse = 1 // 0x00000001
	LogSetLogLevelResultErr      = 2 // 0x00000002
)

type LogSetLogLevelResult struct {
	I_logSetLogLevelResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Response                  LogSetLogLevelResponse `fidl_ordinal:"1"`
	Err                       Error                  `fidl_ordinal:"2"`
}

func (_m *LogSetLogLevelResult) Which() I_logSetLogLevelResultTag {
	return _m.I_logSetLogLevelResultTag
}

func (_m *LogSetLogLevelResult) Ordinal() uint64 {
	return uint64(_m.I_logSetLogLevelResultTag)
}

func (_m *LogSetLogLevelResult) SetResponse(response LogSetLogLevelResponse) {
	_m.I_logSetLogLevelResultTag = LogSetLogLevelResultResponse
	_m.Response = response
}

func LogSetLogLevelResultWithResponse(response LogSetLogLevelResponse) LogSetLogLevelResult {
	var _u LogSetLogLevelResult
	_u.SetResponse(response)
	return _u
}

func (_m *LogSetLogLevelResult) SetErr(err Error) {
	_m.I_logSetLogLevelResultTag = LogSetLogLevelResultErr
	_m.Err = err
}

func LogSetLogLevelResultWithErr(err Error) LogSetLogLevelResult {
	var _u LogSetLogLevelResult
	_u.SetErr(err)
	return _u
}

type I_interfaceStatusTag uint64

const (
	InterfaceStatusPresence       = 1 // 0x00000001
	InterfaceStatusPhysical       = 2 // 0x00000002
	InterfaceStatusAdministrative = 3 // 0x00000003
)

type InterfaceStatus struct {
	I_interfaceStatusTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Presence             PresenceStatus       `fidl_ordinal:"1"`
	Physical             PhysicalStatus       `fidl_ordinal:"2"`
	Administrative       AdministrativeStatus `fidl_ordinal:"3"`
}

func (_m *InterfaceStatus) Which() I_interfaceStatusTag {
	return _m.I_interfaceStatusTag
}

func (_m *InterfaceStatus) Ordinal() uint64 {
	return uint64(_m.I_interfaceStatusTag)
}

func (_m *InterfaceStatus) SetPresence(presence PresenceStatus) {
	_m.I_interfaceStatusTag = InterfaceStatusPresence
	_m.Presence = presence
}

func InterfaceStatusWithPresence(presence PresenceStatus) InterfaceStatus {
	var _u InterfaceStatus
	_u.SetPresence(presence)
	return _u
}

func (_m *InterfaceStatus) SetPhysical(physical PhysicalStatus) {
	_m.I_interfaceStatusTag = InterfaceStatusPhysical
	_m.Physical = physical
}

func InterfaceStatusWithPhysical(physical PhysicalStatus) InterfaceStatus {
	var _u InterfaceStatus
	_u.SetPhysical(physical)
	return _u
}

func (_m *InterfaceStatus) SetAdministrative(administrative AdministrativeStatus) {
	_m.I_interfaceStatusTag = InterfaceStatusAdministrative
	_m.Administrative = administrative
}

func InterfaceStatusWithAdministrative(administrative AdministrativeStatus) InterfaceStatus {
	var _u InterfaceStatus
	_u.SetAdministrative(administrative)
	return _u
}

type I_forwardingDestinationTag uint64

const (
	ForwardingDestinationDeviceId = 1 // 0x00000001
	ForwardingDestinationNextHop  = 2 // 0x00000002
)

// A ForwardingDestination represents either the device that should transmit a packet or the address
// of the next hop in the route.
type ForwardingDestination struct {
	I_forwardingDestinationTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	// The opaque identifier of the device to which packets should be forwarded.
	DeviceId uint64 `fidl_ordinal:"1"`
	// The IP address of the next hop, used to look up the next forwarding entry.
	NextHop fuchsianet.IpAddress `fidl_ordinal:"2"`
}

func (_m *ForwardingDestination) Which() I_forwardingDestinationTag {
	return _m.I_forwardingDestinationTag
}

func (_m *ForwardingDestination) Ordinal() uint64 {
	return uint64(_m.I_forwardingDestinationTag)
}

func (_m *ForwardingDestination) SetDeviceId(deviceId uint64) {
	_m.I_forwardingDestinationTag = ForwardingDestinationDeviceId
	_m.DeviceId = deviceId
}

func ForwardingDestinationWithDeviceId(deviceId uint64) ForwardingDestination {
	var _u ForwardingDestination
	_u.SetDeviceId(deviceId)
	return _u
}

func (_m *ForwardingDestination) SetNextHop(nextHop fuchsianet.IpAddress) {
	_m.I_forwardingDestinationTag = ForwardingDestinationNextHop
	_m.NextHop = nextHop
}

func ForwardingDestinationWithNextHop(nextHop fuchsianet.IpAddress) ForwardingDestination {
	var _u ForwardingDestination
	_u.SetNextHop(nextHop)
	return _u
}

const (
	StackAddEthernetInterfaceOrdinal       uint64 = 0x1f31608300000000
	StackAddEthernetInterfaceGenOrdinal    uint64 = 0x5f5733e9cf647a5b
	StackDelEthernetInterfaceOrdinal       uint64 = 0x9caf04c00000000
	StackDelEthernetInterfaceGenOrdinal    uint64 = 0x1e7f3b1fe503a8eb
	StackListInterfacesOrdinal             uint64 = 0x4232ac3500000000
	StackListInterfacesGenOrdinal          uint64 = 0x7858623a6d268864
	StackGetInterfaceInfoOrdinal           uint64 = 0x57f739ce00000000
	StackGetInterfaceInfoGenOrdinal        uint64 = 0x55567267dd660333
	StackEnableInterfaceOrdinal            uint64 = 0x142f6abd00000000
	StackEnableInterfaceGenOrdinal         uint64 = 0x2723e7e9dabca8f2
	StackDisableInterfaceOrdinal           uint64 = 0x190a52ef00000000
	StackDisableInterfaceGenOrdinal        uint64 = 0x1703c5cf0b2f4d87
	StackAddInterfaceAddressOrdinal        uint64 = 0x1e0039e600000000
	StackAddInterfaceAddressGenOrdinal     uint64 = 0x6c21cb598c262ea3
	StackDelInterfaceAddressOrdinal        uint64 = 0x48cdf52d00000000
	StackDelInterfaceAddressGenOrdinal     uint64 = 0x73159e96f5537eed
	StackGetForwardingTableOrdinal         uint64 = 0x64b2bf0100000000
	StackGetForwardingTableGenOrdinal      uint64 = 0x6df035986328d2ef
	StackAddForwardingEntryOrdinal         uint64 = 0x2a27681a00000000
	StackAddForwardingEntryGenOrdinal      uint64 = 0x5fe2020877107909
	StackDelForwardingEntryOrdinal         uint64 = 0x1b35cae100000000
	StackDelForwardingEntryGenOrdinal      uint64 = 0x560f3944c4cb51bd
	StackEnablePacketFilterOrdinal         uint64 = 0x64018f000000000
	StackEnablePacketFilterGenOrdinal      uint64 = 0x1fbd56c90ca0b19d
	StackDisablePacketFilterOrdinal        uint64 = 0x1676b78500000000
	StackDisablePacketFilterGenOrdinal     uint64 = 0x40743d436c82c863
	StackEnableIpForwardingOrdinal         uint64 = 0x18d2752700000000
	StackEnableIpForwardingGenOrdinal      uint64 = 0x28e1915a9b177e6c
	StackDisableIpForwardingOrdinal        uint64 = 0x2986fa9800000000
	StackDisableIpForwardingGenOrdinal     uint64 = 0x477f3f3bb42cf1f4
	StackOnInterfaceStatusChangeOrdinal    uint64 = 0x994698400000000
	StackOnInterfaceStatusChangeGenOrdinal uint64 = 0x6b4da146f5d921fe
)

type StackWithCtxInterface _bindings.ChannelProxy

// Add an Ethernet interface to the network stack. On success, returns the identifier assigned
// by the stack for use in subsequent calls.
func (p *StackWithCtxInterface) AddEthernetInterface(ctx_ _bindings.Context, topologicalPath string, device fuchsiahardwareethernet.DeviceWithCtxInterface) (StackAddEthernetInterfaceResult, error) {
	req_ := &stackWithCtxAddEthernetInterfaceRequest{
		TopologicalPath: topologicalPath,
		Device:          device,
	}
	resp_ := &stackWithCtxAddEthernetInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddEthernetInterfaceGenOrdinal, req_, resp_, StackAddEthernetInterfaceOrdinal, StackAddEthernetInterfaceGenOrdinal)
	return resp_.Result, err_
}

// Remove an Ethernet interface from the network stack.
func (p *StackWithCtxInterface) DelEthernetInterface(ctx_ _bindings.Context, id uint64) (StackDelEthernetInterfaceResult, error) {
	req_ := &stackWithCtxDelEthernetInterfaceRequest{
		Id: id,
	}
	resp_ := &stackWithCtxDelEthernetInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDelEthernetInterfaceGenOrdinal, req_, resp_, StackDelEthernetInterfaceOrdinal, StackDelEthernetInterfaceGenOrdinal)
	return resp_.Result, err_
}

// List all the interfaces available in the network stack.
func (p *StackWithCtxInterface) ListInterfaces(ctx_ _bindings.Context) ([]InterfaceInfo, error) {
	var req_ _bindings.Message
	resp_ := &stackWithCtxListInterfacesResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackListInterfacesGenOrdinal, req_, resp_, StackListInterfacesOrdinal, StackListInterfacesGenOrdinal)
	return resp_.Ifs, err_
}

// Retrieve info about a specific interface.
func (p *StackWithCtxInterface) GetInterfaceInfo(ctx_ _bindings.Context, id uint64) (StackGetInterfaceInfoResult, error) {
	req_ := &stackWithCtxGetInterfaceInfoRequest{
		Id: id,
	}
	resp_ := &stackWithCtxGetInterfaceInfoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackGetInterfaceInfoGenOrdinal, req_, resp_, StackGetInterfaceInfoOrdinal, StackGetInterfaceInfoGenOrdinal)
	return resp_.Result, err_
}

// Enable the interface. Packets may be processed by the stack after this call is processed.
func (p *StackWithCtxInterface) EnableInterface(ctx_ _bindings.Context, id uint64) (StackEnableInterfaceResult, error) {
	req_ := &stackWithCtxEnableInterfaceRequest{
		Id: id,
	}
	resp_ := &stackWithCtxEnableInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackEnableInterfaceGenOrdinal, req_, resp_, StackEnableInterfaceOrdinal, StackEnableInterfaceGenOrdinal)
	return resp_.Result, err_
}

// Disable the interface. The stack will no longer process packets after this call.
func (p *StackWithCtxInterface) DisableInterface(ctx_ _bindings.Context, id uint64) (StackDisableInterfaceResult, error) {
	req_ := &stackWithCtxDisableInterfaceRequest{
		Id: id,
	}
	resp_ := &stackWithCtxDisableInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDisableInterfaceGenOrdinal, req_, resp_, StackDisableInterfaceOrdinal, StackDisableInterfaceGenOrdinal)
	return resp_.Result, err_
}

// Add an address to the interface. If the interface already has an address of a given type that
// does not allow duplicates, this method will return an error.
func (p *StackWithCtxInterface) AddInterfaceAddress(ctx_ _bindings.Context, id uint64, addr InterfaceAddress) (StackAddInterfaceAddressResult, error) {
	req_ := &stackWithCtxAddInterfaceAddressRequest{
		Id:   id,
		Addr: addr,
	}
	resp_ := &stackWithCtxAddInterfaceAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddInterfaceAddressGenOrdinal, req_, resp_, StackAddInterfaceAddressOrdinal, StackAddInterfaceAddressGenOrdinal)
	return resp_.Result, err_
}

// Remove the address from the interface. If the address is not assigned to the interface, an
// error is returned.
func (p *StackWithCtxInterface) DelInterfaceAddress(ctx_ _bindings.Context, id uint64, addr InterfaceAddress) (StackDelInterfaceAddressResult, error) {
	req_ := &stackWithCtxDelInterfaceAddressRequest{
		Id:   id,
		Addr: addr,
	}
	resp_ := &stackWithCtxDelInterfaceAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDelInterfaceAddressGenOrdinal, req_, resp_, StackDelInterfaceAddressOrdinal, StackDelInterfaceAddressGenOrdinal)
	return resp_.Result, err_
}

// List all the entries in the forwarding table for the network stack.
func (p *StackWithCtxInterface) GetForwardingTable(ctx_ _bindings.Context) ([]ForwardingEntry, error) {
	var req_ _bindings.Message
	resp_ := &stackWithCtxGetForwardingTableResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackGetForwardingTableGenOrdinal, req_, resp_, StackGetForwardingTableOrdinal, StackGetForwardingTableGenOrdinal)
	return resp_.Table, err_
}

// Add a new entry to the forwarding table. If the table already contains an entry with the same
// subnet, an error is returned. The entry may be deleted using DelForwardingEntry first.
func (p *StackWithCtxInterface) AddForwardingEntry(ctx_ _bindings.Context, entry ForwardingEntry) (StackAddForwardingEntryResult, error) {
	req_ := &stackWithCtxAddForwardingEntryRequest{
		Entry: entry,
	}
	resp_ := &stackWithCtxAddForwardingEntryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddForwardingEntryGenOrdinal, req_, resp_, StackAddForwardingEntryOrdinal, StackAddForwardingEntryGenOrdinal)
	return resp_.Result, err_
}

// Removes the forwarding entry with the given subnet. This will not affect any overlapping
// subnets (superset or subset) so the subnet must exactly match an entry in the forwarding
// table. If no entry for the subnet exists, an error is returned.
func (p *StackWithCtxInterface) DelForwardingEntry(ctx_ _bindings.Context, subnet fuchsianet.Subnet) (StackDelForwardingEntryResult, error) {
	req_ := &stackWithCtxDelForwardingEntryRequest{
		Subnet: subnet,
	}
	resp_ := &stackWithCtxDelForwardingEntryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDelForwardingEntryGenOrdinal, req_, resp_, StackDelForwardingEntryOrdinal, StackDelForwardingEntryGenOrdinal)
	return resp_.Result, err_
}

// Enable the packet filter on a specific interface.
func (p *StackWithCtxInterface) EnablePacketFilter(ctx_ _bindings.Context, id uint64) (StackEnablePacketFilterResult, error) {
	req_ := &stackWithCtxEnablePacketFilterRequest{
		Id: id,
	}
	resp_ := &stackWithCtxEnablePacketFilterResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackEnablePacketFilterGenOrdinal, req_, resp_, StackEnablePacketFilterOrdinal, StackEnablePacketFilterGenOrdinal)
	return resp_.Result, err_
}

// Disable the packet filter on a specific interface.
func (p *StackWithCtxInterface) DisablePacketFilter(ctx_ _bindings.Context, id uint64) (StackDisablePacketFilterResult, error) {
	req_ := &stackWithCtxDisablePacketFilterRequest{
		Id: id,
	}
	resp_ := &stackWithCtxDisablePacketFilterResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDisablePacketFilterGenOrdinal, req_, resp_, StackDisablePacketFilterOrdinal, StackDisablePacketFilterGenOrdinal)
	return resp_.Result, err_
}

// Enable IP Forwarding.
func (p *StackWithCtxInterface) EnableIpForwarding(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackEnableIpForwardingGenOrdinal, req_, resp_, StackEnableIpForwardingOrdinal, StackEnableIpForwardingGenOrdinal)
	return err_
}

// Disable IP Forwarding.
func (p *StackWithCtxInterface) DisableIpForwarding(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDisableIpForwardingGenOrdinal, req_, resp_, StackDisableIpForwardingOrdinal, StackDisableIpForwardingGenOrdinal)
	return err_
}

// A status change event is triggered whenever an interface's status changes.
func (p *StackWithCtxInterface) ExpectOnInterfaceStatusChange(ctx_ _bindings.Context) (InterfaceStatusChange, error) {
	resp_ := &stackWithCtxOnInterfaceStatusChangeResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(StackOnInterfaceStatusChangeOrdinal, resp_, StackOnInterfaceStatusChangeGenOrdinal)
	return resp_.Info, err_
}

type StackWithCtx interface {
	// Add an Ethernet interface to the network stack. On success, returns the identifier assigned
	// by the stack for use in subsequent calls.
	AddEthernetInterface(ctx_ _bindings.Context, topologicalPath string, device fuchsiahardwareethernet.DeviceWithCtxInterface) (StackAddEthernetInterfaceResult, error)
	// Remove an Ethernet interface from the network stack.
	DelEthernetInterface(ctx_ _bindings.Context, id uint64) (StackDelEthernetInterfaceResult, error)
	// List all the interfaces available in the network stack.
	ListInterfaces(ctx_ _bindings.Context) ([]InterfaceInfo, error)
	// Retrieve info about a specific interface.
	GetInterfaceInfo(ctx_ _bindings.Context, id uint64) (StackGetInterfaceInfoResult, error)
	// Enable the interface. Packets may be processed by the stack after this call is processed.
	EnableInterface(ctx_ _bindings.Context, id uint64) (StackEnableInterfaceResult, error)
	// Disable the interface. The stack will no longer process packets after this call.
	DisableInterface(ctx_ _bindings.Context, id uint64) (StackDisableInterfaceResult, error)
	// Add an address to the interface. If the interface already has an address of a given type that
	// does not allow duplicates, this method will return an error.
	AddInterfaceAddress(ctx_ _bindings.Context, id uint64, addr InterfaceAddress) (StackAddInterfaceAddressResult, error)
	// Remove the address from the interface. If the address is not assigned to the interface, an
	// error is returned.
	DelInterfaceAddress(ctx_ _bindings.Context, id uint64, addr InterfaceAddress) (StackDelInterfaceAddressResult, error)
	// List all the entries in the forwarding table for the network stack.
	GetForwardingTable(ctx_ _bindings.Context) ([]ForwardingEntry, error)
	// Add a new entry to the forwarding table. If the table already contains an entry with the same
	// subnet, an error is returned. The entry may be deleted using DelForwardingEntry first.
	AddForwardingEntry(ctx_ _bindings.Context, entry ForwardingEntry) (StackAddForwardingEntryResult, error)
	// Removes the forwarding entry with the given subnet. This will not affect any overlapping
	// subnets (superset or subset) so the subnet must exactly match an entry in the forwarding
	// table. If no entry for the subnet exists, an error is returned.
	DelForwardingEntry(ctx_ _bindings.Context, subnet fuchsianet.Subnet) (StackDelForwardingEntryResult, error)
	// Enable the packet filter on a specific interface.
	EnablePacketFilter(ctx_ _bindings.Context, id uint64) (StackEnablePacketFilterResult, error)
	// Disable the packet filter on a specific interface.
	DisablePacketFilter(ctx_ _bindings.Context, id uint64) (StackDisablePacketFilterResult, error)
	// Enable IP Forwarding.
	EnableIpForwarding(ctx_ _bindings.Context) error
	// Disable IP Forwarding.
	DisableIpForwarding(ctx_ _bindings.Context) error
	// A status change event is triggered whenever an interface's status changes.
}

type StackWithCtxTransitionalBase struct{}

type StackWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewStackWithCtxInterfaceRequest() (StackWithCtxInterfaceRequest, *StackWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return StackWithCtxInterfaceRequest(req), (*StackWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ StackWithCtxInterfaceRequest) Name() string {
	return "fuchsia.net.stack.Stack"
}
func (c StackWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const StackName = "fuchsia.net.stack.Stack"

type StackWithCtxStub struct {
	Impl StackWithCtx
}

func (s_ *StackWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case StackAddEthernetInterfaceOrdinal:
		fallthrough
	case StackAddEthernetInterfaceGenOrdinal:
		in_ := stackWithCtxAddEthernetInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddEthernetInterface(args_.Ctx, in_.TopologicalPath, in_.Device)
		out_ := stackWithCtxAddEthernetInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDelEthernetInterfaceOrdinal:
		fallthrough
	case StackDelEthernetInterfaceGenOrdinal:
		in_ := stackWithCtxDelEthernetInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DelEthernetInterface(args_.Ctx, in_.Id)
		out_ := stackWithCtxDelEthernetInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackListInterfacesOrdinal:
		fallthrough
	case StackListInterfacesGenOrdinal:
		ifs, err_ := s_.Impl.ListInterfaces(args_.Ctx)
		out_ := stackWithCtxListInterfacesResponse{}
		out_.Ifs = ifs
		return &out_, true, err_
	case StackGetInterfaceInfoOrdinal:
		fallthrough
	case StackGetInterfaceInfoGenOrdinal:
		in_ := stackWithCtxGetInterfaceInfoRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.GetInterfaceInfo(args_.Ctx, in_.Id)
		out_ := stackWithCtxGetInterfaceInfoResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackEnableInterfaceOrdinal:
		fallthrough
	case StackEnableInterfaceGenOrdinal:
		in_ := stackWithCtxEnableInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.EnableInterface(args_.Ctx, in_.Id)
		out_ := stackWithCtxEnableInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDisableInterfaceOrdinal:
		fallthrough
	case StackDisableInterfaceGenOrdinal:
		in_ := stackWithCtxDisableInterfaceRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DisableInterface(args_.Ctx, in_.Id)
		out_ := stackWithCtxDisableInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackAddInterfaceAddressOrdinal:
		fallthrough
	case StackAddInterfaceAddressGenOrdinal:
		in_ := stackWithCtxAddInterfaceAddressRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddInterfaceAddress(args_.Ctx, in_.Id, in_.Addr)
		out_ := stackWithCtxAddInterfaceAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDelInterfaceAddressOrdinal:
		fallthrough
	case StackDelInterfaceAddressGenOrdinal:
		in_ := stackWithCtxDelInterfaceAddressRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DelInterfaceAddress(args_.Ctx, in_.Id, in_.Addr)
		out_ := stackWithCtxDelInterfaceAddressResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackGetForwardingTableOrdinal:
		fallthrough
	case StackGetForwardingTableGenOrdinal:
		table, err_ := s_.Impl.GetForwardingTable(args_.Ctx)
		out_ := stackWithCtxGetForwardingTableResponse{}
		out_.Table = table
		return &out_, true, err_
	case StackAddForwardingEntryOrdinal:
		fallthrough
	case StackAddForwardingEntryGenOrdinal:
		in_ := stackWithCtxAddForwardingEntryRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.AddForwardingEntry(args_.Ctx, in_.Entry)
		out_ := stackWithCtxAddForwardingEntryResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDelForwardingEntryOrdinal:
		fallthrough
	case StackDelForwardingEntryGenOrdinal:
		in_ := stackWithCtxDelForwardingEntryRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DelForwardingEntry(args_.Ctx, in_.Subnet)
		out_ := stackWithCtxDelForwardingEntryResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackEnablePacketFilterOrdinal:
		fallthrough
	case StackEnablePacketFilterGenOrdinal:
		in_ := stackWithCtxEnablePacketFilterRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.EnablePacketFilter(args_.Ctx, in_.Id)
		out_ := stackWithCtxEnablePacketFilterResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDisablePacketFilterOrdinal:
		fallthrough
	case StackDisablePacketFilterGenOrdinal:
		in_ := stackWithCtxDisablePacketFilterRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.DisablePacketFilter(args_.Ctx, in_.Id)
		out_ := stackWithCtxDisablePacketFilterResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackEnableIpForwardingOrdinal:
		fallthrough
	case StackEnableIpForwardingGenOrdinal:
		err_ := s_.Impl.EnableIpForwarding(args_.Ctx)
		return nil, true, err_
	case StackDisableIpForwardingOrdinal:
		fallthrough
	case StackDisableIpForwardingGenOrdinal:
		err_ := s_.Impl.DisableIpForwarding(args_.Ctx)
		return nil, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type StackEventProxy _bindings.ChannelProxy

func (p *StackEventProxy) OnInterfaceStatusChange(info InterfaceStatusChange) error {
	event_ := &stackWithCtxOnInterfaceStatusChangeResponse{
		Info: info,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(StackOnInterfaceStatusChangeGenOrdinal, event_)
}

const (
	LogSetLogLevelOrdinal    uint64 = 0xa83034300000000
	LogSetLogLevelGenOrdinal uint64 = 0x5fea0a401ca44550
)

type LogWithCtxInterface _bindings.ChannelProxy

// Dynamically set a syslog level.
// See syslog/logger.go for level definition.
func (p *LogWithCtxInterface) SetLogLevel(ctx_ _bindings.Context, level LogLevelFilter) (LogSetLogLevelResult, error) {
	req_ := &logWithCtxSetLogLevelRequest{
		Level: level,
	}
	resp_ := &logWithCtxSetLogLevelResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(LogSetLogLevelGenOrdinal, req_, resp_, LogSetLogLevelOrdinal, LogSetLogLevelGenOrdinal)
	return resp_.Result, err_
}

type LogWithCtx interface {
	// Dynamically set a syslog level.
	// See syslog/logger.go for level definition.
	SetLogLevel(ctx_ _bindings.Context, level LogLevelFilter) (LogSetLogLevelResult, error)
}

type LogWithCtxTransitionalBase struct{}

type LogWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewLogWithCtxInterfaceRequest() (LogWithCtxInterfaceRequest, *LogWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return LogWithCtxInterfaceRequest(req), (*LogWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ LogWithCtxInterfaceRequest) Name() string {
	return "fuchsia.net.stack.Log"
}
func (c LogWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const LogName = "fuchsia.net.stack.Log"

type LogWithCtxStub struct {
	Impl LogWithCtx
}

func (s_ *LogWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case LogSetLogLevelOrdinal:
		fallthrough
	case LogSetLogLevelGenOrdinal:
		in_ := logWithCtxSetLogLevelRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.SetLogLevel(args_.Ctx, in_.Level)
		out_ := logWithCtxSetLogLevelResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type LogEventProxy _bindings.ChannelProxy