runtime/internal/flow/conn/conn.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: conn

package conn

import (
	"fmt"
	"v.io/v23/context"
	"v.io/v23/i18n"
	"v.io/v23/security"
	"v.io/v23/vdl"
	"v.io/v23/verror"
	"v.io/x/ref/lib/security/bcrypter"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// Blessings is used to transport blessings between the two ends of a Conn.
// Since blessings can be large, we try not to send them more than once by
// associating them with an integer key (BKey). Thereafter we refer to them
// by their key.
type Blessings struct {
	Blessings security.Blessings
	BKey      uint64
}

func (Blessings) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Blessings"`
}) {
}

func (m *Blessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var wireValue2 security.WireBlessings
	if err := security.WireBlessingsFromNative(&wireValue2, m.Blessings); err != nil {
		return err
	}

	var5 := true
	var var6 bool
	if len(wireValue2.CertificateChains) == 0 {
		var6 = true
	}
	var5 = var5 && var6
	if var5 {
		if err := fieldsTarget1.ZeroField("Blessings"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget3, fieldTarget4, err := fieldsTarget1.StartField("Blessings")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
				return err
			}
		}
	}
	var9 := (m.BKey == uint64(0))
	if var9 {
		if err := fieldsTarget1.ZeroField("BKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("BKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget8.FromUint(uint64(m.BKey), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Blessings) MakeVDLTarget() vdl.Target {
	return &BlessingsTarget{Value: m}
}

type BlessingsTarget struct {
	Value           *Blessings
	blessingsTarget security.WireBlessingsTarget
	bKeyTarget      vdl.Uint64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BlessingsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Blessings)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *BlessingsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Blessings":
		t.blessingsTarget.Value = &t.Value.Blessings
		target, err := &t.blessingsTarget, error(nil)
		return nil, target, err
	case "BKey":
		t.bKeyTarget.Value = &t.Value.BKey
		target, err := &t.bKeyTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.Blessings", name)
	}
}
func (t *BlessingsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *BlessingsTarget) ZeroField(name string) error {
	switch name {
	case "Blessings":
		t.Value.Blessings = func() security.Blessings {
			var native security.Blessings
			if err := vdl.Convert(&native, security.WireBlessings{}); err != nil {
				panic(err)
			}
			return native
		}()
		return nil
	case "BKey":
		t.Value.BKey = uint64(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.Blessings", name)
	}
}
func (t *BlessingsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *Blessings) VDLRead(dec vdl.Decoder) error {
	*x = Blessings{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "Blessings":
			match++
			var wire security.WireBlessings
			if err = wire.VDLRead(dec); err != nil {
				return err
			}
			if err = security.WireBlessingsToNative(wire, &x.Blessings); err != nil {
				return err
			}
		case "BKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.BKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// EncryptedBlessings is used to transport encrypted blessings between the
// two ends of a Conn. The encryption is with respect to a set of blessing
// patterns that define the set of peers that are allowed to see the blessings.
// Since encrypted blessings can be large, we try not to send them more than
// once by associating them with an integer key (BKey). Thereafter we refer to
// them by their key.
type EncryptedBlessings struct {
	Ciphertexts []bcrypter.WireCiphertext
	BKey        uint64
}

func (EncryptedBlessings) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedBlessings"`
}) {
}

func (m *EncryptedBlessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.Ciphertexts) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("Ciphertexts"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Ciphertexts")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Ciphertexts))
			if err != nil {
				return err
			}
			for i, elem7 := range m.Ciphertexts {
				elemTarget6, err := listTarget5.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget5.FinishElem(elemTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishList(listTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var10 := (m.BKey == uint64(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("BKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("BKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromUint(uint64(m.BKey), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *EncryptedBlessings) MakeVDLTarget() vdl.Target {
	return &EncryptedBlessingsTarget{Value: m}
}

type EncryptedBlessingsTarget struct {
	Value             *EncryptedBlessings
	ciphertextsTarget __VDLTarget1_list
	bKeyTarget        vdl.Uint64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *EncryptedBlessingsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*EncryptedBlessings)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *EncryptedBlessingsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Ciphertexts":
		t.ciphertextsTarget.Value = &t.Value.Ciphertexts
		target, err := &t.ciphertextsTarget, error(nil)
		return nil, target, err
	case "BKey":
		t.bKeyTarget.Value = &t.Value.BKey
		target, err := &t.bKeyTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.EncryptedBlessings", name)
	}
}
func (t *EncryptedBlessingsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *EncryptedBlessingsTarget) ZeroField(name string) error {
	switch name {
	case "Ciphertexts":
		t.Value.Ciphertexts = []bcrypter.WireCiphertext(nil)
		return nil
	case "BKey":
		t.Value.BKey = uint64(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.EncryptedBlessings", name)
	}
}
func (t *EncryptedBlessingsTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []bcrypter.WireCiphertext
type __VDLTarget1_list struct {
	Value      *[]bcrypter.WireCiphertext
	elemTarget bcrypter.WireCiphertextTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]bcrypter.WireCiphertext)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]bcrypter.WireCiphertext, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

func (x *EncryptedBlessings) VDLRead(dec vdl.Decoder) error {
	*x = EncryptedBlessings{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "Ciphertexts":
			match++
			if err = __VDLRead1_list(dec, &x.Ciphertexts); err != nil {
				return err
			}
		case "BKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.BKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead1_list(dec vdl.Decoder, x *[]bcrypter.WireCiphertext) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if k := dec.Type().Kind(); k != vdl.Array && k != vdl.List {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len == 0:
		*x = nil
	case len > 0:
		*x = make([]bcrypter.WireCiphertext, 0, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem bcrypter.WireCiphertext
		if err = elem.VDLRead(dec); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

// Discharges is used to transport discharges between the two ends of a Conn.
// Since discharges can be large, we try not to send them more than once by
// associating them with an integer key (DKey). Thereafter we refer to them
// by their key.
// Discharges also contains the BKey of the blessings with which the discharges
// are associated with.
type Discharges struct {
	Discharges []security.Discharge
	DKey       uint64
	BKey       uint64
}

func (Discharges) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.Discharges"`
}) {
}

func (m *Discharges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.Discharges) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("Discharges"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Discharges")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Discharges))
			if err != nil {
				return err
			}
			for i, elem7 := range m.Discharges {
				elemTarget6, err := listTarget5.StartElem(i)
				if err != nil {
					return err
				}

				var wireValue8 security.WireDischarge
				if err := security.WireDischargeFromNative(&wireValue8, elem7); err != nil {
					return err
				}

				unionValue9 := wireValue8
				if unionValue9 == nil {
					unionValue9 = security.WireDischargePublicKey{}
				}
				if err := unionValue9.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget5.FinishElem(elemTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishList(listTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var12 := (m.DKey == uint64(0))
	if var12 {
		if err := fieldsTarget1.ZeroField("DKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("DKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget11.FromUint(uint64(m.DKey), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
				return err
			}
		}
	}
	var15 := (m.BKey == uint64(0))
	if var15 {
		if err := fieldsTarget1.ZeroField("BKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("BKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget14.FromUint(uint64(m.BKey), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Discharges) MakeVDLTarget() vdl.Target {
	return &DischargesTarget{Value: m}
}

type DischargesTarget struct {
	Value            *Discharges
	dischargesTarget __VDLTarget2_list
	dKeyTarget       vdl.Uint64Target
	bKeyTarget       vdl.Uint64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *DischargesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Discharges)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *DischargesTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Discharges":
		t.dischargesTarget.Value = &t.Value.Discharges
		target, err := &t.dischargesTarget, error(nil)
		return nil, target, err
	case "DKey":
		t.dKeyTarget.Value = &t.Value.DKey
		target, err := &t.dKeyTarget, error(nil)
		return nil, target, err
	case "BKey":
		t.bKeyTarget.Value = &t.Value.BKey
		target, err := &t.bKeyTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.Discharges", name)
	}
}
func (t *DischargesTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *DischargesTarget) ZeroField(name string) error {
	switch name {
	case "Discharges":
		t.Value.Discharges = []security.Discharge(nil)
		return nil
	case "DKey":
		t.Value.DKey = uint64(0)
		return nil
	case "BKey":
		t.Value.BKey = uint64(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.Discharges", name)
	}
}
func (t *DischargesTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []security.Discharge
type __VDLTarget2_list struct {
	Value      *[]security.Discharge
	elemTarget security.WireDischargeTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget2_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]security.Discharge)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]security.Discharge, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget2_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget2_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

func (x *Discharges) VDLRead(dec vdl.Decoder) error {
	*x = Discharges{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "Discharges":
			match++
			if err = __VDLRead2_list(dec, &x.Discharges); err != nil {
				return err
			}
		case "DKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.DKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "BKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.BKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead2_list(dec vdl.Decoder, x *[]security.Discharge) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if k := dec.Type().Kind(); k != vdl.Array && k != vdl.List {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len == 0:
		*x = nil
	case len > 0:
		*x = make([]security.Discharge, 0, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem security.Discharge
		var wire security.WireDischarge
		if err = security.VDLReadWireDischarge(dec, &wire); err != nil {
			return err
		}
		if err = security.WireDischargeToNative(wire, &elem); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

// EncryptedDischarges is used to transport encrypted discharges between the
// two ends of a Conn. The encryption is with respect to a set of blessing
// patterns that define the set of peers that are allowed to see the discharges.
// Since discharges can be large, we try not to send them more than once by
// associating them with an integer key (DKey). Thereafter we refer to them
// by their key.
// EncryptedDischarges also contains the BKey of the blessings with which the
// plaintext discharges are associated with.
type EncryptedDischarges struct {
	Ciphertexts []bcrypter.WireCiphertext
	DKey        uint64
	BKey        uint64
}

func (EncryptedDischarges) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/runtime/internal/flow/conn.EncryptedDischarges"`
}) {
}

func (m *EncryptedDischarges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.Ciphertexts) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("Ciphertexts"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Ciphertexts")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Ciphertexts))
			if err != nil {
				return err
			}
			for i, elem7 := range m.Ciphertexts {
				elemTarget6, err := listTarget5.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget5.FinishElem(elemTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishList(listTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var10 := (m.DKey == uint64(0))
	if var10 {
		if err := fieldsTarget1.ZeroField("DKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("DKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget9.FromUint(uint64(m.DKey), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	var13 := (m.BKey == uint64(0))
	if var13 {
		if err := fieldsTarget1.ZeroField("BKey"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("BKey")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget12.FromUint(uint64(m.BKey), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *EncryptedDischarges) MakeVDLTarget() vdl.Target {
	return &EncryptedDischargesTarget{Value: m}
}

type EncryptedDischargesTarget struct {
	Value             *EncryptedDischarges
	ciphertextsTarget __VDLTarget1_list
	dKeyTarget        vdl.Uint64Target
	bKeyTarget        vdl.Uint64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *EncryptedDischargesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*EncryptedDischarges)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *EncryptedDischargesTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Ciphertexts":
		t.ciphertextsTarget.Value = &t.Value.Ciphertexts
		target, err := &t.ciphertextsTarget, error(nil)
		return nil, target, err
	case "DKey":
		t.dKeyTarget.Value = &t.Value.DKey
		target, err := &t.dKeyTarget, error(nil)
		return nil, target, err
	case "BKey":
		t.bKeyTarget.Value = &t.Value.BKey
		target, err := &t.bKeyTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.EncryptedDischarges", name)
	}
}
func (t *EncryptedDischargesTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *EncryptedDischargesTarget) ZeroField(name string) error {
	switch name {
	case "Ciphertexts":
		t.Value.Ciphertexts = []bcrypter.WireCiphertext(nil)
		return nil
	case "DKey":
		t.Value.DKey = uint64(0)
		return nil
	case "BKey":
		t.Value.BKey = uint64(0)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/runtime/internal/flow/conn.EncryptedDischarges", name)
	}
}
func (t *EncryptedDischargesTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *EncryptedDischarges) VDLRead(dec vdl.Decoder) error {
	*x = EncryptedDischarges{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "Ciphertexts":
			match++
			if err = __VDLRead1_list(dec, &x.Ciphertexts); err != nil {
				return err
			}
		case "DKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.DKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "BKey":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.BKey, err = dec.DecodeUint(64); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type (
	// BlessingsFlowMessage represents any single field of the BlessingsFlowMessage union type.
	//
	// BlessingsFlowMessage is used to send either a Blessings, Discharges, EncryptedBlessings
	// or EncryptedDischarges object over the wire.
	BlessingsFlowMessage interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the BlessingsFlowMessage union type.
		__VDLReflect(__BlessingsFlowMessageReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// BlessingsFlowMessageBlessings represents field Blessings of the BlessingsFlowMessage union type.
	BlessingsFlowMessageBlessings struct{ Value Blessings }
	// BlessingsFlowMessageDischarges represents field Discharges of the BlessingsFlowMessage union type.
	BlessingsFlowMessageDischarges struct{ Value Discharges }
	// BlessingsFlowMessageEncryptedBlessings represents field EncryptedBlessings of the BlessingsFlowMessage union type.
	BlessingsFlowMessageEncryptedBlessings struct{ Value EncryptedBlessings }
	// BlessingsFlowMessageEncryptedDischarges represents field EncryptedDischarges of the BlessingsFlowMessage union type.
	BlessingsFlowMessageEncryptedDischarges struct{ Value EncryptedDischarges }
	// __BlessingsFlowMessageReflect describes the BlessingsFlowMessage union type.
	__BlessingsFlowMessageReflect struct {
		Name               string `vdl:"v.io/x/ref/runtime/internal/flow/conn.BlessingsFlowMessage"`
		Type               BlessingsFlowMessage
		UnionTargetFactory blessingsFlowMessageTargetFactory
		Union              struct {
			Blessings           BlessingsFlowMessageBlessings
			Discharges          BlessingsFlowMessageDischarges
			EncryptedBlessings  BlessingsFlowMessageEncryptedBlessings
			EncryptedDischarges BlessingsFlowMessageEncryptedDischarges
		}
	}
)

func (x BlessingsFlowMessageBlessings) Index() int                                 { return 0 }
func (x BlessingsFlowMessageBlessings) Interface() interface{}                     { return x.Value }
func (x BlessingsFlowMessageBlessings) Name() string                               { return "Blessings" }
func (x BlessingsFlowMessageBlessings) __VDLReflect(__BlessingsFlowMessageReflect) {}

func (m BlessingsFlowMessageBlessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Blessings")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BlessingsFlowMessageBlessings) MakeVDLTarget() vdl.Target {
	return nil
}

func (x BlessingsFlowMessageDischarges) Index() int                                 { return 1 }
func (x BlessingsFlowMessageDischarges) Interface() interface{}                     { return x.Value }
func (x BlessingsFlowMessageDischarges) Name() string                               { return "Discharges" }
func (x BlessingsFlowMessageDischarges) __VDLReflect(__BlessingsFlowMessageReflect) {}

func (m BlessingsFlowMessageDischarges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Discharges")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BlessingsFlowMessageDischarges) MakeVDLTarget() vdl.Target {
	return nil
}

func (x BlessingsFlowMessageEncryptedBlessings) Index() int                                 { return 2 }
func (x BlessingsFlowMessageEncryptedBlessings) Interface() interface{}                     { return x.Value }
func (x BlessingsFlowMessageEncryptedBlessings) Name() string                               { return "EncryptedBlessings" }
func (x BlessingsFlowMessageEncryptedBlessings) __VDLReflect(__BlessingsFlowMessageReflect) {}

func (m BlessingsFlowMessageEncryptedBlessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("EncryptedBlessings")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(2).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BlessingsFlowMessageEncryptedBlessings) MakeVDLTarget() vdl.Target {
	return nil
}

func (x BlessingsFlowMessageEncryptedDischarges) Index() int                                 { return 3 }
func (x BlessingsFlowMessageEncryptedDischarges) Interface() interface{}                     { return x.Value }
func (x BlessingsFlowMessageEncryptedDischarges) Name() string                               { return "EncryptedDischarges" }
func (x BlessingsFlowMessageEncryptedDischarges) __VDLReflect(__BlessingsFlowMessageReflect) {}

func (m BlessingsFlowMessageEncryptedDischarges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("EncryptedDischarges")
	if err != nil {
		return err
	}

	if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(3).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BlessingsFlowMessageEncryptedDischarges) MakeVDLTarget() vdl.Target {
	return nil
}

type BlessingsFlowMessageTarget struct {
	Value     *BlessingsFlowMessage
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BlessingsFlowMessageTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*BlessingsFlowMessage)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *BlessingsFlowMessageTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "Blessings":
		val := Blessings{}
		return nil, &BlessingsTarget{Value: &val}, nil
	case "Discharges":
		val := Discharges{}
		return nil, &DischargesTarget{Value: &val}, nil
	case "EncryptedBlessings":
		val := EncryptedBlessings{}
		return nil, &EncryptedBlessingsTarget{Value: &val}, nil
	case "EncryptedDischarges":
		val := EncryptedDischarges{}
		return nil, &EncryptedDischargesTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/runtime/internal/flow/conn.BlessingsFlowMessage", name)
	}
}
func (t *BlessingsFlowMessageTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "Blessings":
		*t.Value = BlessingsFlowMessageBlessings{*(fieldTarget.(*BlessingsTarget)).Value}
	case "Discharges":
		*t.Value = BlessingsFlowMessageDischarges{*(fieldTarget.(*DischargesTarget)).Value}
	case "EncryptedBlessings":
		*t.Value = BlessingsFlowMessageEncryptedBlessings{*(fieldTarget.(*EncryptedBlessingsTarget)).Value}
	case "EncryptedDischarges":
		*t.Value = BlessingsFlowMessageEncryptedDischarges{*(fieldTarget.(*EncryptedDischargesTarget)).Value}
	}
	return nil
}
func (t *BlessingsFlowMessageTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type blessingsFlowMessageTargetFactory struct{}

func (t blessingsFlowMessageTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*BlessingsFlowMessage); ok {
		return &BlessingsFlowMessageTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *BlessingsFlowMessage", union)
}

func VDLReadBlessingsFlowMessage(dec vdl.Decoder, x *BlessingsFlowMessage) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Union {
		return fmt.Errorf("incompatible union %T, from %v", *x, dec.Type())
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "Blessings":
		var field BlessingsFlowMessageBlessings
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "Discharges":
		var field BlessingsFlowMessageDischarges
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "EncryptedBlessings":
		var field BlessingsFlowMessageEncryptedBlessings
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "EncryptedDischarges":
		var field BlessingsFlowMessageEncryptedDischarges
		if err = field.Value.VDLRead(dec); err != nil {
			return err
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

//////////////////////////////////////////////////
// Error definitions
var (
	ErrMissingSetupOption       = verror.Register("v.io/x/ref/runtime/internal/flow/conn.MissingSetupOption", verror.NoRetry, "{1:}{2:} missing required setup option{:3}.")
	ErrUnexpectedMsg            = verror.Register("v.io/x/ref/runtime/internal/flow/conn.UnexpectedMsg", verror.NoRetry, "{1:}{2:} unexpected message type{:3}.")
	ErrConnectionClosed         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ConnectionClosed", verror.NoRetry, "{1:}{2:} connection closed.")
	ErrRemoteError              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.RemoteError", verror.NoRetry, "{1:}{2:} remote end received err{:3}.")
	ErrSend                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Send", verror.NoRetry, "{1:}{2:} failure sending {3} message to {4}{:5}.")
	ErrRecv                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Recv", verror.NoRetry, "{1:}{2:} error reading from {3}{:4}")
	ErrCounterOverflow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CounterOverflow", verror.NoRetry, "{1:}{2:} A remote process has sent more data than allowed.")
	ErrBlessingsFlowClosed      = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsFlowClosed", verror.NoRetry, "{1:}{2:} The blessings flow was closed with error{:3}.")
	ErrInvalidChannelBinding    = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidChannelBinding", verror.NoRetry, "{1:}{2:} The channel binding was invalid.")
	ErrNoPublicKey              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPublicKey", verror.NoRetry, "{1:}{2:} No public key was received by the remote end.")
	ErrDialingNonServer         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialingNonServer", verror.NoRetry, "{1:}{2:} You are attempting to dial on a connection with no remote server.")
	ErrAcceptorBlessingsMissing = verror.Register("v.io/x/ref/runtime/internal/flow/conn.AcceptorBlessingsMissing", verror.NoRetry, "{1:}{2:} The acceptor did not send blessings.")
	ErrDialerBlessingsMissing   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialerBlessingsMissing", verror.NoRetry, "{1:}{2:} The dialer did not send blessings.")
	ErrBlessingsNotBound        = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsNotBound", verror.NoRetry, "{1:}{2:} blessings not bound to connection remote public key")
	ErrInvalidPeerFlow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidPeerFlow", verror.NoRetry, "{1:}{2:} peer has chosen flow id from local domain.")
	ErrChannelTimeout           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ChannelTimeout", verror.NoRetry, "{1:}{2:} the channel has become unresponsive.")
	ErrCannotDecryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptBlessings", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted blessings sent by peer{:3}")
	ErrCannotDecryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptDischarges", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted discharges sent by peer{:3}")
	ErrCannotEncryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptBlessings", verror.NoRetry, "{1:}{2:} cannot encyrpt blessings for peer {3}{:4}")
	ErrCannotEncryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptDischarges", verror.NoRetry, "{1:}{2:} cannot encrypt discharges for peers {3}{:4}")
	ErrNoCrypter                = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoCrypter", verror.NoRetry, "{1:}{2:} no blessings-based crypter available")
	ErrNoPrivateKey             = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPrivateKey", verror.NoRetry, "{1:}{2:} no blessings private key available for decryption")
	ErrIdleConnKilled           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.IdleConnKilled", verror.NoRetry, "{1:}{2:} Connection killed because idle expiry was reached.")
)

// NewErrMissingSetupOption returns an error with the ErrMissingSetupOption ID.
func NewErrMissingSetupOption(ctx *context.T, option string) error {
	return verror.New(ErrMissingSetupOption, ctx, option)
}

// NewErrUnexpectedMsg returns an error with the ErrUnexpectedMsg ID.
func NewErrUnexpectedMsg(ctx *context.T, typ string) error {
	return verror.New(ErrUnexpectedMsg, ctx, typ)
}

// NewErrConnectionClosed returns an error with the ErrConnectionClosed ID.
func NewErrConnectionClosed(ctx *context.T) error {
	return verror.New(ErrConnectionClosed, ctx)
}

// NewErrRemoteError returns an error with the ErrRemoteError ID.
func NewErrRemoteError(ctx *context.T, msg string) error {
	return verror.New(ErrRemoteError, ctx, msg)
}

// NewErrSend returns an error with the ErrSend ID.
func NewErrSend(ctx *context.T, typ string, dest string, err error) error {
	return verror.New(ErrSend, ctx, typ, dest, err)
}

// NewErrRecv returns an error with the ErrRecv ID.
func NewErrRecv(ctx *context.T, src string, err error) error {
	return verror.New(ErrRecv, ctx, src, err)
}

// NewErrCounterOverflow returns an error with the ErrCounterOverflow ID.
func NewErrCounterOverflow(ctx *context.T) error {
	return verror.New(ErrCounterOverflow, ctx)
}

// NewErrBlessingsFlowClosed returns an error with the ErrBlessingsFlowClosed ID.
func NewErrBlessingsFlowClosed(ctx *context.T, err error) error {
	return verror.New(ErrBlessingsFlowClosed, ctx, err)
}

// NewErrInvalidChannelBinding returns an error with the ErrInvalidChannelBinding ID.
func NewErrInvalidChannelBinding(ctx *context.T) error {
	return verror.New(ErrInvalidChannelBinding, ctx)
}

// NewErrNoPublicKey returns an error with the ErrNoPublicKey ID.
func NewErrNoPublicKey(ctx *context.T) error {
	return verror.New(ErrNoPublicKey, ctx)
}

// NewErrDialingNonServer returns an error with the ErrDialingNonServer ID.
func NewErrDialingNonServer(ctx *context.T) error {
	return verror.New(ErrDialingNonServer, ctx)
}

// NewErrAcceptorBlessingsMissing returns an error with the ErrAcceptorBlessingsMissing ID.
func NewErrAcceptorBlessingsMissing(ctx *context.T) error {
	return verror.New(ErrAcceptorBlessingsMissing, ctx)
}

// NewErrDialerBlessingsMissing returns an error with the ErrDialerBlessingsMissing ID.
func NewErrDialerBlessingsMissing(ctx *context.T) error {
	return verror.New(ErrDialerBlessingsMissing, ctx)
}

// NewErrBlessingsNotBound returns an error with the ErrBlessingsNotBound ID.
func NewErrBlessingsNotBound(ctx *context.T) error {
	return verror.New(ErrBlessingsNotBound, ctx)
}

// NewErrInvalidPeerFlow returns an error with the ErrInvalidPeerFlow ID.
func NewErrInvalidPeerFlow(ctx *context.T) error {
	return verror.New(ErrInvalidPeerFlow, ctx)
}

// NewErrChannelTimeout returns an error with the ErrChannelTimeout ID.
func NewErrChannelTimeout(ctx *context.T) error {
	return verror.New(ErrChannelTimeout, ctx)
}

// NewErrCannotDecryptBlessings returns an error with the ErrCannotDecryptBlessings ID.
func NewErrCannotDecryptBlessings(ctx *context.T, err error) error {
	return verror.New(ErrCannotDecryptBlessings, ctx, err)
}

// NewErrCannotDecryptDischarges returns an error with the ErrCannotDecryptDischarges ID.
func NewErrCannotDecryptDischarges(ctx *context.T, err error) error {
	return verror.New(ErrCannotDecryptDischarges, ctx, err)
}

// NewErrCannotEncryptBlessings returns an error with the ErrCannotEncryptBlessings ID.
func NewErrCannotEncryptBlessings(ctx *context.T, peers []security.BlessingPattern, err error) error {
	return verror.New(ErrCannotEncryptBlessings, ctx, peers, err)
}

// NewErrCannotEncryptDischarges returns an error with the ErrCannotEncryptDischarges ID.
func NewErrCannotEncryptDischarges(ctx *context.T, peers []security.BlessingPattern, err error) error {
	return verror.New(ErrCannotEncryptDischarges, ctx, peers, err)
}

// NewErrNoCrypter returns an error with the ErrNoCrypter ID.
func NewErrNoCrypter(ctx *context.T) error {
	return verror.New(ErrNoCrypter, ctx)
}

// NewErrNoPrivateKey returns an error with the ErrNoPrivateKey ID.
func NewErrNoPrivateKey(ctx *context.T) error {
	return verror.New(ErrNoPrivateKey, ctx)
}

// NewErrIdleConnKilled returns an error with the ErrIdleConnKilled ID.
func NewErrIdleConnKilled(ctx *context.T) error {
	return verror.New(ErrIdleConnKilled, ctx)
}

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*Blessings)(nil))
	vdl.Register((*EncryptedBlessings)(nil))
	vdl.Register((*Discharges)(nil))
	vdl.Register((*EncryptedDischarges)(nil))
	vdl.Register((*BlessingsFlowMessage)(nil))

	// Set error format strings.
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrMissingSetupOption.ID), "{1:}{2:} missing required setup option{:3}.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrUnexpectedMsg.ID), "{1:}{2:} unexpected message type{:3}.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrConnectionClosed.ID), "{1:}{2:} connection closed.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrRemoteError.ID), "{1:}{2:} remote end received err{:3}.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrSend.ID), "{1:}{2:} failure sending {3} message to {4}{:5}.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrRecv.ID), "{1:}{2:} error reading from {3}{:4}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrCounterOverflow.ID), "{1:}{2:} A remote process has sent more data than allowed.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBlessingsFlowClosed.ID), "{1:}{2:} The blessings flow was closed with error{:3}.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrInvalidChannelBinding.ID), "{1:}{2:} The channel binding was invalid.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoPublicKey.ID), "{1:}{2:} No public key was received by the remote end.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrDialingNonServer.ID), "{1:}{2:} You are attempting to dial on a connection with no remote server.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrAcceptorBlessingsMissing.ID), "{1:}{2:} The acceptor did not send blessings.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrDialerBlessingsMissing.ID), "{1:}{2:} The dialer did not send blessings.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBlessingsNotBound.ID), "{1:}{2:} blessings not bound to connection remote public key")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrInvalidPeerFlow.ID), "{1:}{2:} peer has chosen flow id from local domain.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrChannelTimeout.ID), "{1:}{2:} the channel has become unresponsive.")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrCannotDecryptBlessings.ID), "{1:}{2:} cannot decrypt the encrypted blessings sent by peer{:3}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrCannotDecryptDischarges.ID), "{1:}{2:} cannot decrypt the encrypted discharges sent by peer{:3}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrCannotEncryptBlessings.ID), "{1:}{2:} cannot encyrpt blessings for peer {3}{:4}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrCannotEncryptDischarges.ID), "{1:}{2:} cannot encrypt discharges for peers {3}{:4}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoCrypter.ID), "{1:}{2:} no blessings-based crypter available")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoPrivateKey.ID), "{1:}{2:} no blessings private key available for decryption")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrIdleConnKilled.ID), "{1:}{2:} Connection killed because idle expiry was reached.")

	return struct{}{}
}