// SPDX-License-Identifier: MIT

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: ermite/token.proto

package ermite

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Scope is a permission carried by a token. The API knows scopes only; any
// grouping into presets is a client concern.
type Scope int32

const (
	// Not set. Rejected in requests, never returned by the server.
	Scope_SCOPE_UNSPECIFIED Scope = 0
	// SCOPE_REPO_READ allows reading private repositories (public ones need no
	// token). Wire name: repo:read.
	Scope_SCOPE_REPO_READ Scope = 1
	// SCOPE_REPO_WRITE allows pushing and creating repositories. Wire name:
	// repo:write.
	Scope_SCOPE_REPO_WRITE Scope = 2
	// SCOPE_REPO_ADMIN allows deleting a repository and changing its visibility,
	// description or default branch. Wire name: repo:admin.
	Scope_SCOPE_REPO_ADMIN Scope = 3
	// SCOPE_MR_WRITE allows creating, commenting on and closing merge requests.
	// Wire name: mr:write.
	Scope_SCOPE_MR_WRITE Scope = 4
	// SCOPE_MR_MERGE allows merging merge requests. Wire name: mr:merge.
	Scope_SCOPE_MR_MERGE Scope = 5
	// SCOPE_CI_WRITE allows re-running or cancelling CI runs. Wire name:
	// ci:write.
	Scope_SCOPE_CI_WRITE Scope = 6
	// SCOPE_SECRETS_WRITE allows managing secrets, variables and environments
	// (SecretService, VariableService, EnvironmentService), reads included. A
	// token limited to branches is refused them even with this scope. Wire name:
	// secrets:write.
	Scope_SCOPE_SECRETS_WRITE Scope = 7
	// SCOPE_RUNNER_REGISTER allows registering a CI runner. Wire name:
	// runner:register.
	Scope_SCOPE_RUNNER_REGISTER Scope = 8
	// SCOPE_TOKEN_ADMIN allows creating, listing and revoking tokens. Wire name:
	// token:admin.
	Scope_SCOPE_TOKEN_ADMIN Scope = 9
)

// Enum value maps for Scope.
var (
	Scope_name = map[int32]string{
		0: "SCOPE_UNSPECIFIED",
		1: "SCOPE_REPO_READ",
		2: "SCOPE_REPO_WRITE",
		3: "SCOPE_REPO_ADMIN",
		4: "SCOPE_MR_WRITE",
		5: "SCOPE_MR_MERGE",
		6: "SCOPE_CI_WRITE",
		7: "SCOPE_SECRETS_WRITE",
		8: "SCOPE_RUNNER_REGISTER",
		9: "SCOPE_TOKEN_ADMIN",
	}
	Scope_value = map[string]int32{
		"SCOPE_UNSPECIFIED":     0,
		"SCOPE_REPO_READ":       1,
		"SCOPE_REPO_WRITE":      2,
		"SCOPE_REPO_ADMIN":      3,
		"SCOPE_MR_WRITE":        4,
		"SCOPE_MR_MERGE":        5,
		"SCOPE_CI_WRITE":        6,
		"SCOPE_SECRETS_WRITE":   7,
		"SCOPE_RUNNER_REGISTER": 8,
		"SCOPE_TOKEN_ADMIN":     9,
	}
)

func (x Scope) Enum() *Scope {
	p := new(Scope)
	*p = x
	return p
}

func (x Scope) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Scope) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_token_proto_enumTypes[0].Descriptor()
}

func (Scope) Type() protoreflect.EnumType {
	return &file_ermite_token_proto_enumTypes[0]
}

func (x Scope) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Scope.Descriptor instead.
func (Scope) EnumDescriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{0}
}

// Token describes a stored token. It never contains the secret nor its hash.
type Token struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Id identifies the token in ListTokens and RevokeToken. It is not the
	// secret and cannot be used to authenticate.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Label is a human-readable name chosen at creation.
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	// Scopes are the permissions of the token. Never empty.
	Scopes []Scope `protobuf:"varint,3,rep,packed,name=scopes,proto3,enum=ermite.Scope" json:"scopes,omitempty"`
	// Repos restricts the token to these repository names. Empty means every
	// repository.
	Repos []string `protobuf:"bytes,4,rep,name=repos,proto3" json:"repos,omitempty"`
	// ExpiresAt is when the token stops working. Unset means it never expires.
	ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	// CreatedAt is when the token was created.
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// LastUsedAt is when the token last authenticated a request. Unset if never
	// used. It may lag behind the real time by a short delay.
	LastUsedAt *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=last_used_at,json=lastUsedAt,proto3" json:"last_used_at,omitempty"`
	// BranchPrefixes limits the branches the token may write. Each prefix ends
	// with "/" (for example "agent/claude/"). Empty means every branch. A limited
	// token can push, force-push and delete only branches under its prefixes; it
	// cannot push tags or other refs, create repositories, or merge into or
	// delete a branch outside its prefixes.
	BranchPrefixes []string `protobuf:"bytes,8,rep,name=branch_prefixes,json=branchPrefixes,proto3" json:"branch_prefixes,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *Token) Reset() {
	*x = Token{}
	mi := &file_ermite_token_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Token) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Token) ProtoMessage() {}

func (x *Token) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Token.ProtoReflect.Descriptor instead.
func (*Token) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{0}
}

func (x *Token) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *Token) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

func (x *Token) GetScopes() []Scope {
	if x != nil {
		return x.Scopes
	}
	return nil
}

func (x *Token) GetRepos() []string {
	if x != nil {
		return x.Repos
	}
	return nil
}

func (x *Token) GetExpiresAt() *timestamppb.Timestamp {
	if x != nil {
		return x.ExpiresAt
	}
	return nil
}

func (x *Token) GetCreatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.CreatedAt
	}
	return nil
}

func (x *Token) GetLastUsedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.LastUsedAt
	}
	return nil
}

func (x *Token) GetBranchPrefixes() []string {
	if x != nil {
		return x.BranchPrefixes
	}
	return nil
}

// CreateTokenRequest describes the token to create.
type CreateTokenRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Label is a human-readable name, for example "laptop". Not required to be
	// unique.
	Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	// Scopes are the permissions to grant. At least one is required.
	Scopes []Scope `protobuf:"varint,2,rep,packed,name=scopes,proto3,enum=ermite.Scope" json:"scopes,omitempty"`
	// Repos restricts the token to these repository names. Empty means every
	// repository.
	Repos []string `protobuf:"bytes,3,rep,name=repos,proto3" json:"repos,omitempty"`
	// ExpiresAt is when the token stops working. Unset means no expiry. It must
	// be in the future.
	ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	// BranchPrefixes limits the branches the token may write, for example
	// "agent/claude/". Each prefix must end with "/" and be a valid branch name
	// once the "/" is removed; at most 8 are allowed. Empty means every branch;
	// a limited token cannot push tags or create repositories. A token that has
	// prefixes can only create tokens whose prefixes each lie within its own.
	// Fails with invalid_argument when a prefix is malformed.
	BranchPrefixes []string `protobuf:"bytes,5,rep,name=branch_prefixes,json=branchPrefixes,proto3" json:"branch_prefixes,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *CreateTokenRequest) Reset() {
	*x = CreateTokenRequest{}
	mi := &file_ermite_token_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CreateTokenRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CreateTokenRequest) ProtoMessage() {}

func (x *CreateTokenRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateTokenRequest.ProtoReflect.Descriptor instead.
func (*CreateTokenRequest) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{1}
}

func (x *CreateTokenRequest) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

func (x *CreateTokenRequest) GetScopes() []Scope {
	if x != nil {
		return x.Scopes
	}
	return nil
}

func (x *CreateTokenRequest) GetRepos() []string {
	if x != nil {
		return x.Repos
	}
	return nil
}

func (x *CreateTokenRequest) GetExpiresAt() *timestamppb.Timestamp {
	if x != nil {
		return x.ExpiresAt
	}
	return nil
}

func (x *CreateTokenRequest) GetBranchPrefixes() []string {
	if x != nil {
		return x.BranchPrefixes
	}
	return nil
}

// CreateTokenResponse holds the new token and its secret.
type CreateTokenResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Token describes the created token.
	Token *Token `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	// Secret is the bearer secret to present as "Authorization: Bearer <secret>".
	// It is returned once and never stored in clear text by the server.
	Secret        string `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CreateTokenResponse) Reset() {
	*x = CreateTokenResponse{}
	mi := &file_ermite_token_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CreateTokenResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CreateTokenResponse) ProtoMessage() {}

func (x *CreateTokenResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CreateTokenResponse.ProtoReflect.Descriptor instead.
func (*CreateTokenResponse) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{2}
}

func (x *CreateTokenResponse) GetToken() *Token {
	if x != nil {
		return x.Token
	}
	return nil
}

func (x *CreateTokenResponse) GetSecret() string {
	if x != nil {
		return x.Secret
	}
	return ""
}

// ListTokensRequest selects a page of tokens.
type ListTokensRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// PageSize is the maximum number of tokens to return. 0 means the server
	// default; values above the server maximum are lowered to it.
	PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// PageToken is the next_page_token of a previous response. Empty for the
	// first page.
	PageToken     string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListTokensRequest) Reset() {
	*x = ListTokensRequest{}
	mi := &file_ermite_token_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListTokensRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListTokensRequest) ProtoMessage() {}

func (x *ListTokensRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListTokensRequest.ProtoReflect.Descriptor instead.
func (*ListTokensRequest) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{3}
}

func (x *ListTokensRequest) GetPageSize() int32 {
	if x != nil {
		return x.PageSize
	}
	return 0
}

func (x *ListTokensRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

// ListTokensResponse is one page of tokens.
type ListTokensResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Tokens are the tokens of this page, newest first.
	Tokens []*Token `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"`
	// NextPageToken is passed as page_token to get the next page. Empty when
	// there is no next page.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListTokensResponse) Reset() {
	*x = ListTokensResponse{}
	mi := &file_ermite_token_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListTokensResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListTokensResponse) ProtoMessage() {}

func (x *ListTokensResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListTokensResponse.ProtoReflect.Descriptor instead.
func (*ListTokensResponse) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{4}
}

func (x *ListTokensResponse) GetTokens() []*Token {
	if x != nil {
		return x.Tokens
	}
	return nil
}

func (x *ListTokensResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

// RevokeTokenRequest names the token to revoke.
type RevokeTokenRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Id is the Token.id to revoke.
	Id            string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RevokeTokenRequest) Reset() {
	*x = RevokeTokenRequest{}
	mi := &file_ermite_token_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RevokeTokenRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RevokeTokenRequest) ProtoMessage() {}

func (x *RevokeTokenRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RevokeTokenRequest.ProtoReflect.Descriptor instead.
func (*RevokeTokenRequest) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{5}
}

func (x *RevokeTokenRequest) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

// RevokeTokenResponse is empty.
type RevokeTokenResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RevokeTokenResponse) Reset() {
	*x = RevokeTokenResponse{}
	mi := &file_ermite_token_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RevokeTokenResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RevokeTokenResponse) ProtoMessage() {}

func (x *RevokeTokenResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_token_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RevokeTokenResponse.ProtoReflect.Descriptor instead.
func (*RevokeTokenResponse) Descriptor() ([]byte, []int) {
	return file_ermite_token_proto_rawDescGZIP(), []int{6}
}

var File_ermite_token_proto protoreflect.FileDescriptor

const file_ermite_token_proto_rawDesc = "" +
	"\n" +
	"\x12ermite/token.proto\x12\x06ermite\x1a\x1fgoogle/protobuf/timestamp.proto\"\xc7\x02\n" +
	"\x05Token\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
	"\x05label\x18\x02 \x01(\tR\x05label\x12%\n" +
	"\x06scopes\x18\x03 \x03(\x0e2\r.ermite.ScopeR\x06scopes\x12\x14\n" +
	"\x05repos\x18\x04 \x03(\tR\x05repos\x129\n" +
	"\n" +
	"expires_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\texpiresAt\x129\n" +
	"\n" +
	"created_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x12<\n" +
	"\flast_used_at\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\n" +
	"lastUsedAt\x12'\n" +
	"\x0fbranch_prefixes\x18\b \x03(\tR\x0ebranchPrefixes\"\xcb\x01\n" +
	"\x12CreateTokenRequest\x12\x14\n" +
	"\x05label\x18\x01 \x01(\tR\x05label\x12%\n" +
	"\x06scopes\x18\x02 \x03(\x0e2\r.ermite.ScopeR\x06scopes\x12\x14\n" +
	"\x05repos\x18\x03 \x03(\tR\x05repos\x129\n" +
	"\n" +
	"expires_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\texpiresAt\x12'\n" +
	"\x0fbranch_prefixes\x18\x05 \x03(\tR\x0ebranchPrefixes\"R\n" +
	"\x13CreateTokenResponse\x12#\n" +
	"\x05token\x18\x01 \x01(\v2\r.ermite.TokenR\x05token\x12\x16\n" +
	"\x06secret\x18\x02 \x01(\tR\x06secret\"O\n" +
	"\x11ListTokensRequest\x12\x1b\n" +
	"\tpage_size\x18\x01 \x01(\x05R\bpageSize\x12\x1d\n" +
	"\n" +
	"page_token\x18\x02 \x01(\tR\tpageToken\"c\n" +
	"\x12ListTokensResponse\x12%\n" +
	"\x06tokens\x18\x01 \x03(\v2\r.ermite.TokenR\x06tokens\x12&\n" +
	"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"$\n" +
	"\x12RevokeTokenRequest\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"\x15\n" +
	"\x13RevokeTokenResponse*\xe6\x01\n" +
	"\x05Scope\x12\x15\n" +
	"\x11SCOPE_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fSCOPE_REPO_READ\x10\x01\x12\x14\n" +
	"\x10SCOPE_REPO_WRITE\x10\x02\x12\x14\n" +
	"\x10SCOPE_REPO_ADMIN\x10\x03\x12\x12\n" +
	"\x0eSCOPE_MR_WRITE\x10\x04\x12\x12\n" +
	"\x0eSCOPE_MR_MERGE\x10\x05\x12\x12\n" +
	"\x0eSCOPE_CI_WRITE\x10\x06\x12\x17\n" +
	"\x13SCOPE_SECRETS_WRITE\x10\a\x12\x19\n" +
	"\x15SCOPE_RUNNER_REGISTER\x10\b\x12\x15\n" +
	"\x11SCOPE_TOKEN_ADMIN\x10\t2\xe3\x01\n" +
	"\fTokenService\x12F\n" +
	"\vCreateToken\x12\x1a.ermite.CreateTokenRequest\x1a\x1b.ermite.CreateTokenResponse\x12C\n" +
	"\n" +
	"ListTokens\x12\x19.ermite.ListTokensRequest\x1a\x1a.ermite.ListTokensResponse\x12F\n" +
	"\vRevokeToken\x12\x1a.ermite.RevokeTokenRequest\x1a\x1b.ermite.RevokeTokenResponseBq\n" +
	"\n" +
	"com.ermiteB\n" +
	"TokenProtoP\x01Z\x1fbnema.dev/ermite-api/gen/ermite\xa2\x02\x03EXX\xaa\x02\x06Ermite\xca\x02\x06Ermite\xe2\x02\x12Ermite\\GPBMetadata\xea\x02\x06Ermiteb\x06proto3"

var (
	file_ermite_token_proto_rawDescOnce sync.Once
	file_ermite_token_proto_rawDescData []byte
)

func file_ermite_token_proto_rawDescGZIP() []byte {
	file_ermite_token_proto_rawDescOnce.Do(func() {
		file_ermite_token_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ermite_token_proto_rawDesc), len(file_ermite_token_proto_rawDesc)))
	})
	return file_ermite_token_proto_rawDescData
}

var file_ermite_token_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_ermite_token_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_ermite_token_proto_goTypes = []any{
	(Scope)(0),                    // 0: ermite.Scope
	(*Token)(nil),                 // 1: ermite.Token
	(*CreateTokenRequest)(nil),    // 2: ermite.CreateTokenRequest
	(*CreateTokenResponse)(nil),   // 3: ermite.CreateTokenResponse
	(*ListTokensRequest)(nil),     // 4: ermite.ListTokensRequest
	(*ListTokensResponse)(nil),    // 5: ermite.ListTokensResponse
	(*RevokeTokenRequest)(nil),    // 6: ermite.RevokeTokenRequest
	(*RevokeTokenResponse)(nil),   // 7: ermite.RevokeTokenResponse
	(*timestamppb.Timestamp)(nil), // 8: google.protobuf.Timestamp
}
var file_ermite_token_proto_depIdxs = []int32{
	0,  // 0: ermite.Token.scopes:type_name -> ermite.Scope
	8,  // 1: ermite.Token.expires_at:type_name -> google.protobuf.Timestamp
	8,  // 2: ermite.Token.created_at:type_name -> google.protobuf.Timestamp
	8,  // 3: ermite.Token.last_used_at:type_name -> google.protobuf.Timestamp
	0,  // 4: ermite.CreateTokenRequest.scopes:type_name -> ermite.Scope
	8,  // 5: ermite.CreateTokenRequest.expires_at:type_name -> google.protobuf.Timestamp
	1,  // 6: ermite.CreateTokenResponse.token:type_name -> ermite.Token
	1,  // 7: ermite.ListTokensResponse.tokens:type_name -> ermite.Token
	2,  // 8: ermite.TokenService.CreateToken:input_type -> ermite.CreateTokenRequest
	4,  // 9: ermite.TokenService.ListTokens:input_type -> ermite.ListTokensRequest
	6,  // 10: ermite.TokenService.RevokeToken:input_type -> ermite.RevokeTokenRequest
	3,  // 11: ermite.TokenService.CreateToken:output_type -> ermite.CreateTokenResponse
	5,  // 12: ermite.TokenService.ListTokens:output_type -> ermite.ListTokensResponse
	7,  // 13: ermite.TokenService.RevokeToken:output_type -> ermite.RevokeTokenResponse
	11, // [11:14] is the sub-list for method output_type
	8,  // [8:11] is the sub-list for method input_type
	8,  // [8:8] is the sub-list for extension type_name
	8,  // [8:8] is the sub-list for extension extendee
	0,  // [0:8] is the sub-list for field type_name
}

func init() { file_ermite_token_proto_init() }
func file_ermite_token_proto_init() {
	if File_ermite_token_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ermite_token_proto_rawDesc), len(file_ermite_token_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   7,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_ermite_token_proto_goTypes,
		DependencyIndexes: file_ermite_token_proto_depIdxs,
		EnumInfos:         file_ermite_token_proto_enumTypes,
		MessageInfos:      file_ermite_token_proto_msgTypes,
	}.Build()
	File_ermite_token_proto = out.File
	file_ermite_token_proto_goTypes = nil
	file_ermite_token_proto_depIdxs = nil
}