gitpod/components/supervisor-api/go/token.pb.go

// Copyright (c) 2020 TypeFox GmbH. All rights reserved.
// Licensed under the GNU Affero General Public License (AGPL).
// See License-AGPL.txt in the project root for license information.

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: token.proto

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type TokenReuse int32

const (
	// REUSE_NEVER means the token can never be re-used.
	// This mode only makes sense when providing a token in response to a request.
	TokenReuse_REUSE_NEVER TokenReuse = 0
	// REUSE_EXACTLY means the token can only be reused when the requested scopes
	// exactly match those of the token.
	TokenReuse_REUSE_EXACTLY TokenReuse = 1
	// REUSE_WHEN_POSSIBLE means the token can be reused when the requested scopes
	// are a subset of the token's scopes.
	TokenReuse_REUSE_WHEN_POSSIBLE TokenReuse = 2
)

var TokenReuse_name = map[int32]string{
	0: "REUSE_NEVER",
	1: "REUSE_EXACTLY",
	2: "REUSE_WHEN_POSSIBLE",
}

var TokenReuse_value = map[string]int32{
	"REUSE_NEVER":         0,
	"REUSE_EXACTLY":       1,
	"REUSE_WHEN_POSSIBLE": 2,
}

func (x TokenReuse) String() string {
	return proto.EnumName(TokenReuse_name, int32(x))
}

func (TokenReuse) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_3aff0bcd502840ab, []int{0}
}

type GetTokenRequest struct {
	Host                 string   `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	Scope                []string `protobuf:"bytes,2,rep,name=scope,proto3" json:"scope,omitempty"`
	Description          string   `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *GetTokenRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTokenRequest.Unmarshal(m, b)
}
func (m *GetTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTokenRequest.Marshal(b, m, deterministic)
}
func (m *GetTokenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTokenRequest.Merge(m, src)
}
func (m *GetTokenRequest) XXX_Size() int {
	return xxx_messageInfo_GetTokenRequest.Size(m)
}
func (m *GetTokenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTokenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTokenRequest proto.InternalMessageInfo

func (m *GetTokenRequest) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *GetTokenRequest) GetScope() []string {
	if m != nil {
		return m.Scope
	}
	return nil
}

func (m *GetTokenRequest) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type GetTokenResponse struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *GetTokenResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetTokenResponse.Unmarshal(m, b)
}
func (m *GetTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetTokenResponse.Marshal(b, m, deterministic)
}
func (m *GetTokenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTokenResponse.Merge(m, src)
}
func (m *GetTokenResponse) XXX_Size() int {
	return xxx_messageInfo_GetTokenResponse.Size(m)
}
func (m *GetTokenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTokenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTokenResponse proto.InternalMessageInfo

func (m *GetTokenResponse) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

type SetTokenRequest struct {
	Host                 string               `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	Scope                []string             `protobuf:"bytes,2,rep,name=scope,proto3" json:"scope,omitempty"`
	Token                string               `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
	ExpiryDate           *timestamp.Timestamp `protobuf:"bytes,4,opt,name=expiry_date,json=expiryDate,proto3" json:"expiry_date,omitempty"`
	Reuse                TokenReuse           `protobuf:"varint,5,opt,name=reuse,proto3,enum=supervisor.TokenReuse" json:"reuse,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *SetTokenRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetTokenRequest.Unmarshal(m, b)
}
func (m *SetTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetTokenRequest.Marshal(b, m, deterministic)
}
func (m *SetTokenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetTokenRequest.Merge(m, src)
}
func (m *SetTokenRequest) XXX_Size() int {
	return xxx_messageInfo_SetTokenRequest.Size(m)
}
func (m *SetTokenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetTokenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetTokenRequest proto.InternalMessageInfo

func (m *SetTokenRequest) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *SetTokenRequest) GetScope() []string {
	if m != nil {
		return m.Scope
	}
	return nil
}

func (m *SetTokenRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *SetTokenRequest) GetExpiryDate() *timestamp.Timestamp {
	if m != nil {
		return m.ExpiryDate
	}
	return nil
}

func (m *SetTokenRequest) GetReuse() TokenReuse {
	if m != nil {
		return m.Reuse
	}
	return TokenReuse_REUSE_NEVER
}

type SetTokenResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *SetTokenResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetTokenResponse.Unmarshal(m, b)
}
func (m *SetTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetTokenResponse.Marshal(b, m, deterministic)
}
func (m *SetTokenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetTokenResponse.Merge(m, src)
}
func (m *SetTokenResponse) XXX_Size() int {
	return xxx_messageInfo_SetTokenResponse.Size(m)
}
func (m *SetTokenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetTokenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetTokenResponse proto.InternalMessageInfo

type ClearTokenRequest struct {
	// Types that are valid to be assigned to Token:
	//	*ClearTokenRequest_Value
	//	*ClearTokenRequest_All
	Token                isClearTokenRequest_Token `protobuf_oneof:"token"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

func (m *ClearTokenRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClearTokenRequest.Unmarshal(m, b)
}
func (m *ClearTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClearTokenRequest.Marshal(b, m, deterministic)
}
func (m *ClearTokenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClearTokenRequest.Merge(m, src)
}
func (m *ClearTokenRequest) XXX_Size() int {
	return xxx_messageInfo_ClearTokenRequest.Size(m)
}
func (m *ClearTokenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ClearTokenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ClearTokenRequest proto.InternalMessageInfo

type isClearTokenRequest_Token interface {
	isClearTokenRequest_Token()
}

type ClearTokenRequest_Value struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3,oneof"`
}

type ClearTokenRequest_All struct {
	All bool `protobuf:"varint,2,opt,name=all,proto3,oneof"`
}

func (*ClearTokenRequest_Value) isClearTokenRequest_Token() {}

func (*ClearTokenRequest_All) isClearTokenRequest_Token() {}

func (m *ClearTokenRequest) GetToken() isClearTokenRequest_Token {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *ClearTokenRequest) GetValue() string {
	if x, ok := m.GetToken().(*ClearTokenRequest_Value); ok {
		return x.Value
	}
	return ""
}

func (m *ClearTokenRequest) GetAll() bool {
	if x, ok := m.GetToken().(*ClearTokenRequest_All); ok {
		return x.All
	}
	return false
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ClearTokenRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ClearTokenRequest_Value)(nil),
		(*ClearTokenRequest_All)(nil),
	}
}

type ClearTokenResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ClearTokenResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClearTokenResponse.Unmarshal(m, b)
}
func (m *ClearTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClearTokenResponse.Marshal(b, m, deterministic)
}
func (m *ClearTokenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClearTokenResponse.Merge(m, src)
}
func (m *ClearTokenResponse) XXX_Size() int {
	return xxx_messageInfo_ClearTokenResponse.Size(m)
}
func (m *ClearTokenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ClearTokenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ClearTokenResponse proto.InternalMessageInfo

type ProvideTokenRequest struct {
	// Types that are valid to be assigned to Message:
	//	*ProvideTokenRequest_Registration
	//	*ProvideTokenRequest_Answer
	Message              isProvideTokenRequest_Message `protobuf_oneof:"message"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

func (m *ProvideTokenRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProvideTokenRequest.Unmarshal(m, b)
}
func (m *ProvideTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProvideTokenRequest.Marshal(b, m, deterministic)
}
func (m *ProvideTokenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProvideTokenRequest.Merge(m, src)
}
func (m *ProvideTokenRequest) XXX_Size() int {
	return xxx_messageInfo_ProvideTokenRequest.Size(m)
}
func (m *ProvideTokenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ProvideTokenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ProvideTokenRequest proto.InternalMessageInfo

type isProvideTokenRequest_Message interface {
	isProvideTokenRequest_Message()
}

type ProvideTokenRequest_Registration struct {
	Registration *ProvideTokenRequest_RegisterProvider `protobuf:"bytes,1,opt,name=registration,proto3,oneof"`
}

type ProvideTokenRequest_Answer struct {
	Answer *SetTokenRequest `protobuf:"bytes,2,opt,name=answer,proto3,oneof"`
}

func (*ProvideTokenRequest_Registration) isProvideTokenRequest_Message() {}

func (*ProvideTokenRequest_Answer) isProvideTokenRequest_Message() {}

func (m *ProvideTokenRequest) GetMessage() isProvideTokenRequest_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *ProvideTokenRequest) GetRegistration() *ProvideTokenRequest_RegisterProvider {
	if x, ok := m.GetMessage().(*ProvideTokenRequest_Registration); ok {
		return x.Registration
	}
	return nil
}

func (m *ProvideTokenRequest) GetAnswer() *SetTokenRequest {
	if x, ok := m.GetMessage().(*ProvideTokenRequest_Answer); ok {
		return x.Answer
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ProvideTokenRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ProvideTokenRequest_Registration)(nil),
		(*ProvideTokenRequest_Answer)(nil),
	}
}

type ProvideTokenRequest_RegisterProvider struct {
	Host                 string   `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ProvideTokenRequest_RegisterProvider) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProvideTokenRequest_RegisterProvider.Unmarshal(m, b)
}
func (m *ProvideTokenRequest_RegisterProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProvideTokenRequest_RegisterProvider.Marshal(b, m, deterministic)
}
func (m *ProvideTokenRequest_RegisterProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProvideTokenRequest_RegisterProvider.Merge(m, src)
}
func (m *ProvideTokenRequest_RegisterProvider) XXX_Size() int {
	return xxx_messageInfo_ProvideTokenRequest_RegisterProvider.Size(m)
}
func (m *ProvideTokenRequest_RegisterProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_ProvideTokenRequest_RegisterProvider.DiscardUnknown(m)
}

var xxx_messageInfo_ProvideTokenRequest_RegisterProvider proto.InternalMessageInfo

func (m *ProvideTokenRequest_RegisterProvider) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

type ProvideTokenResponse struct {
	Request              *GetTokenRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ProvideTokenResponse) Reset()         { *m = ProvideTokenResponse{} }
func (m *ProvideTokenResponse) String() string { return proto.CompactTextString(m) }
func (*ProvideTokenResponse) ProtoMessage()    {}
func (*ProvideTokenResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3aff0bcd502840ab, []int{7}
}

func (m *ProvideTokenResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProvideTokenResponse.Unmarshal(m, b)
}
func (m *ProvideTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProvideTokenResponse.Marshal(b, m, deterministic)
}
func (m *ProvideTokenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProvideTokenResponse.Merge(m, src)
}
func (m *ProvideTokenResponse) XXX_Size() int {
	return xxx_messageInfo_ProvideTokenResponse.Size(m)
}
func (m *ProvideTokenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ProvideTokenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ProvideTokenResponse proto.InternalMessageInfo

func (m *ProvideTokenResponse) GetRequest() *GetTokenRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func init() {
	proto.RegisterEnum("supervisor.TokenReuse", TokenReuse_name, TokenReuse_value)
	proto.RegisterType((*GetTokenRequest)(nil), "supervisor.GetTokenRequest")
	proto.RegisterType((*GetTokenResponse)(nil), "supervisor.GetTokenResponse")
	proto.RegisterType((*SetTokenRequest)(nil), "supervisor.SetTokenRequest")
	proto.RegisterType((*SetTokenResponse)(nil), "supervisor.SetTokenResponse")
	proto.RegisterType((*ClearTokenRequest)(nil), "supervisor.ClearTokenRequest")
	proto.RegisterType((*ClearTokenResponse)(nil), "supervisor.ClearTokenResponse")
	proto.RegisterType((*ProvideTokenRequest)(nil), "supervisor.ProvideTokenRequest")
	proto.RegisterType((*ProvideTokenRequest_RegisterProvider)(nil), "supervisor.ProvideTokenRequest.RegisterProvider")
	proto.RegisterType((*ProvideTokenResponse)(nil), "supervisor.ProvideTokenResponse")
}

func init() {
	proto.RegisterFile("token.proto", fileDescriptor_3aff0bcd502840ab)
}

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

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

// 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.SupportPackageIsVersion6

// TokenServiceClient is the client API for TokenService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TokenServiceClient interface {
	GetToken(ctx context.Context, in *GetTokenRequest, opts ...grpc.CallOption) (*GetTokenResponse, error)
	SetToken(ctx context.Context, in *SetTokenRequest, opts ...grpc.CallOption) (*SetTokenResponse, error)
	ClearToken(ctx context.Context, in *ClearTokenRequest, opts ...grpc.CallOption) (*ClearTokenResponse, error)
	ProvideToken(ctx context.Context, opts ...grpc.CallOption) (TokenService_ProvideTokenClient, error)
}

type tokenServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTokenServiceClient(cc grpc.ClientConnInterface) TokenServiceClient {
	return &tokenServiceClient{cc}
}

func (c *tokenServiceClient) GetToken(ctx context.Context, in *GetTokenRequest, opts ...grpc.CallOption) (*GetTokenResponse, error) {
	out := new(GetTokenResponse)
	err := c.cc.Invoke(ctx, "/supervisor.TokenService/GetToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenServiceClient) SetToken(ctx context.Context, in *SetTokenRequest, opts ...grpc.CallOption) (*SetTokenResponse, error) {
	out := new(SetTokenResponse)
	err := c.cc.Invoke(ctx, "/supervisor.TokenService/SetToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenServiceClient) ClearToken(ctx context.Context, in *ClearTokenRequest, opts ...grpc.CallOption) (*ClearTokenResponse, error) {
	out := new(ClearTokenResponse)
	err := c.cc.Invoke(ctx, "/supervisor.TokenService/ClearToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tokenServiceClient) ProvideToken(ctx context.Context, opts ...grpc.CallOption) (TokenService_ProvideTokenClient, error) {
	stream, err := c.cc.NewStream(ctx, &_TokenService_serviceDesc.Streams[0], "/supervisor.TokenService/ProvideToken", opts...)
	if err != nil {
		return nil, err
	}
	x := &tokenServiceProvideTokenClient{stream}
	return x, nil
}

type TokenService_ProvideTokenClient interface {
	Send(*ProvideTokenRequest) error
	Recv() (*ProvideTokenResponse, error)
	grpc.ClientStream
}

type tokenServiceProvideTokenClient struct {
	grpc.ClientStream
}

func (x *tokenServiceProvideTokenClient) Send(m *ProvideTokenRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *tokenServiceProvideTokenClient) Recv() (*ProvideTokenResponse, error) {
	m := new(ProvideTokenResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// TokenServiceServer is the server API for TokenService service.
type TokenServiceServer interface {
	GetToken(context.Context, *GetTokenRequest) (*GetTokenResponse, error)
	SetToken(context.Context, *SetTokenRequest) (*SetTokenResponse, error)
	ClearToken(context.Context, *ClearTokenRequest) (*ClearTokenResponse, error)
	ProvideToken(TokenService_ProvideTokenServer) error
}

// UnimplementedTokenServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTokenServiceServer struct {
}

func (*UnimplementedTokenServiceServer) GetToken(ctx context.Context, req *GetTokenRequest) (*GetTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetToken not implemented")
}
func (*UnimplementedTokenServiceServer) SetToken(ctx context.Context, req *SetTokenRequest) (*SetTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetToken not implemented")
}
func (*UnimplementedTokenServiceServer) ClearToken(ctx context.Context, req *ClearTokenRequest) (*ClearTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClearToken not implemented")
}
func (*UnimplementedTokenServiceServer) ProvideToken(srv TokenService_ProvideTokenServer) error {
	return status.Errorf(codes.Unimplemented, "method ProvideToken not implemented")
}

func RegisterTokenServiceServer(s *grpc.Server, srv TokenServiceServer) {
	s.RegisterService(&_TokenService_serviceDesc, srv)
}

func _TokenService_GetToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenServiceServer).GetToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/supervisor.TokenService/GetToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenServiceServer).GetToken(ctx, req.(*GetTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenService_SetToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenServiceServer).SetToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/supervisor.TokenService/SetToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenServiceServer).SetToken(ctx, req.(*SetTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenService_ClearToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenServiceServer).ClearToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/supervisor.TokenService/ClearToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenServiceServer).ClearToken(ctx, req.(*ClearTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TokenService_ProvideToken_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TokenServiceServer).ProvideToken(&tokenServiceProvideTokenServer{stream})
}

type TokenService_ProvideTokenServer interface {
	Send(*ProvideTokenResponse) error
	Recv() (*ProvideTokenRequest, error)
	grpc.ServerStream
}

type tokenServiceProvideTokenServer struct {
	grpc.ServerStream
}

func (x *tokenServiceProvideTokenServer) Send(m *ProvideTokenResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *tokenServiceProvideTokenServer) Recv() (*ProvideTokenRequest, error) {
	m := new(ProvideTokenRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _TokenService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "supervisor.TokenService",
	HandlerType: (*TokenServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetToken",
			Handler:    _TokenService_GetToken_Handler,
		},
		{
			MethodName: "SetToken",
			Handler:    _TokenService_SetToken_Handler,
		},
		{
			MethodName: "ClearToken",
			Handler:    _TokenService_ClearToken_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ProvideToken",
			Handler:       _TokenService_ProvideToken_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "token.proto",
}