// Code generated by fidlgen; DO NOT EDIT.

package doccomments

import (
	_bindings "syscall/zx/fidl"
)

const (
	// const comment #1
	//
	// const comment #3
	C int32 = 4
)

var _ _bindings.Enum = MyStrictEnum(0)

// strict enum comment #1.
//
// strict enum comment #2.
type MyStrictEnum uint32

const (

	// FOO member comment #1
	//
	// FOO member comment #3
	MyStrictEnumFoo MyStrictEnum = 1

	// BAR member comment #1
	//
	// BAR member comment #3
	MyStrictEnumBar MyStrictEnum = 2
)

func (_ MyStrictEnum) I_EnumValues() []MyStrictEnum {
	return []MyStrictEnum{
		MyStrictEnumFoo,
		MyStrictEnumBar,
	}
}

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

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

func (x MyStrictEnum) String() string {
	switch x {
	case 1:
		return "Foo"
	case 2:
		return "Bar"
	}
	return "Unknown"
}

var _ _bindings.Enum = MyFlexibleEnum(0)

// flexible enum comment #1.
//
// flexible enum comment #2.
type MyFlexibleEnum uint32

const (

	// FOO member comment #1
	//
	// FOO member comment #3
	MyFlexibleEnumFoo MyFlexibleEnum = 1

	// BAR member comment #1
	//
	// BAR member comment #3
	MyFlexibleEnumBar MyFlexibleEnum = 2

	// MyFlexibleEnum_Unknown is the default unknown placeholder.
	MyFlexibleEnum_Unknown MyFlexibleEnum = 0xffffffff
)

func (_ MyFlexibleEnum) I_EnumValues() []MyFlexibleEnum {
	return []MyFlexibleEnum{
		MyFlexibleEnumFoo,
		MyFlexibleEnumBar,
	}
}

func (_ MyFlexibleEnum) I_EnumIsStrict() bool {
	return false
}

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

func (x MyFlexibleEnum) String() string {
	switch x {
	case 1:
		return "Foo"
	case 2:
		return "Bar"
	}
	return "Unknown"
}

var _ _bindings.Bits = MyStrictBits(0)

// strict bits comment #1
//
// strict bits comment #2
type MyStrictBits uint32

const (
	MyStrictBitsMyFirstBit MyStrictBits = 1
	MyStrictBitsMyOtherBit MyStrictBits = 2
	MyStrictBits_Mask      MyStrictBits = 3
)

func (_ MyStrictBits) I_BitsMask() MyStrictBits {
	return MyStrictBits_Mask
}

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

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

func (x MyStrictBits) GetUnknownBits() uint64 {
	return uint64(^MyStrictBits_Mask & x)
}

func (x MyStrictBits) InvertBits() MyStrictBits {
	return MyStrictBits_Mask & ^x
}

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

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

func (x MyStrictBits) String() string {
	switch x {
	case 1:
		return "MyFirstBit"
	case 2:
		return "MyOtherBit"
	}
	return "Unknown"
}

var _ _bindings.Bits = MyFlexibleBits(0)

// flexible bits comment #1
//
// flexible bits comment #2
type MyFlexibleBits uint32

const (
	MyFlexibleBitsMyFirstBit MyFlexibleBits = 1
	MyFlexibleBitsMyOtherBit MyFlexibleBits = 2
	MyFlexibleBits_Mask      MyFlexibleBits = 3
)

func (_ MyFlexibleBits) I_BitsMask() MyFlexibleBits {
	return MyFlexibleBits_Mask
}

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

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

func (x MyFlexibleBits) GetUnknownBits() uint64 {
	return uint64(^MyFlexibleBits_Mask & x)
}

func (x MyFlexibleBits) InvertBits() MyFlexibleBits {
	return MyFlexibleBits_Mask & ^x
}

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

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

func (x MyFlexibleBits) String() string {
	switch x {
	case 1:
		return "MyFirstBit"
	case 2:
		return "MyOtherBit"
	}
	return "Unknown"
}

// struct comment #1
//
// struct comment #3
type Struct struct {
	_ struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	// struct member comment #1
	//
	// struct member comment #3
	Field int32 `fidl_offset_v1:"0"`
}

var _mStruct = _bindings.CreateLazyMarshaler(Struct{})

func (msg *Struct) Marshaler() _bindings.Marshaler {
	return _mStruct
}

type I_strictUnionTag uint64

const (
	StrictUnionField = 1 // 0x00000001
)

// strict union comment #1
//
// strict union comment #3
type StrictUnion struct {
	I_strictUnionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	// union member comment #1
	//
	// union member comment #3
	Field int32 `fidl_ordinal:"1"`
}

func (_m *StrictUnion) reset() {
	switch _m.I_strictUnionTag {
	case 1:
		var _zeroed int32
		_m.Field = _zeroed
	}
}

func (_m *StrictUnion) Which() I_strictUnionTag {
	return _m.I_strictUnionTag
}

func (_m *StrictUnion) Ordinal() uint64 {
	return uint64(_m.I_strictUnionTag)
}

func (_m *StrictUnion) SetField(field int32) {
	_m.reset()
	_m.I_strictUnionTag = StrictUnionField
	_m.Field = field
}

func StrictUnionWithField(field int32) StrictUnion {
	var _u StrictUnion
	_u.SetField(field)
	return _u
}

type I_flexibleUnionTag uint64

const (
	FlexibleUnion_unknownData = 0 // 0x00000000
	FlexibleUnionField        = 1 // 0x00000001
)

// flexible union comment #1
//
// flexible union comment #3
type FlexibleUnion struct {
	I_flexibleUnionTag `fidl:"x" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData      interface{}
	// union member comment #1
	//
	// union member comment #3
	Field int32 `fidl_ordinal:"1"`
}

func (_m *FlexibleUnion) reset() {
	switch _m.I_flexibleUnionTag {
	case 1:
		var _zeroed int32
		_m.Field = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *FlexibleUnion) Which() I_flexibleUnionTag {
	switch _m.I_flexibleUnionTag {
	case 1:
		return FlexibleUnionField
	default:
		return FlexibleUnion_unknownData
	}
}

func (_m *FlexibleUnion) Ordinal() uint64 {
	return uint64(_m.I_flexibleUnionTag)
}

func (_m *FlexibleUnion) SetField(field int32) {
	_m.reset()
	_m.I_flexibleUnionTag = FlexibleUnionField
	_m.Field = field
}

func FlexibleUnionWithField(field int32) FlexibleUnion {
	var _u FlexibleUnion
	_u.SetField(field)
	return _u
}
func (_m *FlexibleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

// table comment #1
//
// table comment #3
type Table struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData interface{}
	// table field comment #1
	//
	// table field comment #3
	Field        int32 `fidl_ordinal:"1"`
	FieldPresent bool
}

func (u *Table) SetField(field int32) {
	u.Field = field
	u.FieldPresent = true
}

func (u *Table) GetField() int32 {
	return u.Field
}

func (u *Table) GetFieldWithDefault(_default int32) int32 {
	if !u.HasField() {
		return _default
	}
	return u.Field
}

func (u *Table) HasField() bool {
	return u.FieldPresent
}

func (u *Table) ClearField() {
	u.FieldPresent = false
}

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

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

const (
	InterfaceMethodOrdinal  uint64 = 0x5c492542705b4265
	InterfaceOnEventOrdinal uint64 = 0x37812b697096f6fa
)

type InterfaceWithCtxInterface _bindings.ChannelProxy

// method comment #1
//
// method comment #3
func (p *InterfaceWithCtxInterface) Method(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Send(InterfaceMethodOrdinal, req_)
	return err_
}

// event comment #1
//
// event comment #3
func (p *InterfaceWithCtxInterface) ExpectOnEvent(ctx_ _bindings.Context) error {
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(InterfaceOnEventOrdinal, resp_)
	return err_
}

// interface comment #1
//
// interface comment #3
type InterfaceWithCtx interface {
	// method comment #1
	//
	// method comment #3
	Method(ctx_ _bindings.Context) error
	// event comment #1
	//
	// event comment #3
}

type InterfaceWithCtxTransitionalBase struct{}

type InterfaceWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewInterfaceWithCtxInterfaceRequest() (InterfaceWithCtxInterfaceRequest, *InterfaceWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return InterfaceWithCtxInterfaceRequest(req), (*InterfaceWithCtxInterface)(cli), err
}

type InterfaceWithCtxStub struct {
	Impl InterfaceWithCtx
}

func (s_ *InterfaceWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case InterfaceMethodOrdinal:
		err_ := s_.Impl.Method(args_.Ctx)
		return nil, false, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type InterfaceEventProxy _bindings.ChannelProxy

func (p *InterfaceEventProxy) OnEvent() error {
	var event_ _bindings.Message
	return ((*_bindings.ChannelProxy)(p)).Send(InterfaceOnEventOrdinal, event_)
}