// 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: test_service

package test_service

import (
	"fmt"
	"io"
	"reflect"
	"time"
	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/rpc"
	"v.io/v23/security"
	"v.io/v23/uniqueid"
	"v.io/v23/vdl"
	_ "v.io/v23/vdlroot/time"
	"v.io/v23/vom"
)

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

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

// KeyPageResult is a page of 10 keys.
type KeyPageResult [10]string

func (KeyPageResult) __VDLReflect(struct {
	Name string `vdl:"v.io/x/js.core/test_service.KeyPageResult"`
}) {
}

func (m *KeyPageResult) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 10)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromString(string(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *KeyPageResult) MakeVDLTarget() vdl.Target {
	return &KeyPageResultTarget{Value: m}
}

// KeyPageResult
type KeyPageResultTarget struct {
	Value      *KeyPageResult
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

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

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

	return nil
}

// KeyValuePair is a representation of a cached key and value pair.
type KeyValuePair struct {
	Key   string
	Value *vom.RawBytes
}

func (KeyValuePair) __VDLReflect(struct {
	Name string `vdl:"v.io/x/js.core/test_service.KeyValuePair"`
}) {
}

func (m *KeyValuePair) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Value")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

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

func (m *KeyValuePair) MakeVDLTarget() vdl.Target {
	return &KeyValuePairTarget{Value: m}
}

type KeyValuePairTarget struct {
	Value     *KeyValuePair
	keyTarget vdl.StringTarget

	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*KeyValuePair)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *KeyValuePairTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Key":
		t.keyTarget.Value = &t.Value.Key
		target, err := &t.keyTarget, error(nil)
		return nil, target, err
	case "Value":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Value))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/js.core/test_service.KeyValuePair", name)
	}
}
func (t *KeyValuePairTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *KeyValuePairTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type TestCaveatData struct {
	A string
	B *vom.RawBytes // Use any for value so that we can confirm VDL is being used properly.
}

func (TestCaveatData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/js.core/test_service.TestCaveatData"`
}) {
}

func (m *TestCaveatData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.A), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.B == nil {
			if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := m.B.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *TestCaveatData) MakeVDLTarget() vdl.Target {
	return &TestCaveatDataTarget{Value: m}
}

type TestCaveatDataTarget struct {
	Value   *TestCaveatData
	aTarget vdl.StringTarget

	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*TestCaveatData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *TestCaveatDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.B))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/js.core/test_service.TestCaveatData", name)
	}
}
func (t *TestCaveatDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *TestCaveatDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Create zero values for each type.
var (
	__VDLZeroKeyPageResult  = KeyPageResult{}
	__VDLZeroKeyValuePair   = KeyValuePair{}
	__VDLZeroTestCaveatData = TestCaveatData{}
)

//////////////////////////////////////////////////
// Const definitions

var ConditionallyValidatingTestCaveat = security.CaveatDescriptor{
	Id: uniqueid.Id{
		0,
		17,
		34,
		51,
		68,
		85,
		102,
		119,
		136,
		153,
		170,
		187,
		204,
		221,
		238,
		255,
	},
	ParamType: vdl.TypeOf((*TestCaveatData)(nil)).Elem(),
}

//////////////////////////////////////////////////
// Interface definitions

// CacheClientMethods is the client interface
// containing Cache methods.
//
// A Cache service mimics the memcache interface.
type CacheClientMethods interface {
	// Set sets a value for a key.
	Set(_ *context.T, key string, value *vom.RawBytes, _ ...rpc.CallOpt) error
	// Get returns the value for a key.  If the value is not found, returns
	// a not found error.
	Get(_ *context.T, key string, _ ...rpc.CallOpt) (*vom.RawBytes, error)
	// Same as Get, but casts the return argument to an byte.
	GetAsByte(_ *context.T, key string, _ ...rpc.CallOpt) (byte, error)
	// Same as Get, but casts the return argument to an int32.
	GetAsInt32(_ *context.T, key string, _ ...rpc.CallOpt) (int32, error)
	// Same as Get, but casts the return argument to an int64.
	GetAsInt64(_ *context.T, key string, _ ...rpc.CallOpt) (int64, error)
	// Same as Get, but casts the return argument to an uint32.
	GetAsUint32(_ *context.T, key string, _ ...rpc.CallOpt) (uint32, error)
	// Same as Get, but casts the return argument to an uint64.
	GetAsUint64(_ *context.T, key string, _ ...rpc.CallOpt) (uint64, error)
	// Same as Get, but casts the return argument to an float32.
	GetAsFloat32(_ *context.T, key string, _ ...rpc.CallOpt) (float32, error)
	// Same as Get, but casts the return argument to an float64.
	GetAsFloat64(_ *context.T, key string, _ ...rpc.CallOpt) (float64, error)
	// Same as Get, but casts the return argument to a string.
	GetAsString(_ *context.T, key string, _ ...rpc.CallOpt) (string, error)
	// Same as Get, but casts the return argument to a bool.
	GetAsBool(_ *context.T, key string, _ ...rpc.CallOpt) (bool, error)
	// Same as Get, but casts the return argument to an error.
	GetAsError(_ *context.T, key string, _ ...rpc.CallOpt) (error, error)
	// AsMap returns the full contents of the cache as a map.
	AsMap(*context.T, ...rpc.CallOpt) (map[string]*vom.RawBytes, error)
	// KeyValuePairs returns the full contents of the cache as a slice of pairs.
	KeyValuePairs(*context.T, ...rpc.CallOpt) ([]KeyValuePair, error)
	// MostRecentSet returns the key and value and the timestamp for the most
	// recent set operation
	// TODO(bprosnitz) support type types and change time to native time type
	MostRecentSet(*context.T, ...rpc.CallOpt) (value KeyValuePair, time int64, _ error)
	// KeyPage indexes into the keys (in alphanumerically sorted order) and
	// returns the indexth page of 10 keys.
	KeyPage(_ *context.T, index int64, _ ...rpc.CallOpt) (KeyPageResult, error)
	// Size returns the total number of entries in the cache.
	Size(*context.T, ...rpc.CallOpt) (int64, error)
	// MultiGet sets up a stream that allows fetching multiple keys.
	MultiGet(*context.T, ...rpc.CallOpt) (CacheMultiGetClientCall, error)
}

// CacheClientStub adds universal methods to CacheClientMethods.
type CacheClientStub interface {
	CacheClientMethods
	rpc.UniversalServiceMethods
}

// CacheClient returns a client stub for Cache.
func CacheClient(name string) CacheClientStub {
	return implCacheClientStub{name}
}

type implCacheClientStub struct {
	name string
}

func (c implCacheClientStub) Set(ctx *context.T, i0 string, i1 *vom.RawBytes, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Set", []interface{}{i0, i1}, nil, opts...)
	return
}

func (c implCacheClientStub) Get(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 *vom.RawBytes, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Get", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsByte(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 byte, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsByte", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsInt32(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 int32, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsInt32", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsInt64(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 int64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsInt64", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsUint32(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 uint32, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsUint32", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsUint64(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 uint64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsUint64", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsFloat32(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 float32, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsFloat32", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsFloat64(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 float64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsFloat64", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsString(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsString", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsBool(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 bool, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsBool", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) GetAsError(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 error, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "GetAsError", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) AsMap(ctx *context.T, opts ...rpc.CallOpt) (o0 map[string]*vom.RawBytes, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "AsMap", nil, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) KeyValuePairs(ctx *context.T, opts ...rpc.CallOpt) (o0 []KeyValuePair, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "KeyValuePairs", nil, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) MostRecentSet(ctx *context.T, opts ...rpc.CallOpt) (o0 KeyValuePair, o1 int64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "MostRecentSet", nil, []interface{}{&o0, &o1}, opts...)
	return
}

func (c implCacheClientStub) KeyPage(ctx *context.T, i0 int64, opts ...rpc.CallOpt) (o0 KeyPageResult, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "KeyPage", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) Size(ctx *context.T, opts ...rpc.CallOpt) (o0 int64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Size", nil, []interface{}{&o0}, opts...)
	return
}

func (c implCacheClientStub) MultiGet(ctx *context.T, opts ...rpc.CallOpt) (ocall CacheMultiGetClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MultiGet", nil, opts...); err != nil {
		return
	}
	ocall = &implCacheMultiGetClientCall{ClientCall: call}
	return
}

// CacheMultiGetClientStream is the client stream for Cache.MultiGet.
type CacheMultiGetClientStream interface {
	// RecvStream returns the receiver side of the Cache.MultiGet client stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() *vom.RawBytes
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the Cache.MultiGet client stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors
		// encountered while sending, or if Send is called after Close or
		// the stream has been canceled.  Blocks if there is no buffer
		// space; will unblock when buffer space is available or after
		// the stream has been canceled.
		Send(item string) error
		// Close indicates to the server that no more items will be sent;
		// server Recv calls will receive io.EOF after all sent items.
		// This is an optional call - e.g. a client might call Close if it
		// needs to continue receiving items from the server after it's
		// done sending.  Returns errors encountered while closing, or if
		// Close is called after the stream has been canceled.  Like Send,
		// blocks if there is no buffer space available.
		Close() error
	}
}

// CacheMultiGetClientCall represents the call returned from Cache.MultiGet.
type CacheMultiGetClientCall interface {
	CacheMultiGetClientStream
	// Finish performs the equivalent of SendStream().Close, then blocks until
	// the server is done, and returns the positional return values for the call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error.  Finish should
	// be called at most once.
	Finish() error
}

type implCacheMultiGetClientCall struct {
	rpc.ClientCall
	valRecv *vom.RawBytes
	errRecv error
}

func (c *implCacheMultiGetClientCall) RecvStream() interface {
	Advance() bool
	Value() *vom.RawBytes
	Err() error
} {
	return implCacheMultiGetClientCallRecv{c}
}

type implCacheMultiGetClientCallRecv struct {
	c *implCacheMultiGetClientCall
}

func (c implCacheMultiGetClientCallRecv) Advance() bool {
	c.c.valRecv = nil
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
}
func (c implCacheMultiGetClientCallRecv) Value() *vom.RawBytes {
	return c.c.valRecv
}
func (c implCacheMultiGetClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
		return nil
	}
	return c.c.errRecv
}
func (c *implCacheMultiGetClientCall) SendStream() interface {
	Send(item string) error
	Close() error
} {
	return implCacheMultiGetClientCallSend{c}
}

type implCacheMultiGetClientCallSend struct {
	c *implCacheMultiGetClientCall
}

func (c implCacheMultiGetClientCallSend) Send(item string) error {
	return c.c.Send(item)
}
func (c implCacheMultiGetClientCallSend) Close() error {
	return c.c.CloseSend()
}
func (c *implCacheMultiGetClientCall) Finish() (err error) {
	err = c.ClientCall.Finish()
	return
}

// CacheServerMethods is the interface a server writer
// implements for Cache.
//
// A Cache service mimics the memcache interface.
type CacheServerMethods interface {
	// Set sets a value for a key.
	Set(_ *context.T, _ rpc.ServerCall, key string, value *vom.RawBytes) error
	// Get returns the value for a key.  If the value is not found, returns
	// a not found error.
	Get(_ *context.T, _ rpc.ServerCall, key string) (*vom.RawBytes, error)
	// Same as Get, but casts the return argument to an byte.
	GetAsByte(_ *context.T, _ rpc.ServerCall, key string) (byte, error)
	// Same as Get, but casts the return argument to an int32.
	GetAsInt32(_ *context.T, _ rpc.ServerCall, key string) (int32, error)
	// Same as Get, but casts the return argument to an int64.
	GetAsInt64(_ *context.T, _ rpc.ServerCall, key string) (int64, error)
	// Same as Get, but casts the return argument to an uint32.
	GetAsUint32(_ *context.T, _ rpc.ServerCall, key string) (uint32, error)
	// Same as Get, but casts the return argument to an uint64.
	GetAsUint64(_ *context.T, _ rpc.ServerCall, key string) (uint64, error)
	// Same as Get, but casts the return argument to an float32.
	GetAsFloat32(_ *context.T, _ rpc.ServerCall, key string) (float32, error)
	// Same as Get, but casts the return argument to an float64.
	GetAsFloat64(_ *context.T, _ rpc.ServerCall, key string) (float64, error)
	// Same as Get, but casts the return argument to a string.
	GetAsString(_ *context.T, _ rpc.ServerCall, key string) (string, error)
	// Same as Get, but casts the return argument to a bool.
	GetAsBool(_ *context.T, _ rpc.ServerCall, key string) (bool, error)
	// Same as Get, but casts the return argument to an error.
	GetAsError(_ *context.T, _ rpc.ServerCall, key string) (error, error)
	// AsMap returns the full contents of the cache as a map.
	AsMap(*context.T, rpc.ServerCall) (map[string]*vom.RawBytes, error)
	// KeyValuePairs returns the full contents of the cache as a slice of pairs.
	KeyValuePairs(*context.T, rpc.ServerCall) ([]KeyValuePair, error)
	// MostRecentSet returns the key and value and the timestamp for the most
	// recent set operation
	// TODO(bprosnitz) support type types and change time to native time type
	MostRecentSet(*context.T, rpc.ServerCall) (value KeyValuePair, time int64, _ error)
	// KeyPage indexes into the keys (in alphanumerically sorted order) and
	// returns the indexth page of 10 keys.
	KeyPage(_ *context.T, _ rpc.ServerCall, index int64) (KeyPageResult, error)
	// Size returns the total number of entries in the cache.
	Size(*context.T, rpc.ServerCall) (int64, error)
	// MultiGet sets up a stream that allows fetching multiple keys.
	MultiGet(*context.T, CacheMultiGetServerCall) error
}

// CacheServerStubMethods is the server interface containing
// Cache methods, as expected by rpc.Server.
// The only difference between this interface and CacheServerMethods
// is the streaming methods.
type CacheServerStubMethods interface {
	// Set sets a value for a key.
	Set(_ *context.T, _ rpc.ServerCall, key string, value *vom.RawBytes) error
	// Get returns the value for a key.  If the value is not found, returns
	// a not found error.
	Get(_ *context.T, _ rpc.ServerCall, key string) (*vom.RawBytes, error)
	// Same as Get, but casts the return argument to an byte.
	GetAsByte(_ *context.T, _ rpc.ServerCall, key string) (byte, error)
	// Same as Get, but casts the return argument to an int32.
	GetAsInt32(_ *context.T, _ rpc.ServerCall, key string) (int32, error)
	// Same as Get, but casts the return argument to an int64.
	GetAsInt64(_ *context.T, _ rpc.ServerCall, key string) (int64, error)
	// Same as Get, but casts the return argument to an uint32.
	GetAsUint32(_ *context.T, _ rpc.ServerCall, key string) (uint32, error)
	// Same as Get, but casts the return argument to an uint64.
	GetAsUint64(_ *context.T, _ rpc.ServerCall, key string) (uint64, error)
	// Same as Get, but casts the return argument to an float32.
	GetAsFloat32(_ *context.T, _ rpc.ServerCall, key string) (float32, error)
	// Same as Get, but casts the return argument to an float64.
	GetAsFloat64(_ *context.T, _ rpc.ServerCall, key string) (float64, error)
	// Same as Get, but casts the return argument to a string.
	GetAsString(_ *context.T, _ rpc.ServerCall, key string) (string, error)
	// Same as Get, but casts the return argument to a bool.
	GetAsBool(_ *context.T, _ rpc.ServerCall, key string) (bool, error)
	// Same as Get, but casts the return argument to an error.
	GetAsError(_ *context.T, _ rpc.ServerCall, key string) (error, error)
	// AsMap returns the full contents of the cache as a map.
	AsMap(*context.T, rpc.ServerCall) (map[string]*vom.RawBytes, error)
	// KeyValuePairs returns the full contents of the cache as a slice of pairs.
	KeyValuePairs(*context.T, rpc.ServerCall) ([]KeyValuePair, error)
	// MostRecentSet returns the key and value and the timestamp for the most
	// recent set operation
	// TODO(bprosnitz) support type types and change time to native time type
	MostRecentSet(*context.T, rpc.ServerCall) (value KeyValuePair, time int64, _ error)
	// KeyPage indexes into the keys (in alphanumerically sorted order) and
	// returns the indexth page of 10 keys.
	KeyPage(_ *context.T, _ rpc.ServerCall, index int64) (KeyPageResult, error)
	// Size returns the total number of entries in the cache.
	Size(*context.T, rpc.ServerCall) (int64, error)
	// MultiGet sets up a stream that allows fetching multiple keys.
	MultiGet(*context.T, *CacheMultiGetServerCallStub) error
}

// CacheServerStub adds universal methods to CacheServerStubMethods.
type CacheServerStub interface {
	CacheServerStubMethods
	// Describe the Cache interfaces.
	Describe__() []rpc.InterfaceDesc
}

// CacheServer returns a server stub for Cache.
// It converts an implementation of CacheServerMethods into
// an object that may be used by rpc.Server.
func CacheServer(impl CacheServerMethods) CacheServerStub {
	stub := implCacheServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implCacheServerStub struct {
	impl CacheServerMethods
	gs   *rpc.GlobState
}

func (s implCacheServerStub) Set(ctx *context.T, call rpc.ServerCall, i0 string, i1 *vom.RawBytes) error {
	return s.impl.Set(ctx, call, i0, i1)
}

func (s implCacheServerStub) Get(ctx *context.T, call rpc.ServerCall, i0 string) (*vom.RawBytes, error) {
	return s.impl.Get(ctx, call, i0)
}

func (s implCacheServerStub) GetAsByte(ctx *context.T, call rpc.ServerCall, i0 string) (byte, error) {
	return s.impl.GetAsByte(ctx, call, i0)
}

func (s implCacheServerStub) GetAsInt32(ctx *context.T, call rpc.ServerCall, i0 string) (int32, error) {
	return s.impl.GetAsInt32(ctx, call, i0)
}

func (s implCacheServerStub) GetAsInt64(ctx *context.T, call rpc.ServerCall, i0 string) (int64, error) {
	return s.impl.GetAsInt64(ctx, call, i0)
}

func (s implCacheServerStub) GetAsUint32(ctx *context.T, call rpc.ServerCall, i0 string) (uint32, error) {
	return s.impl.GetAsUint32(ctx, call, i0)
}

func (s implCacheServerStub) GetAsUint64(ctx *context.T, call rpc.ServerCall, i0 string) (uint64, error) {
	return s.impl.GetAsUint64(ctx, call, i0)
}

func (s implCacheServerStub) GetAsFloat32(ctx *context.T, call rpc.ServerCall, i0 string) (float32, error) {
	return s.impl.GetAsFloat32(ctx, call, i0)
}

func (s implCacheServerStub) GetAsFloat64(ctx *context.T, call rpc.ServerCall, i0 string) (float64, error) {
	return s.impl.GetAsFloat64(ctx, call, i0)
}

func (s implCacheServerStub) GetAsString(ctx *context.T, call rpc.ServerCall, i0 string) (string, error) {
	return s.impl.GetAsString(ctx, call, i0)
}

func (s implCacheServerStub) GetAsBool(ctx *context.T, call rpc.ServerCall, i0 string) (bool, error) {
	return s.impl.GetAsBool(ctx, call, i0)
}

func (s implCacheServerStub) GetAsError(ctx *context.T, call rpc.ServerCall, i0 string) (error, error) {
	return s.impl.GetAsError(ctx, call, i0)
}

func (s implCacheServerStub) AsMap(ctx *context.T, call rpc.ServerCall) (map[string]*vom.RawBytes, error) {
	return s.impl.AsMap(ctx, call)
}

func (s implCacheServerStub) KeyValuePairs(ctx *context.T, call rpc.ServerCall) ([]KeyValuePair, error) {
	return s.impl.KeyValuePairs(ctx, call)
}

func (s implCacheServerStub) MostRecentSet(ctx *context.T, call rpc.ServerCall) (KeyValuePair, int64, error) {
	return s.impl.MostRecentSet(ctx, call)
}

func (s implCacheServerStub) KeyPage(ctx *context.T, call rpc.ServerCall, i0 int64) (KeyPageResult, error) {
	return s.impl.KeyPage(ctx, call, i0)
}

func (s implCacheServerStub) Size(ctx *context.T, call rpc.ServerCall) (int64, error) {
	return s.impl.Size(ctx, call)
}

func (s implCacheServerStub) MultiGet(ctx *context.T, call *CacheMultiGetServerCallStub) error {
	return s.impl.MultiGet(ctx, call)
}

func (s implCacheServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implCacheServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{CacheDesc}
}

// CacheDesc describes the Cache interface.
var CacheDesc rpc.InterfaceDesc = descCache

// descCache hides the desc to keep godoc clean.
var descCache = rpc.InterfaceDesc{
	Name:    "Cache",
	PkgPath: "v.io/x/js.core/test_service",
	Doc:     "// A Cache service mimics the memcache interface.",
	Methods: []rpc.MethodDesc{
		{
			Name: "Set",
			Doc:  "// Set sets a value for a key.",
			InArgs: []rpc.ArgDesc{
				{"key", ``},   // string
				{"value", ``}, // *vom.RawBytes
			},
		},
		{
			Name: "Get",
			Doc:  "// Get returns the value for a key.  If the value is not found, returns\n// a not found error.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // *vom.RawBytes
			},
		},
		{
			Name: "GetAsByte",
			Doc:  "// Same as Get, but casts the return argument to an byte.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // byte
			},
		},
		{
			Name: "GetAsInt32",
			Doc:  "// Same as Get, but casts the return argument to an int32.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // int32
			},
		},
		{
			Name: "GetAsInt64",
			Doc:  "// Same as Get, but casts the return argument to an int64.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // int64
			},
		},
		{
			Name: "GetAsUint32",
			Doc:  "// Same as Get, but casts the return argument to an uint32.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // uint32
			},
		},
		{
			Name: "GetAsUint64",
			Doc:  "// Same as Get, but casts the return argument to an uint64.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // uint64
			},
		},
		{
			Name: "GetAsFloat32",
			Doc:  "// Same as Get, but casts the return argument to an float32.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // float32
			},
		},
		{
			Name: "GetAsFloat64",
			Doc:  "// Same as Get, but casts the return argument to an float64.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // float64
			},
		},
		{
			Name: "GetAsString",
			Doc:  "// Same as Get, but casts the return argument to a string.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // string
			},
		},
		{
			Name: "GetAsBool",
			Doc:  "// Same as Get, but casts the return argument to a bool.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // bool
			},
		},
		{
			Name: "GetAsError",
			Doc:  "// Same as Get, but casts the return argument to an error.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // error
			},
		},
		{
			Name: "AsMap",
			Doc:  "// AsMap returns the full contents of the cache as a map.",
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // map[string]*vom.RawBytes
			},
		},
		{
			Name: "KeyValuePairs",
			Doc:  "// KeyValuePairs returns the full contents of the cache as a slice of pairs.",
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // []KeyValuePair
			},
		},
		{
			Name: "MostRecentSet",
			Doc:  "// MostRecentSet returns the key and value and the timestamp for the most\n// recent set operation\n// TODO(bprosnitz) support type types and change time to native time type",
			OutArgs: []rpc.ArgDesc{
				{"value", ``}, // KeyValuePair
				{"time", ``},  // int64
			},
		},
		{
			Name: "KeyPage",
			Doc:  "// KeyPage indexes into the keys (in alphanumerically sorted order) and\n// returns the indexth page of 10 keys.",
			InArgs: []rpc.ArgDesc{
				{"index", ``}, // int64
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // KeyPageResult
			},
		},
		{
			Name: "Size",
			Doc:  "// Size returns the total number of entries in the cache.",
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // int64
			},
		},
		{
			Name: "MultiGet",
			Doc:  "// MultiGet sets up a stream that allows fetching multiple keys.",
		},
	},
}

// CacheMultiGetServerStream is the server stream for Cache.MultiGet.
type CacheMultiGetServerStream interface {
	// RecvStream returns the receiver side of the Cache.MultiGet server stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() string
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the Cache.MultiGet server stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors encountered
		// while sending.  Blocks if there is no buffer space; will unblock when
		// buffer space is available.
		Send(item *vom.RawBytes) error
	}
}

// CacheMultiGetServerCall represents the context passed to Cache.MultiGet.
type CacheMultiGetServerCall interface {
	rpc.ServerCall
	CacheMultiGetServerStream
}

// CacheMultiGetServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements CacheMultiGetServerCall.
type CacheMultiGetServerCallStub struct {
	rpc.StreamServerCall
	valRecv string
	errRecv error
}

// Init initializes CacheMultiGetServerCallStub from rpc.StreamServerCall.
func (s *CacheMultiGetServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
}

// RecvStream returns the receiver side of the Cache.MultiGet server stream.
func (s *CacheMultiGetServerCallStub) RecvStream() interface {
	Advance() bool
	Value() string
	Err() error
} {
	return implCacheMultiGetServerCallRecv{s}
}

type implCacheMultiGetServerCallRecv struct {
	s *CacheMultiGetServerCallStub
}

func (s implCacheMultiGetServerCallRecv) Advance() bool {
	s.s.errRecv = s.s.Recv(&s.s.valRecv)
	return s.s.errRecv == nil
}
func (s implCacheMultiGetServerCallRecv) Value() string {
	return s.s.valRecv
}
func (s implCacheMultiGetServerCallRecv) Err() error {
	if s.s.errRecv == io.EOF {
		return nil
	}
	return s.s.errRecv
}

// SendStream returns the send side of the Cache.MultiGet server stream.
func (s *CacheMultiGetServerCallStub) SendStream() interface {
	Send(item *vom.RawBytes) error
} {
	return implCacheMultiGetServerCallSend{s}
}

type implCacheMultiGetServerCallSend struct {
	s *CacheMultiGetServerCallStub
}

func (s implCacheMultiGetServerCallSend) Send(item *vom.RawBytes) error {
	return s.s.Send(item)
}

// CancelCollectorClientMethods is the client interface
// containing CancelCollector methods.
//
// CancelCollector is a test interface for use in testing cancellation and deadlines.
type CancelCollectorClientMethods interface {
	// A function that never returns, but records the status of the given key.
	NeverReturn(_ *context.T, key int64, _ ...rpc.CallOpt) error
	// Wait for the call with the given key to have the given status.  Possible statuses are:
	// "running", and, "cancelled".  Returns the number of nanoseconds left on
	// the deadline of the specified call when the call first began.
	WaitForStatus(_ *context.T, key int64, status string, _ ...rpc.CallOpt) (timeout int64, _ error)
}

// CancelCollectorClientStub adds universal methods to CancelCollectorClientMethods.
type CancelCollectorClientStub interface {
	CancelCollectorClientMethods
	rpc.UniversalServiceMethods
}

// CancelCollectorClient returns a client stub for CancelCollector.
func CancelCollectorClient(name string) CancelCollectorClientStub {
	return implCancelCollectorClientStub{name}
}

type implCancelCollectorClientStub struct {
	name string
}

func (c implCancelCollectorClientStub) NeverReturn(ctx *context.T, i0 int64, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "NeverReturn", []interface{}{i0}, nil, opts...)
	return
}

func (c implCancelCollectorClientStub) WaitForStatus(ctx *context.T, i0 int64, i1 string, opts ...rpc.CallOpt) (o0 int64, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "WaitForStatus", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
	return
}

// CancelCollectorServerMethods is the interface a server writer
// implements for CancelCollector.
//
// CancelCollector is a test interface for use in testing cancellation and deadlines.
type CancelCollectorServerMethods interface {
	// A function that never returns, but records the status of the given key.
	NeverReturn(_ *context.T, _ rpc.ServerCall, key int64) error
	// Wait for the call with the given key to have the given status.  Possible statuses are:
	// "running", and, "cancelled".  Returns the number of nanoseconds left on
	// the deadline of the specified call when the call first began.
	WaitForStatus(_ *context.T, _ rpc.ServerCall, key int64, status string) (timeout int64, _ error)
}

// CancelCollectorServerStubMethods is the server interface containing
// CancelCollector methods, as expected by rpc.Server.
// There is no difference between this interface and CancelCollectorServerMethods
// since there are no streaming methods.
type CancelCollectorServerStubMethods CancelCollectorServerMethods

// CancelCollectorServerStub adds universal methods to CancelCollectorServerStubMethods.
type CancelCollectorServerStub interface {
	CancelCollectorServerStubMethods
	// Describe the CancelCollector interfaces.
	Describe__() []rpc.InterfaceDesc
}

// CancelCollectorServer returns a server stub for CancelCollector.
// It converts an implementation of CancelCollectorServerMethods into
// an object that may be used by rpc.Server.
func CancelCollectorServer(impl CancelCollectorServerMethods) CancelCollectorServerStub {
	stub := implCancelCollectorServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implCancelCollectorServerStub struct {
	impl CancelCollectorServerMethods
	gs   *rpc.GlobState
}

func (s implCancelCollectorServerStub) NeverReturn(ctx *context.T, call rpc.ServerCall, i0 int64) error {
	return s.impl.NeverReturn(ctx, call, i0)
}

func (s implCancelCollectorServerStub) WaitForStatus(ctx *context.T, call rpc.ServerCall, i0 int64, i1 string) (int64, error) {
	return s.impl.WaitForStatus(ctx, call, i0, i1)
}

func (s implCancelCollectorServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implCancelCollectorServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{CancelCollectorDesc}
}

// CancelCollectorDesc describes the CancelCollector interface.
var CancelCollectorDesc rpc.InterfaceDesc = descCancelCollector

// descCancelCollector hides the desc to keep godoc clean.
var descCancelCollector = rpc.InterfaceDesc{
	Name:    "CancelCollector",
	PkgPath: "v.io/x/js.core/test_service",
	Doc:     "// CancelCollector is a test interface for use in testing cancellation and deadlines.",
	Methods: []rpc.MethodDesc{
		{
			Name: "NeverReturn",
			Doc:  "// A function that never returns, but records the status of the given key.",
			InArgs: []rpc.ArgDesc{
				{"key", ``}, // int64
			},
		},
		{
			Name: "WaitForStatus",
			Doc:  "// Wait for the call with the given key to have the given status.  Possible statuses are:\n// \"running\", and, \"cancelled\".  Returns the number of nanoseconds left on\n// the deadline of the specified call when the call first began.",
			InArgs: []rpc.ArgDesc{
				{"key", ``},    // int64
				{"status", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"timeout", ``}, // int64
			},
		},
	},
}

// ErrorThrowerClientMethods is the client interface
// containing ErrorThrower methods.
//
// A testing interface with methods that throw various types of errors
type ErrorThrowerClientMethods interface {
	// Throws v23/vError.Aborted error
	ThrowAborted(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.BadArg error
	ThrowBadArg(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.BadProtocol error
	ThrowBadProtocol(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.Internal error
	ThrowInternal(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.NoAccess error
	ThrowNoAccess(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.NoExist error
	ThrowNoExist(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.NoExistOrNoAccess error
	ThrowNoExistOrNoAccess(*context.T, ...rpc.CallOpt) error
	// Throws v23/vError.Unknown error
	ThrowUnknown(*context.T, ...rpc.CallOpt) error
	// Throws normal Go error
	ThrowGoError(*context.T, ...rpc.CallOpt) error
	// Throws custom error created by using Standard
	ThrowCustomStandardError(*context.T, ...rpc.CallOpt) error
}

// ErrorThrowerClientStub adds universal methods to ErrorThrowerClientMethods.
type ErrorThrowerClientStub interface {
	ErrorThrowerClientMethods
	rpc.UniversalServiceMethods
}

// ErrorThrowerClient returns a client stub for ErrorThrower.
func ErrorThrowerClient(name string) ErrorThrowerClientStub {
	return implErrorThrowerClientStub{name}
}

type implErrorThrowerClientStub struct {
	name string
}

func (c implErrorThrowerClientStub) ThrowAborted(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowAborted", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowBadArg(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowBadArg", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowBadProtocol(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowBadProtocol", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowInternal(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowInternal", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowNoAccess(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowNoAccess", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowNoExist(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowNoExist", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowNoExistOrNoAccess(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowNoExistOrNoAccess", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowUnknown(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowUnknown", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowGoError(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowGoError", nil, nil, opts...)
	return
}

func (c implErrorThrowerClientStub) ThrowCustomStandardError(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "ThrowCustomStandardError", nil, nil, opts...)
	return
}

// ErrorThrowerServerMethods is the interface a server writer
// implements for ErrorThrower.
//
// A testing interface with methods that throw various types of errors
type ErrorThrowerServerMethods interface {
	// Throws v23/vError.Aborted error
	ThrowAborted(*context.T, rpc.ServerCall) error
	// Throws v23/vError.BadArg error
	ThrowBadArg(*context.T, rpc.ServerCall) error
	// Throws v23/vError.BadProtocol error
	ThrowBadProtocol(*context.T, rpc.ServerCall) error
	// Throws v23/vError.Internal error
	ThrowInternal(*context.T, rpc.ServerCall) error
	// Throws v23/vError.NoAccess error
	ThrowNoAccess(*context.T, rpc.ServerCall) error
	// Throws v23/vError.NoExist error
	ThrowNoExist(*context.T, rpc.ServerCall) error
	// Throws v23/vError.NoExistOrNoAccess error
	ThrowNoExistOrNoAccess(*context.T, rpc.ServerCall) error
	// Throws v23/vError.Unknown error
	ThrowUnknown(*context.T, rpc.ServerCall) error
	// Throws normal Go error
	ThrowGoError(*context.T, rpc.ServerCall) error
	// Throws custom error created by using Standard
	ThrowCustomStandardError(*context.T, rpc.ServerCall) error
}

// ErrorThrowerServerStubMethods is the server interface containing
// ErrorThrower methods, as expected by rpc.Server.
// There is no difference between this interface and ErrorThrowerServerMethods
// since there are no streaming methods.
type ErrorThrowerServerStubMethods ErrorThrowerServerMethods

// ErrorThrowerServerStub adds universal methods to ErrorThrowerServerStubMethods.
type ErrorThrowerServerStub interface {
	ErrorThrowerServerStubMethods
	// Describe the ErrorThrower interfaces.
	Describe__() []rpc.InterfaceDesc
}

// ErrorThrowerServer returns a server stub for ErrorThrower.
// It converts an implementation of ErrorThrowerServerMethods into
// an object that may be used by rpc.Server.
func ErrorThrowerServer(impl ErrorThrowerServerMethods) ErrorThrowerServerStub {
	stub := implErrorThrowerServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implErrorThrowerServerStub struct {
	impl ErrorThrowerServerMethods
	gs   *rpc.GlobState
}

func (s implErrorThrowerServerStub) ThrowAborted(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowAborted(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowBadArg(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowBadArg(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowBadProtocol(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowBadProtocol(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowInternal(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowInternal(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowNoAccess(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowNoAccess(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowNoExist(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowNoExist(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowNoExistOrNoAccess(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowNoExistOrNoAccess(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowUnknown(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowUnknown(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowGoError(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowGoError(ctx, call)
}

func (s implErrorThrowerServerStub) ThrowCustomStandardError(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.ThrowCustomStandardError(ctx, call)
}

func (s implErrorThrowerServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implErrorThrowerServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{ErrorThrowerDesc}
}

// ErrorThrowerDesc describes the ErrorThrower interface.
var ErrorThrowerDesc rpc.InterfaceDesc = descErrorThrower

// descErrorThrower hides the desc to keep godoc clean.
var descErrorThrower = rpc.InterfaceDesc{
	Name:    "ErrorThrower",
	PkgPath: "v.io/x/js.core/test_service",
	Doc:     "// A testing interface with methods that throw various types of errors",
	Methods: []rpc.MethodDesc{
		{
			Name: "ThrowAborted",
			Doc:  "// Throws v23/vError.Aborted error",
		},
		{
			Name: "ThrowBadArg",
			Doc:  "// Throws v23/vError.BadArg error",
		},
		{
			Name: "ThrowBadProtocol",
			Doc:  "// Throws v23/vError.BadProtocol error",
		},
		{
			Name: "ThrowInternal",
			Doc:  "// Throws v23/vError.Internal error",
		},
		{
			Name: "ThrowNoAccess",
			Doc:  "// Throws v23/vError.NoAccess error",
		},
		{
			Name: "ThrowNoExist",
			Doc:  "// Throws v23/vError.NoExist error",
		},
		{
			Name: "ThrowNoExistOrNoAccess",
			Doc:  "// Throws v23/vError.NoExistOrNoAccess error",
		},
		{
			Name: "ThrowUnknown",
			Doc:  "// Throws v23/vError.Unknown error",
		},
		{
			Name: "ThrowGoError",
			Doc:  "// Throws normal Go error",
		},
		{
			Name: "ThrowCustomStandardError",
			Doc:  "// Throws custom error created by using Standard",
		},
	},
}

// InvokableTestMethodClientMethods is the client interface
// containing InvokableTestMethod methods.
type InvokableTestMethodClientMethods interface {
	AMethod(*context.T, ...rpc.CallOpt) (string, error)
}

// InvokableTestMethodClientStub adds universal methods to InvokableTestMethodClientMethods.
type InvokableTestMethodClientStub interface {
	InvokableTestMethodClientMethods
	rpc.UniversalServiceMethods
}

// InvokableTestMethodClient returns a client stub for InvokableTestMethod.
func InvokableTestMethodClient(name string) InvokableTestMethodClientStub {
	return implInvokableTestMethodClientStub{name}
}

type implInvokableTestMethodClientStub struct {
	name string
}

func (c implInvokableTestMethodClientStub) AMethod(ctx *context.T, opts ...rpc.CallOpt) (o0 string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "AMethod", nil, []interface{}{&o0}, opts...)
	return
}

// InvokableTestMethodServerMethods is the interface a server writer
// implements for InvokableTestMethod.
type InvokableTestMethodServerMethods interface {
	AMethod(*context.T, rpc.ServerCall) (string, error)
}

// InvokableTestMethodServerStubMethods is the server interface containing
// InvokableTestMethod methods, as expected by rpc.Server.
// There is no difference between this interface and InvokableTestMethodServerMethods
// since there are no streaming methods.
type InvokableTestMethodServerStubMethods InvokableTestMethodServerMethods

// InvokableTestMethodServerStub adds universal methods to InvokableTestMethodServerStubMethods.
type InvokableTestMethodServerStub interface {
	InvokableTestMethodServerStubMethods
	// Describe the InvokableTestMethod interfaces.
	Describe__() []rpc.InterfaceDesc
}

// InvokableTestMethodServer returns a server stub for InvokableTestMethod.
// It converts an implementation of InvokableTestMethodServerMethods into
// an object that may be used by rpc.Server.
func InvokableTestMethodServer(impl InvokableTestMethodServerMethods) InvokableTestMethodServerStub {
	stub := implInvokableTestMethodServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implInvokableTestMethodServerStub struct {
	impl InvokableTestMethodServerMethods
	gs   *rpc.GlobState
}

func (s implInvokableTestMethodServerStub) AMethod(ctx *context.T, call rpc.ServerCall) (string, error) {
	return s.impl.AMethod(ctx, call)
}

func (s implInvokableTestMethodServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implInvokableTestMethodServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{InvokableTestMethodDesc}
}

// InvokableTestMethodDesc describes the InvokableTestMethod interface.
var InvokableTestMethodDesc rpc.InterfaceDesc = descInvokableTestMethod

// descInvokableTestMethod hides the desc to keep godoc clean.
var descInvokableTestMethod = rpc.InterfaceDesc{
	Name:    "InvokableTestMethod",
	PkgPath: "v.io/x/js.core/test_service",
	Methods: []rpc.MethodDesc{
		{
			Name: "AMethod",
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // string
			},
		},
	},
}

// InvokeMethodWithCaveatedIdentityClientMethods is the client interface
// containing InvokeMethodWithCaveatedIdentity methods.
type InvokeMethodWithCaveatedIdentityClientMethods interface {
	Invoke(_ *context.T, name string, cavDesc security.CaveatDescriptor, cavParam *vom.RawBytes, _ ...rpc.CallOpt) error
}

// InvokeMethodWithCaveatedIdentityClientStub adds universal methods to InvokeMethodWithCaveatedIdentityClientMethods.
type InvokeMethodWithCaveatedIdentityClientStub interface {
	InvokeMethodWithCaveatedIdentityClientMethods
	rpc.UniversalServiceMethods
}

// InvokeMethodWithCaveatedIdentityClient returns a client stub for InvokeMethodWithCaveatedIdentity.
func InvokeMethodWithCaveatedIdentityClient(name string) InvokeMethodWithCaveatedIdentityClientStub {
	return implInvokeMethodWithCaveatedIdentityClientStub{name}
}

type implInvokeMethodWithCaveatedIdentityClientStub struct {
	name string
}

func (c implInvokeMethodWithCaveatedIdentityClientStub) Invoke(ctx *context.T, i0 string, i1 security.CaveatDescriptor, i2 *vom.RawBytes, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Invoke", []interface{}{i0, i1, i2}, nil, opts...)
	return
}

// InvokeMethodWithCaveatedIdentityServerMethods is the interface a server writer
// implements for InvokeMethodWithCaveatedIdentity.
type InvokeMethodWithCaveatedIdentityServerMethods interface {
	Invoke(_ *context.T, _ rpc.ServerCall, name string, cavDesc security.CaveatDescriptor, cavParam *vom.RawBytes) error
}

// InvokeMethodWithCaveatedIdentityServerStubMethods is the server interface containing
// InvokeMethodWithCaveatedIdentity methods, as expected by rpc.Server.
// There is no difference between this interface and InvokeMethodWithCaveatedIdentityServerMethods
// since there are no streaming methods.
type InvokeMethodWithCaveatedIdentityServerStubMethods InvokeMethodWithCaveatedIdentityServerMethods

// InvokeMethodWithCaveatedIdentityServerStub adds universal methods to InvokeMethodWithCaveatedIdentityServerStubMethods.
type InvokeMethodWithCaveatedIdentityServerStub interface {
	InvokeMethodWithCaveatedIdentityServerStubMethods
	// Describe the InvokeMethodWithCaveatedIdentity interfaces.
	Describe__() []rpc.InterfaceDesc
}

// InvokeMethodWithCaveatedIdentityServer returns a server stub for InvokeMethodWithCaveatedIdentity.
// It converts an implementation of InvokeMethodWithCaveatedIdentityServerMethods into
// an object that may be used by rpc.Server.
func InvokeMethodWithCaveatedIdentityServer(impl InvokeMethodWithCaveatedIdentityServerMethods) InvokeMethodWithCaveatedIdentityServerStub {
	stub := implInvokeMethodWithCaveatedIdentityServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implInvokeMethodWithCaveatedIdentityServerStub struct {
	impl InvokeMethodWithCaveatedIdentityServerMethods
	gs   *rpc.GlobState
}

func (s implInvokeMethodWithCaveatedIdentityServerStub) Invoke(ctx *context.T, call rpc.ServerCall, i0 string, i1 security.CaveatDescriptor, i2 *vom.RawBytes) error {
	return s.impl.Invoke(ctx, call, i0, i1, i2)
}

func (s implInvokeMethodWithCaveatedIdentityServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implInvokeMethodWithCaveatedIdentityServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{InvokeMethodWithCaveatedIdentityDesc}
}

// InvokeMethodWithCaveatedIdentityDesc describes the InvokeMethodWithCaveatedIdentity interface.
var InvokeMethodWithCaveatedIdentityDesc rpc.InterfaceDesc = descInvokeMethodWithCaveatedIdentity

// descInvokeMethodWithCaveatedIdentity hides the desc to keep godoc clean.
var descInvokeMethodWithCaveatedIdentity = rpc.InterfaceDesc{
	Name:    "InvokeMethodWithCaveatedIdentity",
	PkgPath: "v.io/x/js.core/test_service",
	Methods: []rpc.MethodDesc{
		{
			Name: "Invoke",
			InArgs: []rpc.ArgDesc{
				{"name", ``},     // string
				{"cavDesc", ``},  // security.CaveatDescriptor
				{"cavParam", ``}, // *vom.RawBytes
			},
		},
	},
}

// NativeTestClientMethods is the client interface
// containing NativeTest methods.
type NativeTestClientMethods interface {
	PassTime(_ *context.T, t time.Time, _ ...rpc.CallOpt) (time.Time, error)
	PassError(_ *context.T, e error, _ ...rpc.CallOpt) error
}

// NativeTestClientStub adds universal methods to NativeTestClientMethods.
type NativeTestClientStub interface {
	NativeTestClientMethods
	rpc.UniversalServiceMethods
}

// NativeTestClient returns a client stub for NativeTest.
func NativeTestClient(name string) NativeTestClientStub {
	return implNativeTestClientStub{name}
}

type implNativeTestClientStub struct {
	name string
}

func (c implNativeTestClientStub) PassTime(ctx *context.T, i0 time.Time, opts ...rpc.CallOpt) (o0 time.Time, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "PassTime", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implNativeTestClientStub) PassError(ctx *context.T, i0 error, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "PassError", []interface{}{&i0}, nil, opts...)
	return
}

// NativeTestServerMethods is the interface a server writer
// implements for NativeTest.
type NativeTestServerMethods interface {
	PassTime(_ *context.T, _ rpc.ServerCall, t time.Time) (time.Time, error)
	PassError(_ *context.T, _ rpc.ServerCall, e error) error
}

// NativeTestServerStubMethods is the server interface containing
// NativeTest methods, as expected by rpc.Server.
// There is no difference between this interface and NativeTestServerMethods
// since there are no streaming methods.
type NativeTestServerStubMethods NativeTestServerMethods

// NativeTestServerStub adds universal methods to NativeTestServerStubMethods.
type NativeTestServerStub interface {
	NativeTestServerStubMethods
	// Describe the NativeTest interfaces.
	Describe__() []rpc.InterfaceDesc
}

// NativeTestServer returns a server stub for NativeTest.
// It converts an implementation of NativeTestServerMethods into
// an object that may be used by rpc.Server.
func NativeTestServer(impl NativeTestServerMethods) NativeTestServerStub {
	stub := implNativeTestServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implNativeTestServerStub struct {
	impl NativeTestServerMethods
	gs   *rpc.GlobState
}

func (s implNativeTestServerStub) PassTime(ctx *context.T, call rpc.ServerCall, i0 time.Time) (time.Time, error) {
	return s.impl.PassTime(ctx, call, i0)
}

func (s implNativeTestServerStub) PassError(ctx *context.T, call rpc.ServerCall, i0 error) error {
	return s.impl.PassError(ctx, call, i0)
}

func (s implNativeTestServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implNativeTestServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{NativeTestDesc}
}

// NativeTestDesc describes the NativeTest interface.
var NativeTestDesc rpc.InterfaceDesc = descNativeTest

// descNativeTest hides the desc to keep godoc clean.
var descNativeTest = rpc.InterfaceDesc{
	Name:    "NativeTest",
	PkgPath: "v.io/x/js.core/test_service",
	Methods: []rpc.MethodDesc{
		{
			Name: "PassTime",
			InArgs: []rpc.ArgDesc{
				{"t", ``}, // time.Time
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // time.Time
			},
		},
		{
			Name: "PassError",
			InArgs: []rpc.ArgDesc{
				{"e", ``}, // error
			},
		},
	},
}

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

	// Register types.
	vdl.Register((*KeyPageResult)(nil))
	vdl.Register((*KeyValuePair)(nil))
	vdl.Register((*TestCaveatData)(nil))

	return struct{}{}
}