logdog/api/endpoints/coordinator/logs/v1/logs.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1/logs.proto

/*
Package logdog is a generated protocol buffer package.

It is generated from these files:
	github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1/logs.proto
	github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1/state.proto

It has these top-level messages:
	GetRequest
	TailRequest
	GetResponse
	QueryRequest
	QueryResponse
	ListRequest
	ListResponse
	LogStreamState
*/
package logdog

import prpc "github.com/luci/luci-go/grpc/prpc"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import logpb "github.com/luci/luci-go/logdog/api/logpb"
import google_protobuf "github.com/golang/protobuf/ptypes/timestamp"
import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// Trinary represents a trinary value.
type QueryRequest_Trinary int32

const (
	// Both positive and negative results will be returned.
	QueryRequest_BOTH QueryRequest_Trinary = 0
	// Only positive results will be returned.
	QueryRequest_YES QueryRequest_Trinary = 1
	// Only negative results will be returned.
	QueryRequest_NO QueryRequest_Trinary = 2
)

var QueryRequest_Trinary_name = map[int32]string{
	0: "BOTH",
	1: "YES",
	2: "NO",
}
var QueryRequest_Trinary_value = map[string]int32{
	"BOTH": 0,
	"YES":  1,
	"NO":   2,
}

func (x QueryRequest_Trinary) String() string {
	return proto.EnumName(QueryRequest_Trinary_name, int32(x))
}
func (QueryRequest_Trinary) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }

type ListResponse_Component_Type int32

const (
	ListResponse_Component_PATH    ListResponse_Component_Type = 0
	ListResponse_Component_STREAM  ListResponse_Component_Type = 1
	ListResponse_Component_PROJECT ListResponse_Component_Type = 2
)

var ListResponse_Component_Type_name = map[int32]string{
	0: "PATH",
	1: "STREAM",
	2: "PROJECT",
}
var ListResponse_Component_Type_value = map[string]int32{
	"PATH":    0,
	"STREAM":  1,
	"PROJECT": 2,
}

func (x ListResponse_Component_Type) String() string {
	return proto.EnumName(ListResponse_Component_Type_name, int32(x))
}
func (ListResponse_Component_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{6, 0, 0}
}

// GetRequest is the request structure for the user Get endpoint.
//
// If the requested log stream exists, a valid GetRequest will succeed
// regardless of whether the requested log range was available.
//
// Note that this endpoint may return fewer logs than requested due to either
// availability or internal constraints.
type GetRequest struct {
	// The request project to request.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The path of the log stream to get.
	//
	// This can either be a LogDog stream path or the SHA256 hash of a LogDog
	// stream path.
	//
	// Some utilities may find passing around a full LogDog path to be cumbersome
	// due to its length. They can opt to pass around the hash instead and
	// retrieve logs using it.
	Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
	// If true, requests that the log stream's state is returned.
	State bool `protobuf:"varint,3,opt,name=state" json:"state,omitempty"`
	// The initial log stream index to retrieve.
	Index int64 `protobuf:"varint,4,opt,name=index" json:"index,omitempty"`
	// The maximum number of bytes to return. If non-zero, it is applied as a
	// constraint to limit the number of logs that are returned.
	//
	// This only returns complete logs. Assuming logs are available, it will
	// return at least one log (even if it violates the size constraint) and as
	// many additional logs as it can without exceeding this constraint.
	ByteCount int32 `protobuf:"varint,5,opt,name=byte_count,json=byteCount" json:"byte_count,omitempty"`
	// The maximum number of log records to request.
	//
	// If this value is zero, no count constraint will be applied. If this value
	// is less than zero, no log entries will be returned. This can be used to
	// fetch log stream descriptors without fetching any log records.
	LogCount int32 `protobuf:"varint,6,opt,name=log_count,json=logCount" json:"log_count,omitempty"`
	// If true, allows the range request to return non-contiguous records.
	//
	// A contiguous request (default) will iterate forwards from the supplied
	// Index and stop if either the end of stream is encountered or there is a
	// missing stream index. A NonContiguous request will remove the latter
	// condition.
	//
	// For example, say the log stream consists of:
	// [3, 4, 6, 7]
	//
	// A contiguous request with Index 3 will return: [3, 4], stopping because
	// 5 is missing. A non-contiguous request will return [3, 4, 6, 7].
	NonContiguous bool                       `protobuf:"varint,7,opt,name=non_contiguous,json=nonContiguous" json:"non_contiguous,omitempty"`
	GetSignedUrls *GetRequest_SignURLRequest `protobuf:"bytes,8,opt,name=get_signed_urls,json=getSignedUrls" json:"get_signed_urls,omitempty"`
}

func (m *GetRequest) Reset()                    { *m = GetRequest{} }
func (m *GetRequest) String() string            { return proto.CompactTextString(m) }
func (*GetRequest) ProtoMessage()               {}
func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *GetRequest) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *GetRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *GetRequest) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

func (m *GetRequest) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *GetRequest) GetByteCount() int32 {
	if m != nil {
		return m.ByteCount
	}
	return 0
}

func (m *GetRequest) GetLogCount() int32 {
	if m != nil {
		return m.LogCount
	}
	return 0
}

func (m *GetRequest) GetNonContiguous() bool {
	if m != nil {
		return m.NonContiguous
	}
	return false
}

func (m *GetRequest) GetGetSignedUrls() *GetRequest_SignURLRequest {
	if m != nil {
		return m.GetSignedUrls
	}
	return nil
}

// If supplied, the response will contain a SignedUrls message with the
// requested signed URLs. If signed URLs are not supported by the log's
// current storage system, the response message will be empty.
type GetRequest_SignURLRequest struct {
	// The lifetime that the signed URL will be bound to.. The
	Lifetime *google_protobuf1.Duration `protobuf:"bytes,1,opt,name=lifetime" json:"lifetime,omitempty"`
	// Return a signed URL for the log's RecordIO protobuf data.
	Stream bool `protobuf:"varint,2,opt,name=stream" json:"stream,omitempty"`
	// Return a signed URL for the log's LogIndex protobuf.
	Index bool `protobuf:"varint,3,opt,name=index" json:"index,omitempty"`
}

func (m *GetRequest_SignURLRequest) Reset()                    { *m = GetRequest_SignURLRequest{} }
func (m *GetRequest_SignURLRequest) String() string            { return proto.CompactTextString(m) }
func (*GetRequest_SignURLRequest) ProtoMessage()               {}
func (*GetRequest_SignURLRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }

func (m *GetRequest_SignURLRequest) GetLifetime() *google_protobuf1.Duration {
	if m != nil {
		return m.Lifetime
	}
	return nil
}

func (m *GetRequest_SignURLRequest) GetStream() bool {
	if m != nil {
		return m.Stream
	}
	return false
}

func (m *GetRequest_SignURLRequest) GetIndex() bool {
	if m != nil {
		return m.Index
	}
	return false
}

// TailRequest is the request structure for the user Tail endpoint. It returns
// the last log in a given log stream at the time of the request.
type TailRequest struct {
	// The request project to request.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The path of the log stream to get.
	//
	// This can either be a LogDog stream path or the SHA256 hash of a LogDog
	// stream path.
	//
	// Some utilities may find passing around a full LogDog path to be cumbersome
	// due to its length. They can opt to pass around the hash instead and
	// retrieve logs using it.
	Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
	// If true, requests that the log stream's state is returned.
	State bool `protobuf:"varint,3,opt,name=state" json:"state,omitempty"`
}

func (m *TailRequest) Reset()                    { *m = TailRequest{} }
func (m *TailRequest) String() string            { return proto.CompactTextString(m) }
func (*TailRequest) ProtoMessage()               {}
func (*TailRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *TailRequest) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *TailRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *TailRequest) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

// GetResponse is the response structure for the user Get endpoint.
type GetResponse struct {
	// Project is the project name that these logs belong to.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The log stream descriptor and state for this stream.
	//
	// It can be requested by setting the request's State field to true. If the
	// Proto field is true, the State's Descriptor field will not be included.
	State *LogStreamState `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
	// The expanded LogStreamDescriptor protobuf. It is intended for JSON
	// consumption.
	//
	// If the GetRequest's Proto field is false, this will be populated;
	// otherwise, the serialized protobuf will be written to the DescriptorProto
	// field.
	Desc *logpb.LogStreamDescriptor `protobuf:"bytes,3,opt,name=desc" json:"desc,omitempty"`
	// Log represents the set of retrieved log records.
	Logs []*logpb.LogEntry `protobuf:"bytes,4,rep,name=logs" json:"logs,omitempty"`
	// An optional signed log entry RecordIO protobuf URL, if requested via
	// "sign_entry_url_lifetime".
	SignedUrls *GetResponse_SignedUrls `protobuf:"bytes,5,opt,name=signed_urls,json=signedUrls" json:"signed_urls,omitempty"`
}

func (m *GetResponse) Reset()                    { *m = GetResponse{} }
func (m *GetResponse) String() string            { return proto.CompactTextString(m) }
func (*GetResponse) ProtoMessage()               {}
func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *GetResponse) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *GetResponse) GetState() *LogStreamState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *GetResponse) GetDesc() *logpb.LogStreamDescriptor {
	if m != nil {
		return m.Desc
	}
	return nil
}

func (m *GetResponse) GetLogs() []*logpb.LogEntry {
	if m != nil {
		return m.Logs
	}
	return nil
}

func (m *GetResponse) GetSignedUrls() *GetResponse_SignedUrls {
	if m != nil {
		return m.SignedUrls
	}
	return nil
}

// Holds information about the log stream's signed entry URL.
type GetResponse_SignedUrls struct {
	// The time when this signed URL will expire.
	Expiration *google_protobuf.Timestamp `protobuf:"bytes,1,opt,name=expiration" json:"expiration,omitempty"`
	// The signed log stream URL, if requested.
	Stream string `protobuf:"bytes,2,opt,name=stream" json:"stream,omitempty"`
	// The signed log index URL, if requested.
	Index string `protobuf:"bytes,3,opt,name=index" json:"index,omitempty"`
}

func (m *GetResponse_SignedUrls) Reset()                    { *m = GetResponse_SignedUrls{} }
func (m *GetResponse_SignedUrls) String() string            { return proto.CompactTextString(m) }
func (*GetResponse_SignedUrls) ProtoMessage()               {}
func (*GetResponse_SignedUrls) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }

func (m *GetResponse_SignedUrls) GetExpiration() *google_protobuf.Timestamp {
	if m != nil {
		return m.Expiration
	}
	return nil
}

func (m *GetResponse_SignedUrls) GetStream() string {
	if m != nil {
		return m.Stream
	}
	return ""
}

func (m *GetResponse_SignedUrls) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

// QueryRequest is the request structure for the user Query endpoint.
type QueryRequest struct {
	// The request project to request.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The query parameter.
	//
	// The path expression may substitute a glob ("*") for a specific path
	// component. That is, any stream that matches the remaining structure qualifies
	// regardless of its value in that specific positional field.
	//
	// An unbounded wildcard may appear as a component at the end of both the
	// prefix and name query components. "**" matches all remaining components.
	//
	// If the supplied path query does not contain a path separator ("+"), it will
	// be treated as if the prefix is "**".
	//
	// Examples:
	//   - Empty ("") will return all streams.
	//   - **/+/** will return all streams.
	//   - foo/bar/** will return all streams with the "foo/bar" prefix.
	//   - foo/bar/**/+/baz will return all streams beginning with the "foo/bar"
	//     prefix and named "baz" (e.g., "foo/bar/qux/lol/+/baz")
	//   - foo/bar/+/** will return all streams with a "foo/bar" prefix.
	//   - foo/*/+/baz will return all streams with a two-component prefix whose
	//     first value is "foo" and whose name is "baz".
	//   - foo/bar will return all streams whose name is "foo/bar".
	//   - */* will return all streams with two-component names.
	Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
	// If true, returns that the streams' full state is returned instead of just
	// its Path.
	State bool `protobuf:"varint,3,opt,name=state" json:"state,omitempty"`
	// If true, causes the requested state to be returned as serialized protobuf
	// data instead of deserialized JSON structures.
	Proto bool `protobuf:"varint,4,opt,name=proto" json:"proto,omitempty"`
	// Next, if not empty, indicates that this query should continue at the point
	// where the previous query left off.
	Next string `protobuf:"bytes,5,opt,name=next" json:"next,omitempty"`
	// MaxResults is the maximum number of query results to return.
	//
	// If MaxResults is zero, no upper bound will be indicated. However, the
	// returned result count is still be subject to internal constraints.
	MaxResults int32 `protobuf:"varint,6,opt,name=max_results,json=maxResults" json:"max_results,omitempty"`
	// ContentType, if not empty, restricts results to streams with the supplied
	// content type.
	ContentType string                         `protobuf:"bytes,10,opt,name=content_type,json=contentType" json:"content_type,omitempty"`
	StreamType  *QueryRequest_StreamTypeFilter `protobuf:"bytes,11,opt,name=stream_type,json=streamType" json:"stream_type,omitempty"`
	// Newer restricts results to streams created after the specified date.
	Newer *google_protobuf.Timestamp `protobuf:"bytes,12,opt,name=newer" json:"newer,omitempty"`
	// Older restricts results to streams created before the specified date.
	Older *google_protobuf.Timestamp `protobuf:"bytes,13,opt,name=older" json:"older,omitempty"`
	// If not empty, constrains the results to those whose protobuf version string
	// matches the supplied version.
	ProtoVersion string `protobuf:"bytes,14,opt,name=proto_version,json=protoVersion" json:"proto_version,omitempty"`
	// Tags is the set of tags to constrain the query with.
	//
	// A Tag entry may either be:
	// - A key/value query, in which case the results are constrained by logs
	//   whose tag includes that key/value pair.
	// - A key with an missing (nil) value, in which case the results are
	//   constraints by logs that have that tag key, regardless of its value.
	Tags map[string]string `protobuf:"bytes,15,rep,name=tags" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Purged restricts the query to streams that have or haven't been purged.
	Purged QueryRequest_Trinary `protobuf:"varint,16,opt,name=purged,enum=logdog.QueryRequest_Trinary" json:"purged,omitempty"`
}

func (m *QueryRequest) Reset()                    { *m = QueryRequest{} }
func (m *QueryRequest) String() string            { return proto.CompactTextString(m) }
func (*QueryRequest) ProtoMessage()               {}
func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

func (m *QueryRequest) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *QueryRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *QueryRequest) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

func (m *QueryRequest) GetProto() bool {
	if m != nil {
		return m.Proto
	}
	return false
}

func (m *QueryRequest) GetNext() string {
	if m != nil {
		return m.Next
	}
	return ""
}

func (m *QueryRequest) GetMaxResults() int32 {
	if m != nil {
		return m.MaxResults
	}
	return 0
}

func (m *QueryRequest) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

func (m *QueryRequest) GetStreamType() *QueryRequest_StreamTypeFilter {
	if m != nil {
		return m.StreamType
	}
	return nil
}

func (m *QueryRequest) GetNewer() *google_protobuf.Timestamp {
	if m != nil {
		return m.Newer
	}
	return nil
}

func (m *QueryRequest) GetOlder() *google_protobuf.Timestamp {
	if m != nil {
		return m.Older
	}
	return nil
}

func (m *QueryRequest) GetProtoVersion() string {
	if m != nil {
		return m.ProtoVersion
	}
	return ""
}

func (m *QueryRequest) GetTags() map[string]string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *QueryRequest) GetPurged() QueryRequest_Trinary {
	if m != nil {
		return m.Purged
	}
	return QueryRequest_BOTH
}

// The stream type to filter on.
type QueryRequest_StreamTypeFilter struct {
	// The StreamType value to filter on.
	Value logpb.StreamType `protobuf:"varint,1,opt,name=value,enum=logpb.StreamType" json:"value,omitempty"`
}

func (m *QueryRequest_StreamTypeFilter) Reset()         { *m = QueryRequest_StreamTypeFilter{} }
func (m *QueryRequest_StreamTypeFilter) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_StreamTypeFilter) ProtoMessage()    {}
func (*QueryRequest_StreamTypeFilter) Descriptor() ([]byte, []int) {
	return fileDescriptor0, []int{3, 0}
}

func (m *QueryRequest_StreamTypeFilter) GetValue() logpb.StreamType {
	if m != nil {
		return m.Value
	}
	return logpb.StreamType_TEXT
}

// QueryResponse is the response structure for the user Query endpoint.
type QueryResponse struct {
	// Project is the project name that all responses belong to.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The list of streams that were identified as the result of the query.
	Streams []*QueryResponse_Stream `protobuf:"bytes,2,rep,name=streams" json:"streams,omitempty"`
	// If not empty, indicates that there are more query results available.
	// These results can be requested by repeating the Query request with the
	// same Path field and supplying this value in the Next field.
	Next string `protobuf:"bytes,3,opt,name=next" json:"next,omitempty"`
}

func (m *QueryResponse) Reset()                    { *m = QueryResponse{} }
func (m *QueryResponse) String() string            { return proto.CompactTextString(m) }
func (*QueryResponse) ProtoMessage()               {}
func (*QueryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *QueryResponse) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *QueryResponse) GetStreams() []*QueryResponse_Stream {
	if m != nil {
		return m.Streams
	}
	return nil
}

func (m *QueryResponse) GetNext() string {
	if m != nil {
		return m.Next
	}
	return ""
}

// Stream represents a single query response stream.
type QueryResponse_Stream struct {
	// Path is the log stream path.
	Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	// State is the log stream descriptor and state for this stream.
	//
	// It can be requested by setting the request's State field to true. If the
	// Proto field is true, the State's Descriptor field will not be included.
	State *LogStreamState `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
	// The JSON-packed log stream descriptor protobuf.
	//
	// A Descriptor entry corresponds to the Path with the same index.
	//
	// If the query request's State field is set, the descriptor will be
	// populated. If the Proto field is false, Descriptor will be populated;
	// otherwise, DescriptorProto will be populated with the serialized descriptor
	// protobuf.
	Desc *logpb.LogStreamDescriptor `protobuf:"bytes,3,opt,name=desc" json:"desc,omitempty"`
	// The serialized log stream Descriptor protobuf.
	DescProto []byte `protobuf:"bytes,4,opt,name=desc_proto,json=descProto,proto3" json:"desc_proto,omitempty"`
}

func (m *QueryResponse_Stream) Reset()                    { *m = QueryResponse_Stream{} }
func (m *QueryResponse_Stream) String() string            { return proto.CompactTextString(m) }
func (*QueryResponse_Stream) ProtoMessage()               {}
func (*QueryResponse_Stream) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4, 0} }

func (m *QueryResponse_Stream) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *QueryResponse_Stream) GetState() *LogStreamState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *QueryResponse_Stream) GetDesc() *logpb.LogStreamDescriptor {
	if m != nil {
		return m.Desc
	}
	return nil
}

func (m *QueryResponse_Stream) GetDescProto() []byte {
	if m != nil {
		return m.DescProto
	}
	return nil
}

// ListRequest is the request structure for the user List endpoint.
//
// The List endpoint enables a directory-tree style traversal of the project
// and log stream space.
//
// For example, if project "myproj" had streams "a/+/baz", a listing would
// return:
// - Request: project="", path="", Response: {myproj} (Project names)
// - Request: project="myproj", path="", Response: {a} (Path components)
// - Request: project="myproj", path="a", Response: {+} (Path component)
// - Request: project="myproj", path="a/+", Response: {baz} (Stream component)
type ListRequest struct {
	// The project to query.
	//
	// If this is empty, the list results will show all projects that the user can
	// access.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The path base to query.
	//
	// For example, log streams:
	// - foo/bar/+/baz
	// - foo/+/qux
	//
	// A query to path_base "foo" will return "bar" and "+", both path
	// components.
	PathBase string `protobuf:"bytes,2,opt,name=path_base,json=pathBase" json:"path_base,omitempty"`
	// State, if true, returns that the streams' full state instead of just its
	// Path.
	State bool `protobuf:"varint,3,opt,name=state" json:"state,omitempty"`
	// If not empty, indicates that this query should continue at the point where
	// the previous query left off.
	Next string `protobuf:"bytes,4,opt,name=next" json:"next,omitempty"`
	// If true, will return only streams. Otherwise, intermediate path components
	// will also be returned.
	StreamOnly bool `protobuf:"varint,5,opt,name=stream_only,json=streamOnly" json:"stream_only,omitempty"`
	// If true, indicates that purged streams should show up in the listing. It is
	// an error if a non-admin user requests this option.
	IncludePurged bool `protobuf:"varint,6,opt,name=include_purged,json=includePurged" json:"include_purged,omitempty"`
	// Offset, if >= 0, instructs the list operation to skip the supplied number
	// of results. This can be used for pagination.
	Offset int32 `protobuf:"varint,7,opt,name=offset" json:"offset,omitempty"`
	// The maximum number of componts to return.
	//
	// If <= 0, no upper bound will be indicated. However, the returned result
	// count is still be subject to internal constraints.
	MaxResults int32 `protobuf:"varint,8,opt,name=max_results,json=maxResults" json:"max_results,omitempty"`
}

func (m *ListRequest) Reset()                    { *m = ListRequest{} }
func (m *ListRequest) String() string            { return proto.CompactTextString(m) }
func (*ListRequest) ProtoMessage()               {}
func (*ListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *ListRequest) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *ListRequest) GetPathBase() string {
	if m != nil {
		return m.PathBase
	}
	return ""
}

func (m *ListRequest) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

func (m *ListRequest) GetNext() string {
	if m != nil {
		return m.Next
	}
	return ""
}

func (m *ListRequest) GetStreamOnly() bool {
	if m != nil {
		return m.StreamOnly
	}
	return false
}

func (m *ListRequest) GetIncludePurged() bool {
	if m != nil {
		return m.IncludePurged
	}
	return false
}

func (m *ListRequest) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *ListRequest) GetMaxResults() int32 {
	if m != nil {
		return m.MaxResults
	}
	return 0
}

// ListResponse is the response structure for the user List endpoint.
type ListResponse struct {
	// The project that the streams belong to.
	//
	// If the request was for the project tier of the list hierarchy, this will
	// be empty, and the components list will contain project elements.
	Project string `protobuf:"bytes,1,opt,name=project" json:"project,omitempty"`
	// The hierarchy base that was requested.
	PathBase string `protobuf:"bytes,2,opt,name=path_base,json=pathBase" json:"path_base,omitempty"`
	// If not empty, indicates that there are more list results available.
	// These results can be requested by repeating the List request with the
	// same Path field and supplying this value in the Next field.
	Next       string                    `protobuf:"bytes,3,opt,name=next" json:"next,omitempty"`
	Components []*ListResponse_Component `protobuf:"bytes,4,rep,name=components" json:"components,omitempty"`
}

func (m *ListResponse) Reset()                    { *m = ListResponse{} }
func (m *ListResponse) String() string            { return proto.CompactTextString(m) }
func (*ListResponse) ProtoMessage()               {}
func (*ListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *ListResponse) GetProject() string {
	if m != nil {
		return m.Project
	}
	return ""
}

func (m *ListResponse) GetPathBase() string {
	if m != nil {
		return m.PathBase
	}
	return ""
}

func (m *ListResponse) GetNext() string {
	if m != nil {
		return m.Next
	}
	return ""
}

func (m *ListResponse) GetComponents() []*ListResponse_Component {
	if m != nil {
		return m.Components
	}
	return nil
}

// The set of listed stream components.
type ListResponse_Component struct {
	// Name is the name of this path component.  When combined with the
	// response Base, this will form the full stream path.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// The type of the component.
	Type ListResponse_Component_Type `protobuf:"varint,2,opt,name=type,enum=logdog.ListResponse_Component_Type" json:"type,omitempty"`
	// State is the log stream descriptor and state for this stream. It will
	// only be filled if this is a STREAM component.
	//
	// It can be requested by setting the request's State field to true. If the
	// Proto field is true, the State's Descriptor field will not be included.
	State *LogStreamState `protobuf:"bytes,3,opt,name=state" json:"state,omitempty"`
	// Descriptor is the JSON-packed log stream descriptor protobuf. It will
	// only be filled if this is a STREAM component.
	//
	// A Descriptor entry corresponds to the Path with the same index.
	//
	// If the list request's State field is set, the descriptor will be
	// populated.
	Desc *logpb.LogStreamDescriptor `protobuf:"bytes,4,opt,name=desc" json:"desc,omitempty"`
}

func (m *ListResponse_Component) Reset()                    { *m = ListResponse_Component{} }
func (m *ListResponse_Component) String() string            { return proto.CompactTextString(m) }
func (*ListResponse_Component) ProtoMessage()               {}
func (*ListResponse_Component) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6, 0} }

func (m *ListResponse_Component) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ListResponse_Component) GetType() ListResponse_Component_Type {
	if m != nil {
		return m.Type
	}
	return ListResponse_Component_PATH
}

func (m *ListResponse_Component) GetState() *LogStreamState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *ListResponse_Component) GetDesc() *logpb.LogStreamDescriptor {
	if m != nil {
		return m.Desc
	}
	return nil
}

func init() {
	proto.RegisterType((*GetRequest)(nil), "logdog.GetRequest")
	proto.RegisterType((*GetRequest_SignURLRequest)(nil), "logdog.GetRequest.SignURLRequest")
	proto.RegisterType((*TailRequest)(nil), "logdog.TailRequest")
	proto.RegisterType((*GetResponse)(nil), "logdog.GetResponse")
	proto.RegisterType((*GetResponse_SignedUrls)(nil), "logdog.GetResponse.SignedUrls")
	proto.RegisterType((*QueryRequest)(nil), "logdog.QueryRequest")
	proto.RegisterType((*QueryRequest_StreamTypeFilter)(nil), "logdog.QueryRequest.StreamTypeFilter")
	proto.RegisterType((*QueryResponse)(nil), "logdog.QueryResponse")
	proto.RegisterType((*QueryResponse_Stream)(nil), "logdog.QueryResponse.Stream")
	proto.RegisterType((*ListRequest)(nil), "logdog.ListRequest")
	proto.RegisterType((*ListResponse)(nil), "logdog.ListResponse")
	proto.RegisterType((*ListResponse_Component)(nil), "logdog.ListResponse.Component")
	proto.RegisterEnum("logdog.QueryRequest_Trinary", QueryRequest_Trinary_name, QueryRequest_Trinary_value)
	proto.RegisterEnum("logdog.ListResponse_Component_Type", ListResponse_Component_Type_name, ListResponse_Component_Type_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Logs service

type LogsClient interface {
	// Get returns state and log data for a single log stream.
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// Tail returns the last log in the log stream at the time of the request.
	Tail(ctx context.Context, in *TailRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// Query returns log stream paths that match the requested query.
	Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error)
	// List returns log stream paths rooted under the path hierarchy.
	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
}
type logsPRPCClient struct {
	client *prpc.Client
}

func NewLogsPRPCClient(client *prpc.Client) LogsClient {
	return &logsPRPCClient{client}
}

func (c *logsPRPCClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.client.Call(ctx, "logdog.Logs", "Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsPRPCClient) Tail(ctx context.Context, in *TailRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.client.Call(ctx, "logdog.Logs", "Tail", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsPRPCClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
	out := new(QueryResponse)
	err := c.client.Call(ctx, "logdog.Logs", "Query", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsPRPCClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
	out := new(ListResponse)
	err := c.client.Call(ctx, "logdog.Logs", "List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type logsClient struct {
	cc *grpc.ClientConn
}

func NewLogsClient(cc *grpc.ClientConn) LogsClient {
	return &logsClient{cc}
}

func (c *logsClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := grpc.Invoke(ctx, "/logdog.Logs/Get", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsClient) Tail(ctx context.Context, in *TailRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := grpc.Invoke(ctx, "/logdog.Logs/Tail", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
	out := new(QueryResponse)
	err := grpc.Invoke(ctx, "/logdog.Logs/Query", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *logsClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
	out := new(ListResponse)
	err := grpc.Invoke(ctx, "/logdog.Logs/List", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Logs service

type LogsServer interface {
	// Get returns state and log data for a single log stream.
	Get(context.Context, *GetRequest) (*GetResponse, error)
	// Tail returns the last log in the log stream at the time of the request.
	Tail(context.Context, *TailRequest) (*GetResponse, error)
	// Query returns log stream paths that match the requested query.
	Query(context.Context, *QueryRequest) (*QueryResponse, error)
	// List returns log stream paths rooted under the path hierarchy.
	List(context.Context, *ListRequest) (*ListResponse, error)
}

func RegisterLogsServer(s prpc.Registrar, srv LogsServer) {
	s.RegisterService(&_Logs_serviceDesc, srv)
}

func _Logs_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LogsServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/logdog.Logs/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LogsServer).Get(ctx, req.(*GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Logs_Tail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TailRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LogsServer).Tail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/logdog.Logs/Tail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LogsServer).Tail(ctx, req.(*TailRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Logs_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LogsServer).Query(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/logdog.Logs/Query",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LogsServer).Query(ctx, req.(*QueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Logs_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LogsServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/logdog.Logs/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LogsServer).List(ctx, req.(*ListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Logs_serviceDesc = grpc.ServiceDesc{
	ServiceName: "logdog.Logs",
	HandlerType: (*LogsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Get",
			Handler:    _Logs_Get_Handler,
		},
		{
			MethodName: "Tail",
			Handler:    _Logs_Tail_Handler,
		},
		{
			MethodName: "Query",
			Handler:    _Logs_Query_Handler,
		},
		{
			MethodName: "List",
			Handler:    _Logs_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1/logs.proto",
}

func init() {
	proto.RegisterFile("github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1/logs.proto", fileDescriptor0)
}

var fileDescriptor0 = []byte{
	// 1130 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xef, 0x8e, 0xdb, 0x44,
	0x10, 0xc7, 0x89, 0xf3, 0x6f, 0x9c, 0xbb, 0x86, 0xa5, 0x54, 0xc6, 0xa5, 0x6d, 0x9a, 0x52, 0x11,
	0x24, 0x70, 0xda, 0x50, 0x28, 0x2a, 0x12, 0xa8, 0xbd, 0x5e, 0xcb, 0x9f, 0x83, 0xbb, 0x6e, 0x52,
	0x24, 0x3e, 0x45, 0x4e, 0xb2, 0xe7, 0x1a, 0x9c, 0x5d, 0xe3, 0x5d, 0x1f, 0x97, 0x67, 0xe0, 0x13,
	0x9f, 0x10, 0x8f, 0xc5, 0x23, 0x20, 0x1e, 0x80, 0x27, 0x40, 0x42, 0x3b, 0x6b, 0xc7, 0x69, 0x1a,
	0x7a, 0x45, 0x94, 0x2f, 0x49, 0x66, 0xe6, 0x37, 0xbb, 0x3b, 0xbf, 0x99, 0xdf, 0x6e, 0xe0, 0xcb,
	0x30, 0x52, 0x4f, 0xb2, 0xa9, 0x3f, 0x13, 0x8b, 0x41, 0x9c, 0xcd, 0x22, 0xfc, 0x78, 0x2f, 0x14,
	0x83, 0x58, 0x84, 0x73, 0x11, 0x0e, 0x82, 0x24, 0x1a, 0x30, 0x3e, 0x4f, 0x44, 0xc4, 0x95, 0x1c,
	0xcc, 0x84, 0x48, 0xe7, 0x11, 0x0f, 0x94, 0x48, 0x35, 0x40, 0x0e, 0x4e, 0x6e, 0xe2, 0xb7, 0x9f,
	0xa4, 0x42, 0x09, 0x52, 0x37, 0x49, 0xde, 0xc1, 0x7f, 0x5e, 0x54, 0xaa, 0x40, 0x31, 0xb3, 0xaa,
	0x37, 0x7c, 0x81, 0xd5, 0x62, 0x11, 0x26, 0x53, 0xfd, 0x99, 0xe7, 0x5c, 0x09, 0x85, 0x08, 0x63,
	0x36, 0x40, 0x6b, 0x9a, 0x1d, 0x0f, 0x54, 0xb4, 0x60, 0x52, 0x05, 0x8b, 0x24, 0x07, 0x5c, 0xde,
	0x04, 0xcc, 0xb3, 0x34, 0x50, 0x91, 0xe0, 0x26, 0xde, 0xfb, 0xa9, 0x0a, 0xf0, 0x90, 0x29, 0xca,
	0x7e, 0xc8, 0x98, 0x54, 0xc4, 0x85, 0x46, 0x92, 0x8a, 0xef, 0xd8, 0x4c, 0xb9, 0x56, 0xd7, 0xea,
	0xb7, 0x68, 0x61, 0x12, 0x02, 0x76, 0x12, 0xa8, 0x27, 0x6e, 0x05, 0xdd, 0xf8, 0x9b, 0x9c, 0x87,
	0x1a, 0x16, 0xe0, 0x56, 0xbb, 0x56, 0xbf, 0x49, 0x8d, 0xa1, 0xbd, 0x11, 0x9f, 0xb3, 0x53, 0xd7,
	0xee, 0x5a, 0xfd, 0x2a, 0x35, 0x06, 0xb9, 0x04, 0x30, 0x5d, 0x2a, 0x36, 0x99, 0x89, 0x8c, 0x2b,
	0xb7, 0xd6, 0xb5, 0xfa, 0x35, 0xda, 0xd2, 0x9e, 0x3d, 0xed, 0x20, 0x17, 0xa1, 0x15, 0x8b, 0x30,
	0x8f, 0xd6, 0x31, 0xda, 0x8c, 0x45, 0x68, 0x82, 0xd7, 0x61, 0x97, 0x0b, 0x3e, 0x99, 0x09, 0xae,
	0xa2, 0x30, 0x13, 0x99, 0x74, 0x1b, 0xb8, 0xe1, 0x0e, 0x17, 0x7c, 0x6f, 0xe5, 0x24, 0x9f, 0xc3,
	0xb9, 0x90, 0xa9, 0x89, 0x8c, 0x42, 0xce, 0xe6, 0x93, 0x2c, 0x8d, 0xa5, 0xdb, 0xec, 0x5a, 0x7d,
	0x67, 0x78, 0xd5, 0x37, 0x14, 0xfa, 0x65, 0xa5, 0xfe, 0x28, 0x0a, 0xf9, 0x63, 0x7a, 0x90, 0x9b,
	0x74, 0x27, 0x64, 0x6a, 0x84, 0x89, 0x8f, 0xd3, 0x58, 0x7a, 0x19, 0xec, 0x3e, 0x0d, 0x20, 0x1f,
	0x40, 0x33, 0x8e, 0x8e, 0x99, 0xe6, 0x17, 0xa9, 0x71, 0x86, 0x6f, 0xf8, 0x86, 0x5b, 0xbf, 0xe0,
	0xd6, 0xbf, 0x9f, 0x73, 0x4b, 0x57, 0x50, 0x72, 0x01, 0xea, 0x52, 0xa5, 0x2c, 0x58, 0x20, 0x71,
	0x4d, 0x9a, 0x5b, 0x25, 0x49, 0x39, 0x75, 0x68, 0xf4, 0x1e, 0x81, 0x33, 0x0e, 0xa2, 0xf8, 0x25,
	0x76, 0xa3, 0xf7, 0x47, 0x05, 0x1c, 0x2c, 0x5b, 0x26, 0x82, 0x4b, 0xf6, 0x9c, 0x35, 0xdf, 0x2d,
	0xf2, 0x2b, 0x58, 0xde, 0x85, 0x82, 0xb4, 0x03, 0x11, 0x8e, 0xf0, 0xd0, 0x23, 0x1d, 0x2d, 0xba,
	0xec, 0x83, 0x3d, 0x67, 0x72, 0x86, 0x9b, 0x39, 0x43, 0xcf, 0xc7, 0xc9, 0x2c, 0xb1, 0xf7, 0x99,
	0x9c, 0xa5, 0x51, 0xa2, 0x44, 0x4a, 0x11, 0x47, 0xae, 0x81, 0xad, 0x87, 0xde, 0xb5, 0xbb, 0xd5,
	0xbe, 0x33, 0x3c, 0x57, 0xe2, 0xf7, 0xb9, 0x4a, 0x97, 0x14, 0x83, 0xe4, 0x53, 0x70, 0xd6, 0xbb,
	0x57, 0xc3, 0xb5, 0x2f, 0x3f, 0xd5, 0x3d, 0x53, 0x86, 0x5f, 0xf6, 0x8a, 0x82, 0x2c, 0xfb, 0x76,
	0x02, 0x50, 0x46, 0xc8, 0x1d, 0x00, 0x76, 0x9a, 0x44, 0xa6, 0x29, 0x79, 0xd7, 0xbc, 0x67, 0xba,
	0x36, 0x2e, 0x24, 0x43, 0xd7, 0xd0, 0x1b, 0x8d, 0x6b, 0x6d, 0x6f, 0x5c, 0xab, 0x68, 0xdc, 0x2f,
	0x35, 0x68, 0x3f, 0xca, 0x58, 0xba, 0x7c, 0xc9, 0x42, 0xc2, 0x43, 0xa2, 0x90, 0x9a, 0xd4, 0x18,
	0x3a, 0x9f, 0xb3, 0x53, 0x23, 0xa1, 0x16, 0xc5, 0xdf, 0xe4, 0x0a, 0x38, 0x8b, 0xe0, 0x74, 0x92,
	0x32, 0x99, 0xc5, 0x4a, 0xe6, 0xfa, 0x81, 0x45, 0x70, 0x4a, 0x8d, 0x87, 0x5c, 0x85, 0xb6, 0x56,
	0x0f, 0xe3, 0x6a, 0xa2, 0x96, 0x09, 0x73, 0x01, 0x93, 0x9d, 0xdc, 0x37, 0x5e, 0x26, 0x8c, 0x3c,
	0x00, 0xc7, 0x94, 0x68, 0x10, 0x0e, 0xb2, 0x75, 0xbd, 0xe0, 0x7e, 0xbd, 0x38, 0xdf, 0xb4, 0x58,
	0x67, 0x3d, 0x88, 0x62, 0xc5, 0x52, 0x0a, 0x72, 0xe5, 0x21, 0x37, 0xa0, 0xc6, 0xd9, 0x8f, 0x2c,
	0x75, 0xdb, 0x67, 0xf2, 0x6d, 0x80, 0x3a, 0x43, 0xc4, 0x73, 0x96, 0xba, 0x3b, 0x67, 0x67, 0x20,
	0x90, 0x5c, 0x83, 0x1d, 0x0c, 0x4e, 0x4e, 0x58, 0x2a, 0x75, 0x6f, 0x77, 0xb1, 0x9e, 0x36, 0x3a,
	0xbf, 0x31, 0x3e, 0x32, 0x04, 0x5b, 0x05, 0xa1, 0x74, 0xcf, 0xe1, 0xc4, 0x5d, 0xde, 0x5a, 0xc9,
	0x38, 0x08, 0x65, 0x3e, 0x80, 0x1a, 0x4b, 0x6e, 0x41, 0x3d, 0xc9, 0xd2, 0x90, 0xcd, 0xdd, 0x4e,
	0xd7, 0xea, 0xef, 0x0e, 0xdf, 0xdc, 0x9e, 0x95, 0x46, 0x3c, 0x48, 0x97, 0x34, 0xc7, 0x7a, 0x1f,
	0x43, 0x67, 0x93, 0x12, 0xf2, 0x36, 0xd4, 0x4e, 0x82, 0x38, 0x33, 0x97, 0xc5, 0xee, 0xf0, 0xd5,
	0x7c, 0xe0, 0x4b, 0x1c, 0x35, 0x71, 0xef, 0x36, 0xb4, 0x56, 0xa7, 0x20, 0x1d, 0xa8, 0x7e, 0xcf,
	0x96, 0xf9, 0xc8, 0xe8, 0x9f, 0x7a, 0x08, 0xcc, 0x3a, 0x66, 0x5e, 0x8c, 0x71, 0xa7, 0xf2, 0x91,
	0xd5, 0x7b, 0x0b, 0x1a, 0xf9, 0x41, 0x48, 0x13, 0xec, 0x7b, 0x87, 0xe3, 0xcf, 0x3a, 0xaf, 0x90,
	0x06, 0x54, 0xbf, 0xdd, 0x1f, 0x75, 0x2c, 0x52, 0x87, 0xca, 0xd7, 0x87, 0x9d, 0x4a, 0xef, 0xe7,
	0x0a, 0xec, 0xe4, 0x87, 0x3f, 0xf3, 0x06, 0xf8, 0x10, 0x1a, 0xa6, 0x91, 0xd2, 0xad, 0x20, 0x69,
	0x9b, 0xe5, 0x17, 0xe2, 0x43, 0x10, 0x2d, 0xc0, 0xab, 0x91, 0xac, 0x96, 0x23, 0xe9, 0xfd, 0x6a,
	0x41, 0xdd, 0xe0, 0x56, 0x13, 0x6f, 0xad, 0x4d, 0xfc, 0xff, 0x7b, 0xd9, 0x5c, 0x02, 0xd0, 0xdf,
	0x93, 0x52, 0x3e, 0x6d, 0xda, 0xd2, 0x9e, 0x23, 0x7c, 0xf4, 0xfe, 0xb4, 0xc0, 0x39, 0x88, 0xe4,
	0x0b, 0xbc, 0x7a, 0x17, 0xa1, 0xa5, 0x8f, 0x3b, 0x99, 0x06, 0xb2, 0xe8, 0x40, 0x53, 0x3b, 0xee,
	0x05, 0x92, 0xfd, 0x83, 0x6a, 0x0b, 0x32, 0xec, 0xa7, 0xf5, 0x99, 0x6b, 0x4b, 0xf0, 0x78, 0x89,
	0xd2, 0x6d, 0x16, 0xa2, 0x39, 0xe4, 0xf1, 0x52, 0xbf, 0x70, 0x11, 0x9f, 0xc5, 0xd9, 0x9c, 0x4d,
	0xf2, 0xf9, 0xab, 0x9b, 0x17, 0x2e, 0xf7, 0x1e, 0xa1, 0x53, 0x5f, 0x4a, 0xe2, 0xf8, 0x58, 0x32,
	0x85, 0x0f, 0x60, 0x8d, 0xe6, 0xd6, 0xa6, 0xfe, 0x9b, 0x9b, 0xfa, 0xef, 0xfd, 0x55, 0x81, 0xb6,
	0xa9, 0xf8, 0xcc, 0x21, 0x78, 0x6e, 0xc9, 0x5b, 0x3a, 0x4d, 0x3e, 0x01, 0x98, 0x89, 0x45, 0x22,
	0x38, 0xe3, 0xaa, 0xb8, 0xdf, 0x57, 0x6a, 0x5b, 0xdf, 0xd4, 0xdf, 0x2b, 0x60, 0x74, 0x2d, 0xc3,
	0xfb, 0xdd, 0x82, 0xd6, 0x2a, 0x82, 0x3b, 0x04, 0xf9, 0x1b, 0xab, 0x77, 0x08, 0x16, 0x8c, 0xdc,
	0x06, 0x1b, 0xef, 0xa4, 0x0a, 0x4a, 0xe9, 0xda, 0xf3, 0xd7, 0xf6, 0x51, 0x5c, 0x98, 0x50, 0x4e,
	0x59, 0xf5, 0xdf, 0x4c, 0x99, 0xfd, 0x62, 0x53, 0xd6, 0x7b, 0x07, 0x6c, 0xbc, 0xf1, 0x9a, 0x60,
	0x1f, 0xdd, 0x45, 0xf5, 0x01, 0xd4, 0x47, 0x63, 0xba, 0x7f, 0xf7, 0xab, 0x8e, 0x45, 0x1c, 0x68,
	0x1c, 0xd1, 0xc3, 0x2f, 0xf6, 0xf7, 0xc6, 0x9d, 0xca, 0xf0, 0x37, 0x0b, 0xec, 0x03, 0xfd, 0xc2,
	0xf9, 0x50, 0x7d, 0xc8, 0x14, 0x21, 0xcf, 0xfe, 0x23, 0xf1, 0x5e, 0xdb, 0xf2, 0xce, 0x91, 0x1b,
	0x60, 0xeb, 0x7f, 0x04, 0x64, 0x15, 0x5c, 0xfb, 0x7f, 0xb0, 0x3d, 0xe3, 0x16, 0xd4, 0x50, 0xad,
	0xe4, 0xfc, 0xb6, 0xbb, 0xcb, 0x7b, 0x7d, 0xab, 0xa4, 0xc9, 0x4d, 0xb0, 0x35, 0x9d, 0xe5, 0x3e,
	0x6b, 0xfa, 0xf0, 0xce, 0x6f, 0x63, 0x7c, 0x5a, 0x47, 0x75, 0xbd, 0xff, 0x77, 0x00, 0x00, 0x00,
	0xff, 0xff, 0x92, 0xcb, 0xcc, 0xa4, 0x5b, 0x0b, 0x00, 0x00,
}