// 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.

package stack

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
	fuchsiahardwareethernet "syscall/zx/hardware/ethernet"
	fuchsiahardwarenetwork "syscall/zx/hardware/network"
	fuchsianet "syscall/zx/net"
	fuchsianetname "syscall/zx/net/name"
)

var _ _bindings.Enum = PhysicalStatus(0)

type PhysicalStatus uint32

const (

	// The link is not attached to the medium.
	PhysicalStatusDown PhysicalStatus = 1

	// The link is attached to the medium.
	PhysicalStatusUp PhysicalStatus = 2
)

func (_ PhysicalStatus) I_EnumValues() []PhysicalStatus {
	return []PhysicalStatus{
		PhysicalStatusDown,
		PhysicalStatusUp,
	}
}

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

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

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

var _ _bindings.Enum = AdministrativeStatus(0)

type AdministrativeStatus uint32

const (

	// The interface is administratively disabled.
	AdministrativeStatusDisabled AdministrativeStatus = 1

	// The interface is administratively enabled.
	AdministrativeStatusEnabled AdministrativeStatus = 2
)

func (_ AdministrativeStatus) I_EnumValues() []AdministrativeStatus {
	return []AdministrativeStatus{
		AdministrativeStatusDisabled,
		AdministrativeStatusEnabled,
	}
}

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

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

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

var _ _bindings.Enum = Error(0)

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 (_ Error) I_EnumValues() []Error {
	return []Error{
		ErrorInternal,
		ErrorNotSupported,
		ErrorInvalidArgs,
		ErrorBadState,
		ErrorTimeOut,
		ErrorNotFound,
		ErrorAlreadyExists,
		ErrorIo,
	}
}

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

func (x Error) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	case 3:
		return false
	case 4:
		return false
	case 5:
		return false
	case 6:
		return false
	case 7:
		return false
	case 8:
		return false
	default:
		return true
	}
}

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"
}

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

var _mStackAddEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(StackAddEthernetInterfaceResponse{})

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

type StackAddInterfaceResponse struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStackAddInterfaceResponse = _bindings.CreateLazyMarshaler(StackAddInterfaceResponse{})

func (msg *StackAddInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mStackAddInterfaceResponse
}

type StackDelEthernetInterfaceResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"96" fidl_alignment_v2:"8"`
	Info InterfaceInfo `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"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" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStackDisablePacketFilterResponse = _bindings.CreateLazyMarshaler(StackDisablePacketFilterResponse{})

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

type StackGetInterfaceIpForwardingResponse struct {
	_       struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
	Enabled bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mStackGetInterfaceIpForwardingResponse = _bindings.CreateLazyMarshaler(StackGetInterfaceIpForwardingResponse{})

func (msg *StackGetInterfaceIpForwardingResponse) Marshaler() _bindings.Marshaler {
	return _mStackGetInterfaceIpForwardingResponse
}

type StackSetInterfaceIpForwardingResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mStackSetInterfaceIpForwardingResponse = _bindings.CreateLazyMarshaler(StackSetInterfaceIpForwardingResponse{})

func (msg *StackSetInterfaceIpForwardingResponse) Marshaler() _bindings.Marshaler {
	return _mStackSetInterfaceIpForwardingResponse
}

type InterfaceInfo struct {
	_ struct{} `fidl:"s" fidl_size_v1:"96" fidl_alignment_v1:"8" fidl_size_v2:"96" fidl_alignment_v2:"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" fidl_offset_v2:"0"`
	// All info of an interface except the interface name.
	Properties InterfaceProperties `fidl_offset_v1:"8" fidl_offset_v2:"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" fidl_size_v2:"88" fidl_alignment_v2:"8"`
	// Human-readable name of the interface. eg. eth001, wlanx35.
	Name string `fidl_offset_v1:"0" fidl_offset_v2:"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_offset_v2:"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_offset_v2:"32" fidl_bounds:"255"`
	// The MAC address of the interface, if available.
	Mac *fuchsiahardwareethernet.MacAddress `fidl_offset_v1:"48" fidl_offset_v2:"48"`
	// The maximum transmission unit for the interface in bytes.
	Mtu uint32 `fidl_offset_v1:"56" fidl_offset_v2:"56"`
	// The features present on the interface.
	Features fuchsiahardwareethernet.Features `fidl_offset_v1:"60" fidl_offset_v2:"60"`
	// The administrative status of the interface.
	AdministrativeStatus AdministrativeStatus `fidl_offset_v1:"64" fidl_offset_v2:"64"`
	// The physical link status of the interface.
	PhysicalStatus PhysicalStatus `fidl_offset_v1:"68" fidl_offset_v2:"68"`
	// The list of addresses currently assigned to the interface.
	Addresses []fuchsianet.Subnet `fidl_offset_v1:"72" fidl_offset_v2:"72" fidl_bounds:""`
}

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" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	// The subnet is the key for the entry in the table.
	Subnet fuchsianet.Subnet `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	// The destination that will receive the forwarded packet.
	Destination ForwardingDestination `fidl_offset_v1:"32" fidl_offset_v2:"24"`
}

var _mForwardingEntry = _bindings.CreateLazyMarshaler(ForwardingEntry{})

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

// An Ethernet device.
// The provided `network_device` is expected to support `Ethernet` frames.
// Its MAC address and MAC filtering is controlled by the provided `mac` channel.
type EthernetDeviceDefinition struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"4" fidl_size_v2:"8" fidl_alignment_v2:"4"`
	// The connection to the device's data plane.
	NetworkDevice fuchsiahardwarenetwork.DeviceWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
	// The connection to the device's addressing control plane.
	Mac fuchsiahardwarenetwork.MacAddressingWithCtxInterface `fidl_offset_v1:"4" fidl_offset_v2:"4" fidl_handle_subtype:"4"`
}

var _mEthernetDeviceDefinition = _bindings.CreateLazyMarshaler(EthernetDeviceDefinition{})

func (msg *EthernetDeviceDefinition) Marshaler() _bindings.Marshaler {
	return _mEthernetDeviceDefinition
}

type stackWithCtxAddEthernetInterfaceRequest struct {
	_               struct{}                                       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	TopologicalPath string                                         `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:"255"`
	Device          fuchsiahardwareethernet.DeviceWithCtxInterface `fidl_offset_v1:"16" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackAddEthernetInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstackWithCtxAddEthernetInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxAddEthernetInterfaceResponse{})

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

type stackWithCtxAddInterfaceRequest struct {
	_      struct{}         `fidl:"s" fidl_size_v1:"40" fidl_alignment_v1:"8" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Config InterfaceConfig  `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Device DeviceDefinition `fidl_offset_v1:"16" fidl_offset_v2:"16"`
}

var _mstackWithCtxAddInterfaceRequest = _bindings.CreateLazyMarshaler(stackWithCtxAddInterfaceRequest{})

func (msg *stackWithCtxAddInterfaceRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddInterfaceRequest
}

type stackWithCtxAddInterfaceResponse struct {
	_      struct{}                `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackAddInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstackWithCtxAddInterfaceResponse = _bindings.CreateLazyMarshaler(stackWithCtxAddInterfaceResponse{})

func (msg *stackWithCtxAddInterfaceResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxAddInterfaceResponse
}

type stackWithCtxDelEthernetInterfaceRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackDelEthernetInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Ifs []InterfaceInfo `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackGetInterfaceInfoResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackEnableInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackDisableInterfaceResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Id   uint64            `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Addr fuchsianet.Subnet `fidl_offset_v1:"8" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackAddInterfaceAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	Id   uint64            `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	Addr fuchsianet.Subnet `fidl_offset_v1:"8" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackDelInterfaceAddressResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Table []ForwardingEntry `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"40" fidl_alignment_v2:"8"`
	Entry ForwardingEntry `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackAddForwardingEntryResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	Subnet fuchsianet.Subnet `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackDelForwardingEntryResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackEnablePacketFilterResult `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Id uint64   `fidl_offset_v1:"0" fidl_offset_v2:"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" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackDisablePacketFilterResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstackWithCtxDisablePacketFilterResponse = _bindings.CreateLazyMarshaler(stackWithCtxDisablePacketFilterResponse{})

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

type stackWithCtxGetInterfaceIpForwardingRequest struct {
	_         struct{}             `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Id        uint64               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	IpVersion fuchsianet.IpVersion `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}

var _mstackWithCtxGetInterfaceIpForwardingRequest = _bindings.CreateLazyMarshaler(stackWithCtxGetInterfaceIpForwardingRequest{})

func (msg *stackWithCtxGetInterfaceIpForwardingRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetInterfaceIpForwardingRequest
}

type stackWithCtxGetInterfaceIpForwardingResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackGetInterfaceIpForwardingResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstackWithCtxGetInterfaceIpForwardingResponse = _bindings.CreateLazyMarshaler(stackWithCtxGetInterfaceIpForwardingResponse{})

func (msg *stackWithCtxGetInterfaceIpForwardingResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetInterfaceIpForwardingResponse
}

type stackWithCtxSetInterfaceIpForwardingRequest struct {
	_         struct{}             `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Id        uint64               `fidl_offset_v1:"0" fidl_offset_v2:"0"`
	IpVersion fuchsianet.IpVersion `fidl_offset_v1:"8" fidl_offset_v2:"8"`
	Enabled   bool                 `fidl_offset_v1:"12" fidl_offset_v2:"12"`
}

var _mstackWithCtxSetInterfaceIpForwardingRequest = _bindings.CreateLazyMarshaler(stackWithCtxSetInterfaceIpForwardingRequest{})

func (msg *stackWithCtxSetInterfaceIpForwardingRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxSetInterfaceIpForwardingRequest
}

type stackWithCtxSetInterfaceIpForwardingResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result StackSetInterfaceIpForwardingResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mstackWithCtxSetInterfaceIpForwardingResponse = _bindings.CreateLazyMarshaler(stackWithCtxSetInterfaceIpForwardingResponse{})

func (msg *stackWithCtxSetInterfaceIpForwardingResponse) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxSetInterfaceIpForwardingResponse
}

type stackWithCtxGetDnsServerWatcherRequest struct {
	_       struct{}                                               `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Watcher fuchsianetname.DnsServerWatcherWithCtxInterfaceRequest `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mstackWithCtxGetDnsServerWatcherRequest = _bindings.CreateLazyMarshaler(stackWithCtxGetDnsServerWatcherRequest{})

func (msg *stackWithCtxGetDnsServerWatcherRequest) Marshaler() _bindings.Marshaler {
	return _mstackWithCtxGetDnsServerWatcherRequest
}

type logWithCtxSetLogPacketsRequest struct {
	_       struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Enabled bool     `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}

var _mlogWithCtxSetLogPacketsRequest = _bindings.CreateLazyMarshaler(logWithCtxSetLogPacketsRequest{})

func (msg *logWithCtxSetLogPacketsRequest) Marshaler() _bindings.Marshaler {
	return _mlogWithCtxSetLogPacketsRequest
}

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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             StackAddEthernetInterfaceResponse `fidl_ordinal:"1"`
	Err                                  Error                             `fidl_ordinal:"2"`
}

func (_m *StackAddEthernetInterfaceResult) reset() {
	switch _m.I_stackAddEthernetInterfaceResultTag {
	case 1:
		var _zeroed StackAddEthernetInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_m.I_stackAddEthernetInterfaceResultTag = StackAddEthernetInterfaceResultErr
	_m.Err = err
}

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

type I_stackAddInterfaceResultTag uint64

const (
	StackAddInterfaceResultResponse = 1 // 0x00000001
	StackAddInterfaceResultErr      = 2 // 0x00000002
)

type StackAddInterfaceResult struct {
	I_stackAddInterfaceResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                     StackAddInterfaceResponse `fidl_ordinal:"1"`
	Err                          Error                     `fidl_ordinal:"2"`
}

func (_m *StackAddInterfaceResult) reset() {
	switch _m.I_stackAddInterfaceResultTag {
	case 1:
		var _zeroed StackAddInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

func (_m *StackAddInterfaceResult) Which() I_stackAddInterfaceResultTag {
	return _m.I_stackAddInterfaceResultTag
}

func (_m *StackAddInterfaceResult) Ordinal() uint64 {
	return uint64(_m.I_stackAddInterfaceResultTag)
}

func (_m *StackAddInterfaceResult) SetResponse(response StackAddInterfaceResponse) {
	_m.reset()
	_m.I_stackAddInterfaceResultTag = StackAddInterfaceResultResponse
	_m.Response = response
}

func StackAddInterfaceResultWithResponse(response StackAddInterfaceResponse) StackAddInterfaceResult {
	var _u StackAddInterfaceResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackAddInterfaceResult) SetErr(err Error) {
	_m.reset()
	_m.I_stackAddInterfaceResultTag = StackAddInterfaceResultErr
	_m.Err = err
}

func StackAddInterfaceResultWithErr(err Error) StackAddInterfaceResult {
	var _u StackAddInterfaceResult
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                             StackDelEthernetInterfaceResponse `fidl_ordinal:"1"`
	Err                                  Error                             `fidl_ordinal:"2"`
}

func (_m *StackDelEthernetInterfaceResult) reset() {
	switch _m.I_stackDelEthernetInterfaceResultTag {
	case 1:
		var _zeroed StackDelEthernetInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         StackGetInterfaceInfoResponse `fidl_ordinal:"1"`
	Err                              Error                         `fidl_ordinal:"2"`
}

func (_m *StackGetInterfaceInfoResult) reset() {
	switch _m.I_stackGetInterfaceInfoResultTag {
	case 1:
		var _zeroed StackGetInterfaceInfoResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                        StackEnableInterfaceResponse `fidl_ordinal:"1"`
	Err                             Error                        `fidl_ordinal:"2"`
}

func (_m *StackEnableInterfaceResult) reset() {
	switch _m.I_stackEnableInterfaceResultTag {
	case 1:
		var _zeroed StackEnableInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                         StackDisableInterfaceResponse `fidl_ordinal:"1"`
	Err                              Error                         `fidl_ordinal:"2"`
}

func (_m *StackDisableInterfaceResult) reset() {
	switch _m.I_stackDisableInterfaceResultTag {
	case 1:
		var _zeroed StackDisableInterfaceResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            StackAddInterfaceAddressResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackAddInterfaceAddressResult) reset() {
	switch _m.I_stackAddInterfaceAddressResultTag {
	case 1:
		var _zeroed StackAddInterfaceAddressResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            StackDelInterfaceAddressResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackDelInterfaceAddressResult) reset() {
	switch _m.I_stackDelInterfaceAddressResultTag {
	case 1:
		var _zeroed StackDelInterfaceAddressResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           StackAddForwardingEntryResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackAddForwardingEntryResult) reset() {
	switch _m.I_stackAddForwardingEntryResultTag {
	case 1:
		var _zeroed StackAddForwardingEntryResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           StackDelForwardingEntryResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackDelForwardingEntryResult) reset() {
	switch _m.I_stackDelForwardingEntryResultTag {
	case 1:
		var _zeroed StackDelForwardingEntryResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                           StackEnablePacketFilterResponse `fidl_ordinal:"1"`
	Err                                Error                           `fidl_ordinal:"2"`
}

func (_m *StackEnablePacketFilterResult) reset() {
	switch _m.I_stackEnablePacketFilterResultTag {
	case 1:
		var _zeroed StackEnablePacketFilterResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                            StackDisablePacketFilterResponse `fidl_ordinal:"1"`
	Err                                 Error                            `fidl_ordinal:"2"`
}

func (_m *StackDisablePacketFilterResult) reset() {
	switch _m.I_stackDisablePacketFilterResultTag {
	case 1:
		var _zeroed StackDisablePacketFilterResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

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.reset()
	_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.reset()
	_m.I_stackDisablePacketFilterResultTag = StackDisablePacketFilterResultErr
	_m.Err = err
}

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

type I_stackGetInterfaceIpForwardingResultTag uint64

const (
	StackGetInterfaceIpForwardingResultResponse = 1 // 0x00000001
	StackGetInterfaceIpForwardingResultErr      = 2 // 0x00000002
)

type StackGetInterfaceIpForwardingResult struct {
	I_stackGetInterfaceIpForwardingResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StackGetInterfaceIpForwardingResponse `fidl_ordinal:"1"`
	Err                                      Error                                 `fidl_ordinal:"2"`
}

func (_m *StackGetInterfaceIpForwardingResult) reset() {
	switch _m.I_stackGetInterfaceIpForwardingResultTag {
	case 1:
		var _zeroed StackGetInterfaceIpForwardingResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

func (_m *StackGetInterfaceIpForwardingResult) Which() I_stackGetInterfaceIpForwardingResultTag {
	return _m.I_stackGetInterfaceIpForwardingResultTag
}

func (_m *StackGetInterfaceIpForwardingResult) Ordinal() uint64 {
	return uint64(_m.I_stackGetInterfaceIpForwardingResultTag)
}

func (_m *StackGetInterfaceIpForwardingResult) SetResponse(response StackGetInterfaceIpForwardingResponse) {
	_m.reset()
	_m.I_stackGetInterfaceIpForwardingResultTag = StackGetInterfaceIpForwardingResultResponse
	_m.Response = response
}

func StackGetInterfaceIpForwardingResultWithResponse(response StackGetInterfaceIpForwardingResponse) StackGetInterfaceIpForwardingResult {
	var _u StackGetInterfaceIpForwardingResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackGetInterfaceIpForwardingResult) SetErr(err Error) {
	_m.reset()
	_m.I_stackGetInterfaceIpForwardingResultTag = StackGetInterfaceIpForwardingResultErr
	_m.Err = err
}

func StackGetInterfaceIpForwardingResultWithErr(err Error) StackGetInterfaceIpForwardingResult {
	var _u StackGetInterfaceIpForwardingResult
	_u.SetErr(err)
	return _u
}

type I_stackSetInterfaceIpForwardingResultTag uint64

const (
	StackSetInterfaceIpForwardingResultResponse = 1 // 0x00000001
	StackSetInterfaceIpForwardingResultErr      = 2 // 0x00000002
)

type StackSetInterfaceIpForwardingResult struct {
	I_stackSetInterfaceIpForwardingResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                 StackSetInterfaceIpForwardingResponse `fidl_ordinal:"1"`
	Err                                      Error                                 `fidl_ordinal:"2"`
}

func (_m *StackSetInterfaceIpForwardingResult) reset() {
	switch _m.I_stackSetInterfaceIpForwardingResultTag {
	case 1:
		var _zeroed StackSetInterfaceIpForwardingResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed Error
		_m.Err = _zeroed
	}
}

func (_m *StackSetInterfaceIpForwardingResult) Which() I_stackSetInterfaceIpForwardingResultTag {
	return _m.I_stackSetInterfaceIpForwardingResultTag
}

func (_m *StackSetInterfaceIpForwardingResult) Ordinal() uint64 {
	return uint64(_m.I_stackSetInterfaceIpForwardingResultTag)
}

func (_m *StackSetInterfaceIpForwardingResult) SetResponse(response StackSetInterfaceIpForwardingResponse) {
	_m.reset()
	_m.I_stackSetInterfaceIpForwardingResultTag = StackSetInterfaceIpForwardingResultResponse
	_m.Response = response
}

func StackSetInterfaceIpForwardingResultWithResponse(response StackSetInterfaceIpForwardingResponse) StackSetInterfaceIpForwardingResult {
	var _u StackSetInterfaceIpForwardingResult
	_u.SetResponse(response)
	return _u
}

func (_m *StackSetInterfaceIpForwardingResult) SetErr(err Error) {
	_m.reset()
	_m.I_stackSetInterfaceIpForwardingResultTag = StackSetInterfaceIpForwardingResultErr
	_m.Err = err
}

func StackSetInterfaceIpForwardingResultWithErr(err Error) StackSetInterfaceIpForwardingResult {
	var _u StackSetInterfaceIpForwardingResult
	_u.SetErr(err)
	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" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	// 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) reset() {
	switch _m.I_forwardingDestinationTag {
	case 1:
		var _zeroed uint64
		_m.DeviceId = _zeroed
	case 2:
		var _zeroed fuchsianet.IpAddress
		_m.NextHop = _zeroed
	}
}

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.reset()
	_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.reset()
	_m.I_forwardingDestinationTag = ForwardingDestinationNextHop
	_m.NextHop = nextHop
}

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

type I_deviceDefinitionTag uint64

const (
	DeviceDefinitionIp       = 1 // 0x00000001
	DeviceDefinitionEthernet = 2 // 0x00000002
)

// Devices that can be used to back a `Stack` interface.
type DeviceDefinition struct {
	I_deviceDefinitionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	// A `fuchsia.hardware.network.Device` that exchanges only IP frames. It either doesn't have a
	// layer 2 or its layer 2 is irrelevant to the `Stack`.
	Ip fuchsiahardwarenetwork.DeviceWithCtxInterface `fidl_handle_subtype:"4" fidl_ordinal:"1"`
	// An Ethernet device.
	Ethernet EthernetDeviceDefinition `fidl_ordinal:"2"`
}

func (_m *DeviceDefinition) reset() {
	switch _m.I_deviceDefinitionTag {
	case 1:
		var _zeroed fuchsiahardwarenetwork.DeviceWithCtxInterface
		_m.Ip = _zeroed
	case 2:
		var _zeroed EthernetDeviceDefinition
		_m.Ethernet = _zeroed
	}
}

func (_m *DeviceDefinition) Which() I_deviceDefinitionTag {
	return _m.I_deviceDefinitionTag
}

func (_m *DeviceDefinition) Ordinal() uint64 {
	return uint64(_m.I_deviceDefinitionTag)
}

func (_m *DeviceDefinition) SetIp(ip fuchsiahardwarenetwork.DeviceWithCtxInterface) {
	_m.reset()
	_m.I_deviceDefinitionTag = DeviceDefinitionIp
	_m.Ip = ip
}

func DeviceDefinitionWithIp(ip fuchsiahardwarenetwork.DeviceWithCtxInterface) DeviceDefinition {
	var _u DeviceDefinition
	_u.SetIp(ip)
	return _u
}

func (_m *DeviceDefinition) SetEthernet(ethernet EthernetDeviceDefinition) {
	_m.reset()
	_m.I_deviceDefinitionTag = DeviceDefinitionEthernet
	_m.Ethernet = ethernet
}

func DeviceDefinitionWithEthernet(ethernet EthernetDeviceDefinition) DeviceDefinition {
	var _u DeviceDefinition
	_u.SetEthernet(ethernet)
	return _u
}

// Base configuration for `Stack` interfaces.
type InterfaceConfig struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// Human-readable name of the interface. eg. eth001, wlanx35.
	// Will be set to a default generic name if not provided.
	Name        string `fidl_bounds:"15" fidl_ordinal:"1"`
	NamePresent bool
	// The topological path to the device, representing a stable identifier for the interface
	// hardware.
	Topopath        string `fidl_bounds:"255" fidl_ordinal:"2"`
	TopopathPresent bool
	// The default metric value used for routes to this interface.
	Metric        uint32 `fidl_ordinal:"3"`
	MetricPresent bool
}

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

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

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

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

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

func (u *InterfaceConfig) SetTopopath(topopath string) {
	u.Topopath = topopath
	u.TopopathPresent = true
}

func (u *InterfaceConfig) GetTopopath() string {
	return u.Topopath
}

func (u *InterfaceConfig) GetTopopathWithDefault(_default string) string {
	if !u.HasTopopath() {
		return _default
	}
	return u.Topopath
}

func (u *InterfaceConfig) HasTopopath() bool {
	return u.TopopathPresent
}

func (u *InterfaceConfig) ClearTopopath() {
	u.TopopathPresent = false
}

func (u *InterfaceConfig) SetMetric(metric uint32) {
	u.Metric = metric
	u.MetricPresent = true
}

func (u *InterfaceConfig) GetMetric() uint32 {
	return u.Metric
}

func (u *InterfaceConfig) GetMetricWithDefault(_default uint32) uint32 {
	if !u.HasMetric() {
		return _default
	}
	return u.Metric
}

func (u *InterfaceConfig) HasMetric() bool {
	return u.MetricPresent
}

func (u *InterfaceConfig) ClearMetric() {
	u.MetricPresent = false
}

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

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

const (
	StackAddEthernetInterfaceOrdinal     uint64 = 0x5f5733e9cf647a5b
	StackAddInterfaceOrdinal             uint64 = 0x16c731272a79a2c9
	StackDelEthernetInterfaceOrdinal     uint64 = 0x1e7f3b1fe503a8eb
	StackListInterfacesOrdinal           uint64 = 0x7858623a6d268864
	StackGetInterfaceInfoOrdinal         uint64 = 0x55567267dd660333
	StackEnableInterfaceOrdinal          uint64 = 0x2723e7e9dabca8f2
	StackDisableInterfaceOrdinal         uint64 = 0x1703c5cf0b2f4d87
	StackAddInterfaceAddressOrdinal      uint64 = 0x6c21cb598c262ea3
	StackDelInterfaceAddressOrdinal      uint64 = 0x73159e96f5537eed
	StackGetForwardingTableOrdinal       uint64 = 0x6df035986328d2ef
	StackAddForwardingEntryOrdinal       uint64 = 0x5fe2020877107909
	StackDelForwardingEntryOrdinal       uint64 = 0x560f3944c4cb51bd
	StackEnablePacketFilterOrdinal       uint64 = 0x1fbd56c90ca0b19d
	StackDisablePacketFilterOrdinal      uint64 = 0x40743d436c82c863
	StackEnableIpForwardingOrdinal       uint64 = 0x28e1915a9b177e6c
	StackDisableIpForwardingOrdinal      uint64 = 0x477f3f3bb42cf1f4
	StackGetInterfaceIpForwardingOrdinal uint64 = 0x24c9c8f3ce16089c
	StackSetInterfaceIpForwardingOrdinal uint64 = 0x79ae7727d73938c9
	StackGetDnsServerWatcherOrdinal      uint64 = 0x14cf0817fc2cf386
)

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(StackAddEthernetInterfaceOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Add a new interface to the network stack backed by the provided `DeviceDefinition`. On
// success, returns the identifier assigned by the stack for use in subsequent calls.
func (p *StackWithCtxInterface) AddInterface(ctx_ _bindings.Context, config InterfaceConfig, device DeviceDefinition) (StackAddInterfaceResult, error) {
	req_ := &stackWithCtxAddInterfaceRequest{
		Config: config,
		Device: device,
	}
	resp_ := &stackWithCtxAddInterfaceResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddInterfaceOrdinal, req_, resp_)
	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(StackDelEthernetInterfaceOrdinal, req_, resp_)
	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(StackListInterfacesOrdinal, req_, resp_)
	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(StackGetInterfaceInfoOrdinal, req_, resp_)
	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(StackEnableInterfaceOrdinal, req_, resp_)
	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(StackDisableInterfaceOrdinal, req_, resp_)
	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 fuchsianet.Subnet) (StackAddInterfaceAddressResult, error) {
	req_ := &stackWithCtxAddInterfaceAddressRequest{
		Id:   id,
		Addr: addr,
	}
	resp_ := &stackWithCtxAddInterfaceAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddInterfaceAddressOrdinal, req_, resp_)
	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 fuchsianet.Subnet) (StackDelInterfaceAddressResult, error) {
	req_ := &stackWithCtxDelInterfaceAddressRequest{
		Id:   id,
		Addr: addr,
	}
	resp_ := &stackWithCtxDelInterfaceAddressResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackDelInterfaceAddressOrdinal, req_, resp_)
	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(StackGetForwardingTableOrdinal, req_, resp_)
	return resp_.Table, err_
}

// Add a new entry to the forwarding table.
//
// If the table already contains an entry with the same subnet and destination, an already
// exists error is returned.
func (p *StackWithCtxInterface) AddForwardingEntry(ctx_ _bindings.Context, entry ForwardingEntry) (StackAddForwardingEntryResult, error) {
	req_ := &stackWithCtxAddForwardingEntryRequest{
		Entry: entry,
	}
	resp_ := &stackWithCtxAddForwardingEntryResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackAddForwardingEntryOrdinal, req_, resp_)
	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(StackDelForwardingEntryOrdinal, req_, resp_)
	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(StackEnablePacketFilterOrdinal, req_, resp_)
	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(StackDisablePacketFilterOrdinal, req_, resp_)
	return resp_.Result, err_
}

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

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

// Returns the IP forwarding state for an interface.
func (p *StackWithCtxInterface) GetInterfaceIpForwarding(ctx_ _bindings.Context, id uint64, ipVersion fuchsianet.IpVersion) (StackGetInterfaceIpForwardingResult, error) {
	req_ := &stackWithCtxGetInterfaceIpForwardingRequest{
		Id:        id,
		IpVersion: ipVersion,
	}
	resp_ := &stackWithCtxGetInterfaceIpForwardingResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackGetInterfaceIpForwardingOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Sets the IP forwarding state for an interface.
func (p *StackWithCtxInterface) SetInterfaceIpForwarding(ctx_ _bindings.Context, id uint64, ipVersion fuchsianet.IpVersion, enabled bool) (StackSetInterfaceIpForwardingResult, error) {
	req_ := &stackWithCtxSetInterfaceIpForwardingRequest{
		Id:        id,
		IpVersion: ipVersion,
		Enabled:   enabled,
	}
	resp_ := &stackWithCtxSetInterfaceIpForwardingResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(StackSetInterfaceIpForwardingOrdinal, req_, resp_)
	return resp_.Result, err_
}

// Get a [`fuchsia.net.name/DnsServerWatcher`].
func (p *StackWithCtxInterface) GetDnsServerWatcher(ctx_ _bindings.Context, watcher fuchsianetname.DnsServerWatcherWithCtxInterfaceRequest) error {
	req_ := &stackWithCtxGetDnsServerWatcherRequest{
		Watcher: watcher,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(StackGetDnsServerWatcherOrdinal, req_)
	return 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)
	// Add a new interface to the network stack backed by the provided `DeviceDefinition`. On
	// success, returns the identifier assigned by the stack for use in subsequent calls.
	AddInterface(ctx_ _bindings.Context, config InterfaceConfig, device DeviceDefinition) (StackAddInterfaceResult, 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 fuchsianet.Subnet) (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 fuchsianet.Subnet) (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 and destination, an already
	// exists error is returned.
	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 for all interfaces and IP versions.
	EnableIpForwarding(ctx_ _bindings.Context) error
	// Disable IP Forwarding for all interfaces and IP versions.
	DisableIpForwarding(ctx_ _bindings.Context) error
	// Returns the IP forwarding state for an interface.
	GetInterfaceIpForwarding(ctx_ _bindings.Context, id uint64, ipVersion fuchsianet.IpVersion) (StackGetInterfaceIpForwardingResult, error)
	// Sets the IP forwarding state for an interface.
	SetInterfaceIpForwarding(ctx_ _bindings.Context, id uint64, ipVersion fuchsianet.IpVersion, enabled bool) (StackSetInterfaceIpForwardingResult, error)
	// Get a [`fuchsia.net.name/DnsServerWatcher`].
	GetDnsServerWatcher(ctx_ _bindings.Context, watcher fuchsianetname.DnsServerWatcherWithCtxInterfaceRequest) error
}

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:
		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 StackAddInterfaceOrdinal:
		in_ := stackWithCtxAddInterfaceRequest{}
		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.AddInterface(args_.Ctx, in_.Config, in_.Device)
		out_ := stackWithCtxAddInterfaceResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackDelEthernetInterfaceOrdinal:
		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:
		ifs, err_ := s_.Impl.ListInterfaces(args_.Ctx)
		out_ := stackWithCtxListInterfacesResponse{}
		out_.Ifs = ifs
		return &out_, true, err_
	case StackGetInterfaceInfoOrdinal:
		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:
		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:
		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:
		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:
		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:
		table, err_ := s_.Impl.GetForwardingTable(args_.Ctx)
		out_ := stackWithCtxGetForwardingTableResponse{}
		out_.Table = table
		return &out_, true, err_
	case StackAddForwardingEntryOrdinal:
		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:
		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:
		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:
		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:
		err_ := s_.Impl.EnableIpForwarding(args_.Ctx)
		return nil, true, err_
	case StackDisableIpForwardingOrdinal:
		err_ := s_.Impl.DisableIpForwarding(args_.Ctx)
		return nil, true, err_
	case StackGetInterfaceIpForwardingOrdinal:
		in_ := stackWithCtxGetInterfaceIpForwardingRequest{}
		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.GetInterfaceIpForwarding(args_.Ctx, in_.Id, in_.IpVersion)
		out_ := stackWithCtxGetInterfaceIpForwardingResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackSetInterfaceIpForwardingOrdinal:
		in_ := stackWithCtxSetInterfaceIpForwardingRequest{}
		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.SetInterfaceIpForwarding(args_.Ctx, in_.Id, in_.IpVersion, in_.Enabled)
		out_ := stackWithCtxSetInterfaceIpForwardingResponse{}
		out_.Result = result
		return &out_, true, err_
	case StackGetDnsServerWatcherOrdinal:
		in_ := stackWithCtxGetDnsServerWatcherRequest{}
		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_
		}
		err_ := s_.Impl.GetDnsServerWatcher(args_.Ctx, in_.Watcher)
		return nil, false, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type StackEventProxy _bindings.ChannelProxy

const (
	LogSetLogPacketsOrdinal uint64 = 0x2176044cba5f378e
)

type LogWithCtxInterface _bindings.ChannelProxy

// Dynamically set packet logging.
func (p *LogWithCtxInterface) SetLogPackets(ctx_ _bindings.Context, enabled bool) error {
	req_ := &logWithCtxSetLogPacketsRequest{
		Enabled: enabled,
	}
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(LogSetLogPacketsOrdinal, req_, resp_)
	return err_
}

type LogWithCtx interface {
	// Dynamically set packet logging.
	SetLogPackets(ctx_ _bindings.Context, enabled bool) 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 LogSetLogPacketsOrdinal:
		in_ := logWithCtxSetLogPacketsRequest{}
		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_
		}
		err_ := s_.Impl.SetLogPackets(args_.Ctx, in_.Enabled)
		return nil, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type LogEventProxy _bindings.ChannelProxy