core

type JSON struct {
	// Note: If none are set then the value is null.
	//
	// Types that are valid to be assigned to JsonValueOneof:
	//	*JSON_JsonString
	//	*JSON_JsonNumber
	//	*JSON_JsonBool
	//	*JSON_JsonObject
	//	*JSON_JsonArray
	JsonValueOneof isJSON_JsonValueOneof `protobuf_oneof:"json_value_oneof"`
}

type JSONArray struct {
	Element []*JSON `protobuf:"bytes,1,rep,name=element" json:"element,omitempty"`
}

type JSONObject struct {
	Property []*JSONProperty `protobuf:"bytes,1,rep,name=property" json:"property,omitempty"`
}

type JSONProperty struct {
	Name  string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value *JSON  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
}

type JSON_JsonArray struct {
	JsonArray *JSONArray `protobuf:"bytes,5,opt,name=json_array,json=jsonArray,oneof"`
}

type JSON_JsonBool struct {
	JsonBool bool `protobuf:"varint,3,opt,name=json_bool,json=jsonBool,oneof"`
}

type JSON_JsonNumber struct {
	JsonNumber float64 `protobuf:"fixed64,2,opt,name=json_number,json=jsonNumber,oneof"`
}

type JSON_JsonObject struct {
	JsonObject *JSONObject `protobuf:"bytes,4,opt,name=json_object,json=jsonObject,oneof"`
}

type JSON_JsonString struct {
	JsonString string `protobuf:"bytes,1,opt,name=json_string,json=jsonString,oneof"`
}

type LeverConfig struct {
	Service     string `json:"name"`
	Description string `json:"description,omitempty"`

	// Only one may be specified.
	EntryPoint   []string `json:"entry,omitempty"`
	JSEntryPoint string   `json:"jsEntry,omitempty"`

	IsPrivate bool `json:"private,omitempty"`

	MaxInstanceLoad float64 `json:"maxInstanceLoad,omitempty"`
	MinInstances    int     `json:"minInstances,omitempty"`

	InstanceMemoryMB int `json:"ram,omitempty"`

	// TODO: Future: Allow cust to add own config which can be read from within
	//       the service. Changing just these would not cause service restart.
	//       Think feature flags.
	CustConfig map[string]interface{} `json:"config,omitempty"`
}

type LeverRPCClient interface {
	HandleRPC(ctx context.Context, in *RPC, opts ...grpc.CallOption) (*RPCReply, error)
	HandleStreamingRPC(ctx context.Context, opts ...grpc.CallOption) (LeverRPC_HandleStreamingRPCClient, error)
}

type LeverRPCServer interface {
	HandleRPC(context.Context, *RPC) (*RPCReply, error)
	HandleStreamingRPC(LeverRPC_HandleStreamingRPCServer) error
}

type LeverRPC_HandleStreamingRPCClient interface {
	Send(*StreamMessage) error
	Recv() (*StreamMessage, error)
	grpc.ClientStream
}

type LeverRPC_HandleStreamingRPCServer interface {
	Send(*StreamMessage) error
	Recv() (*StreamMessage, error)
	grpc.ServerStream
}

type LeverURL struct {
	Environment string
	Service     string
	Resource    string
	Method      string
}

type RPC struct {
	// Types that are valid to be assigned to ArgsOneof:
	//	*RPC_Args
	//	*RPC_ByteArgs
	ArgsOneof isRPC_ArgsOneof `protobuf_oneof:"args_oneof"`
}

type RPCReply struct {
	// Types that are valid to be assigned to ResultOneof:
	//	*RPCReply_Result
	//	*RPCReply_ByteResult
	//	*RPCReply_Error
	//	*RPCReply_ByteError
	ResultOneof isRPCReply_ResultOneof `protobuf_oneof:"result_oneof"`
}

type RPCReply_ByteError struct {
	ByteError []byte `protobuf:"bytes,4,opt,name=byte_error,json=byteError,proto3,oneof"`
}

type RPCReply_ByteResult struct {
	ByteResult []byte `protobuf:"bytes,2,opt,name=byte_result,json=byteResult,proto3,oneof"`
}

type RPCReply_Error struct {
	Error *JSON `protobuf:"bytes,3,opt,name=error,oneof"`
}

type RPCReply_Result struct {
	Result *JSON `protobuf:"bytes,1,opt,name=result,oneof"`
}

type RPC_Args struct {
	Args *JSONArray `protobuf:"bytes,1,opt,name=args,oneof"`
}

type RPC_ByteArgs struct {
	ByteArgs []byte `protobuf:"bytes,2,opt,name=byte_args,json=byteArgs,proto3,oneof"`
}

type StreamMessage struct {
	// Note that the invokation details (rpc field) are part of the very first
	// message sent by the client. It is an error for any other message to have
	// that field set.
	// Also, the very first message sent by the server must be an empty
	// message. This is a workaround for some reverse-proxies which do funny
	// things if there's no data frame.
	//
	// Types that are valid to be assigned to MessageOneof:
	//	*StreamMessage_Rpc
	//	*StreamMessage_Message
	//	*StreamMessage_ByteMessage
	//	*StreamMessage_Error
	//	*StreamMessage_ByteError
	MessageOneof isStreamMessage_MessageOneof `protobuf_oneof:"message_oneof"`
}

type StreamMessage_ByteError struct {
	ByteError []byte `protobuf:"bytes,5,opt,name=byte_error,json=byteError,proto3,oneof"`
}

type StreamMessage_ByteMessage struct {
	ByteMessage []byte `protobuf:"bytes,3,opt,name=byte_message,json=byteMessage,proto3,oneof"`
}

type StreamMessage_Error struct {
	Error *JSON `protobuf:"bytes,4,opt,name=error,oneof"`
}

type StreamMessage_Message struct {
	Message *JSON `protobuf:"bytes,2,opt,name=message,oneof"`
}

type StreamMessage_Rpc struct {
	Rpc *RPC `protobuf:"bytes,1,opt,name=rpc,oneof"`
}