// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.8
// 	protoc        (unknown)
// source: authzed/api/materialize/v0/watchpermissionsets.proto

package v0

import (
	v1 "github.com/authzed/authzed-go/proto/authzed/api/v1"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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)
)

type PermissionSetChange_SetOperation int32

const (
	PermissionSetChange_SET_OPERATION_UNSPECIFIED PermissionSetChange_SetOperation = 0
	PermissionSetChange_SET_OPERATION_ADDED       PermissionSetChange_SetOperation = 1
	PermissionSetChange_SET_OPERATION_REMOVED     PermissionSetChange_SetOperation = 2
)

// Enum value maps for PermissionSetChange_SetOperation.
var (
	PermissionSetChange_SetOperation_name = map[int32]string{
		0: "SET_OPERATION_UNSPECIFIED",
		1: "SET_OPERATION_ADDED",
		2: "SET_OPERATION_REMOVED",
	}
	PermissionSetChange_SetOperation_value = map[string]int32{
		"SET_OPERATION_UNSPECIFIED": 0,
		"SET_OPERATION_ADDED":       1,
		"SET_OPERATION_REMOVED":     2,
	}
)

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

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

func (PermissionSetChange_SetOperation) Descriptor() protoreflect.EnumDescriptor {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes[0].Descriptor()
}

func (PermissionSetChange_SetOperation) Type() protoreflect.EnumType {
	return &file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes[0]
}

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

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

type WatchPermissionSetsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// optional_starting_after is used to specify the SpiceDB revision to start watching from.
	// If not specified, the watch will start from the current SpiceDB revision time of the request ("head revision").
	OptionalStartingAfter *v1.ZedToken `protobuf:"bytes,1,opt,name=optional_starting_after,json=optionalStartingAfter,proto3" json:"optional_starting_after,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

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

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

func (*WatchPermissionSetsRequest) ProtoMessage() {}

func (x *WatchPermissionSetsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 WatchPermissionSetsRequest.ProtoReflect.Descriptor instead.
func (*WatchPermissionSetsRequest) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{0}
}

func (x *WatchPermissionSetsRequest) GetOptionalStartingAfter() *v1.ZedToken {
	if x != nil {
		return x.OptionalStartingAfter
	}
	return nil
}

type WatchPermissionSetsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*WatchPermissionSetsResponse_Change
	//	*WatchPermissionSetsResponse_CompletedRevision
	//	*WatchPermissionSetsResponse_LookupPermissionSetsRequired
	//	*WatchPermissionSetsResponse_BreakingSchemaChange
	Response      isWatchPermissionSetsResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WatchPermissionSetsResponse) ProtoMessage() {}

func (x *WatchPermissionSetsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 WatchPermissionSetsResponse.ProtoReflect.Descriptor instead.
func (*WatchPermissionSetsResponse) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{1}
}

func (x *WatchPermissionSetsResponse) GetResponse() isWatchPermissionSetsResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *WatchPermissionSetsResponse) GetChange() *PermissionSetChange {
	if x != nil {
		if x, ok := x.Response.(*WatchPermissionSetsResponse_Change); ok {
			return x.Change
		}
	}
	return nil
}

func (x *WatchPermissionSetsResponse) GetCompletedRevision() *v1.ZedToken {
	if x != nil {
		if x, ok := x.Response.(*WatchPermissionSetsResponse_CompletedRevision); ok {
			return x.CompletedRevision
		}
	}
	return nil
}

func (x *WatchPermissionSetsResponse) GetLookupPermissionSetsRequired() *LookupPermissionSetsRequired {
	if x != nil {
		if x, ok := x.Response.(*WatchPermissionSetsResponse_LookupPermissionSetsRequired); ok {
			return x.LookupPermissionSetsRequired
		}
	}
	return nil
}

func (x *WatchPermissionSetsResponse) GetBreakingSchemaChange() *BreakingSchemaChange {
	if x != nil {
		if x, ok := x.Response.(*WatchPermissionSetsResponse_BreakingSchemaChange); ok {
			return x.BreakingSchemaChange
		}
	}
	return nil
}

type isWatchPermissionSetsResponse_Response interface {
	isWatchPermissionSetsResponse_Response()
}

type WatchPermissionSetsResponse_Change struct {
	// change is the permission set delta that has occurred as result of a mutation in origin SpiceDB.
	// The consumer should apply this change to the current state of the permission sets in their target system.
	// Once an event arrives with completed_revision instead, the consumer shall consider the set of
	// changes originating from that revision completed.
	//
	// The consumer should keep track of the revision in order to resume streaming in the event of consumer restarts.
	Change *PermissionSetChange `protobuf:"bytes,1,opt,name=change,proto3,oneof"`
}

type WatchPermissionSetsResponse_CompletedRevision struct {
	// completed_revision is the revision token that indicates the completion of a set of changes. It may also be
	// received without accompanying set of changes, indicating that a mutation in the origin SpiceDB cluster did
	// not yield any effective changes in the permission sets
	CompletedRevision *v1.ZedToken `protobuf:"bytes,2,opt,name=completed_revision,json=completedRevision,proto3,oneof"`
}

type WatchPermissionSetsResponse_LookupPermissionSetsRequired struct {
	// lookup_permission_sets_required is a signal that the consumer should perform a LookupPermissionSets call because
	// the permission set snapshot needs to be rebuilt from scratch. This typically happens when the origin SpiceDB
	// cluster has seen its schema changed.
	LookupPermissionSetsRequired *LookupPermissionSetsRequired `protobuf:"bytes,3,opt,name=lookup_permission_sets_required,json=lookupPermissionSetsRequired,proto3,oneof"`
}

type WatchPermissionSetsResponse_BreakingSchemaChange struct {
	// breaking_schema_change is a signal that a breaking schema change has been written to the origin SpiceDB cluster,
	// and that the consumer should expect delays in the ingestion of new changes,
	// because the permission set snapshot needs to be rebuilt from scratch. Once the snapshot is ready, the consumer
	// will receive a LookupPermissionSetsRequired event.
	BreakingSchemaChange *BreakingSchemaChange `protobuf:"bytes,4,opt,name=breaking_schema_change,json=breakingSchemaChange,proto3,oneof"`
}

func (*WatchPermissionSetsResponse_Change) isWatchPermissionSetsResponse_Response() {}

func (*WatchPermissionSetsResponse_CompletedRevision) isWatchPermissionSetsResponse_Response() {}

func (*WatchPermissionSetsResponse_LookupPermissionSetsRequired) isWatchPermissionSetsResponse_Response() {
}

func (*WatchPermissionSetsResponse_BreakingSchemaChange) isWatchPermissionSetsResponse_Response() {}

type Cursor struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// limit is the number of permission sets to stream over a single LookupPermissionSets call that was requested.
	Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// token is the snapshot revision at which the cursor was computed.
	Token *v1.ZedToken `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`
	// starting_index is an offset of the permission set represented by this cursor
	StartingIndex uint32 `protobuf:"varint,5,opt,name=starting_index,json=startingIndex,proto3" json:"starting_index,omitempty"`
	// completed_members is a boolean flag that indicates that the cursor has reached the end of the permission sets
	CompletedMembers bool `protobuf:"varint,6,opt,name=completed_members,json=completedMembers,proto3" json:"completed_members,omitempty"`
	// starting_key is a string cursor used by some backends to resume the stream from a specific point.
	StartingKey string `protobuf:"bytes,7,opt,name=starting_key,json=startingKey,proto3" json:"starting_key,omitempty"`
	// cursor is a string-encoded internal materialize cursor.
	Cursor        string `protobuf:"bytes,8,opt,name=cursor,proto3" json:"cursor,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Cursor) ProtoMessage() {}

func (x *Cursor) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 Cursor.ProtoReflect.Descriptor instead.
func (*Cursor) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{2}
}

func (x *Cursor) GetLimit() uint32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

func (x *Cursor) GetToken() *v1.ZedToken {
	if x != nil {
		return x.Token
	}
	return nil
}

func (x *Cursor) GetStartingIndex() uint32 {
	if x != nil {
		return x.StartingIndex
	}
	return 0
}

func (x *Cursor) GetCompletedMembers() bool {
	if x != nil {
		return x.CompletedMembers
	}
	return false
}

func (x *Cursor) GetStartingKey() string {
	if x != nil {
		return x.StartingKey
	}
	return ""
}

func (x *Cursor) GetCursor() string {
	if x != nil {
		return x.Cursor
	}
	return ""
}

type LookupPermissionSetsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// limit is the number of permission sets to stream over a single LookupPermissionSets. Once the limit is reached,
	// the server will close the stream. If more permission sets are available, the consume should open a new stream
	// providing optional_starting_after_cursor, using the cursor from the last response.
	Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	// optional_at_revision specifies the client is requesting to lookup PermissionSets at a specific revision. It's
	// optional, and if not provided, PermissionSets will be looked up at the current revision. The cursor always
	// takes precedence in defining the revision when present.
	OptionalAtRevision *v1.ZedToken `protobuf:"bytes,2,opt,name=optional_at_revision,json=optionalAtRevision,proto3" json:"optional_at_revision,omitempty"`
	// optional_starting_after_cursor is used to specify the offset to start streaming permission sets from.
	OptionalStartingAfterCursor *Cursor `protobuf:"bytes,4,opt,name=optional_starting_after_cursor,json=optionalStartingAfterCursor,proto3" json:"optional_starting_after_cursor,omitempty"`
	unknownFields               protoimpl.UnknownFields
	sizeCache                   protoimpl.SizeCache
}

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

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

func (*LookupPermissionSetsRequest) ProtoMessage() {}

func (x *LookupPermissionSetsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 LookupPermissionSetsRequest.ProtoReflect.Descriptor instead.
func (*LookupPermissionSetsRequest) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{3}
}

func (x *LookupPermissionSetsRequest) GetLimit() uint32 {
	if x != nil {
		return x.Limit
	}
	return 0
}

func (x *LookupPermissionSetsRequest) GetOptionalAtRevision() *v1.ZedToken {
	if x != nil {
		return x.OptionalAtRevision
	}
	return nil
}

func (x *LookupPermissionSetsRequest) GetOptionalStartingAfterCursor() *Cursor {
	if x != nil {
		return x.OptionalStartingAfterCursor
	}
	return nil
}

type LookupPermissionSetsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// change represents the permission set delta necessary to transition an uninitialized target system to
	// a specific snapshot revision. In practice it's not different from the WatchPermissionSetsResponse.change, except
	// all changes will be of time SET_OPERATION_ADDED because it's assumed there is no known previous state.
	//
	// Applying the deltas to a previously initialized target system would yield incorrect results.
	Change *PermissionSetChange `protobuf:"bytes,1,opt,name=change,proto3" json:"change,omitempty"`
	// cursor points to a specific permission set in a revision.
	// The consumer should keep track of the cursor in order to resume streaming in the event of consumer restarts. This
	// is particularly important in backfill scenarios that may take hours or event days to complete.
	Cursor        *Cursor `protobuf:"bytes,2,opt,name=cursor,proto3" json:"cursor,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LookupPermissionSetsResponse) ProtoMessage() {}

func (x *LookupPermissionSetsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 LookupPermissionSetsResponse.ProtoReflect.Descriptor instead.
func (*LookupPermissionSetsResponse) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{4}
}

func (x *LookupPermissionSetsResponse) GetChange() *PermissionSetChange {
	if x != nil {
		return x.Change
	}
	return nil
}

func (x *LookupPermissionSetsResponse) GetCursor() *Cursor {
	if x != nil {
		return x.Cursor
	}
	return nil
}

type PermissionSetChange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// revision represents the revision at which the permission set change occurred.
	AtRevision *v1.ZedToken `protobuf:"bytes,1,opt,name=at_revision,json=atRevision,proto3" json:"at_revision,omitempty"`
	// operation represents the type of set operation that took place as part of the change
	Operation PermissionSetChange_SetOperation `protobuf:"varint,2,opt,name=operation,proto3,enum=authzed.api.materialize.v0.PermissionSetChange_SetOperation" json:"operation,omitempty"`
	// parent_set represents the permission set parent of either another set or a member
	ParentSet *SetReference `protobuf:"bytes,3,opt,name=parent_set,json=parentSet,proto3" json:"parent_set,omitempty"`
	// Types that are valid to be assigned to Child:
	//
	//	*PermissionSetChange_ChildSet
	//	*PermissionSetChange_ChildMember
	Child         isPermissionSetChange_Child `protobuf_oneof:"child"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PermissionSetChange) ProtoMessage() {}

func (x *PermissionSetChange) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 PermissionSetChange.ProtoReflect.Descriptor instead.
func (*PermissionSetChange) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{5}
}

func (x *PermissionSetChange) GetAtRevision() *v1.ZedToken {
	if x != nil {
		return x.AtRevision
	}
	return nil
}

func (x *PermissionSetChange) GetOperation() PermissionSetChange_SetOperation {
	if x != nil {
		return x.Operation
	}
	return PermissionSetChange_SET_OPERATION_UNSPECIFIED
}

func (x *PermissionSetChange) GetParentSet() *SetReference {
	if x != nil {
		return x.ParentSet
	}
	return nil
}

func (x *PermissionSetChange) GetChild() isPermissionSetChange_Child {
	if x != nil {
		return x.Child
	}
	return nil
}

func (x *PermissionSetChange) GetChildSet() *SetReference {
	if x != nil {
		if x, ok := x.Child.(*PermissionSetChange_ChildSet); ok {
			return x.ChildSet
		}
	}
	return nil
}

func (x *PermissionSetChange) GetChildMember() *MemberReference {
	if x != nil {
		if x, ok := x.Child.(*PermissionSetChange_ChildMember); ok {
			return x.ChildMember
		}
	}
	return nil
}

type isPermissionSetChange_Child interface {
	isPermissionSetChange_Child()
}

type PermissionSetChange_ChildSet struct {
	// child_set represents the scenario where another set is considered member of the parent set
	ChildSet *SetReference `protobuf:"bytes,4,opt,name=child_set,json=childSet,proto3,oneof"`
}

type PermissionSetChange_ChildMember struct {
	// child_member represents the scenario where an specific object is considered member of the parent set
	ChildMember *MemberReference `protobuf:"bytes,5,opt,name=child_member,json=childMember,proto3,oneof"`
}

func (*PermissionSetChange_ChildSet) isPermissionSetChange_Child() {}

func (*PermissionSetChange_ChildMember) isPermissionSetChange_Child() {}

type SetReference struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// object_type is the type of object in a permission set
	ObjectType string `protobuf:"bytes,1,opt,name=object_type,json=objectType,proto3" json:"object_type,omitempty"`
	// object_id is the ID of a permission set
	ObjectId string `protobuf:"bytes,2,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
	// permission_or_relation is the permission or relation referenced by this permission set
	PermissionOrRelation string `protobuf:"bytes,3,opt,name=permission_or_relation,json=permissionOrRelation,proto3" json:"permission_or_relation,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*SetReference) ProtoMessage() {}

func (x *SetReference) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_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 SetReference.ProtoReflect.Descriptor instead.
func (*SetReference) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{6}
}

func (x *SetReference) GetObjectType() string {
	if x != nil {
		return x.ObjectType
	}
	return ""
}

func (x *SetReference) GetObjectId() string {
	if x != nil {
		return x.ObjectId
	}
	return ""
}

func (x *SetReference) GetPermissionOrRelation() string {
	if x != nil {
		return x.PermissionOrRelation
	}
	return ""
}

type MemberReference struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// object_type is the type of object of a permission set member
	ObjectType string `protobuf:"bytes,1,opt,name=object_type,json=objectType,proto3" json:"object_type,omitempty"`
	// object_id is the ID of a permission set member
	ObjectId string `protobuf:"bytes,2,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
	// optional_permission_or_relation is the permission or relation referenced by this permission set member
	OptionalPermissionOrRelation string `protobuf:"bytes,3,opt,name=optional_permission_or_relation,json=optionalPermissionOrRelation,proto3" json:"optional_permission_or_relation,omitempty"`
	unknownFields                protoimpl.UnknownFields
	sizeCache                    protoimpl.SizeCache
}

func (x *MemberReference) Reset() {
	*x = MemberReference{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MemberReference) ProtoMessage() {}

func (x *MemberReference) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[7]
	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 MemberReference.ProtoReflect.Descriptor instead.
func (*MemberReference) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{7}
}

func (x *MemberReference) GetObjectType() string {
	if x != nil {
		return x.ObjectType
	}
	return ""
}

func (x *MemberReference) GetObjectId() string {
	if x != nil {
		return x.ObjectId
	}
	return ""
}

func (x *MemberReference) GetOptionalPermissionOrRelation() string {
	if x != nil {
		return x.OptionalPermissionOrRelation
	}
	return ""
}

// LookupPermissionSetsRequired is a signal that the consumer should perform a LookupPermissionSets call because
// the permission set snapshot needs to be rebuilt from scratch. This typically happens when the origin SpiceDB
// cluster has seen its schema changed, see BreakingSchemaChange event.
type LookupPermissionSetsRequired struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// required_lookup_at is the snapshot revision at which the permission set needs to be rebuilt to.
	RequiredLookupAt *v1.ZedToken `protobuf:"bytes,1,opt,name=required_lookup_at,json=requiredLookupAt,proto3" json:"required_lookup_at,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *LookupPermissionSetsRequired) Reset() {
	*x = LookupPermissionSetsRequired{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LookupPermissionSetsRequired) ProtoMessage() {}

func (x *LookupPermissionSetsRequired) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[8]
	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 LookupPermissionSetsRequired.ProtoReflect.Descriptor instead.
func (*LookupPermissionSetsRequired) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{8}
}

func (x *LookupPermissionSetsRequired) GetRequiredLookupAt() *v1.ZedToken {
	if x != nil {
		return x.RequiredLookupAt
	}
	return nil
}

// BreakingSchemaChange is used to signal a breaking schema change has happened, and that the consumer should
// expect delays in the ingestion of new changes, because the permission set snapshot needs to be rebuilt from scratch.
// Once the snapshot is ready, the consumer will receive a LookupPermissionSetsRequired event.
type BreakingSchemaChange struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// change_at is the revision at which a breaking schema event has happened.
	ChangeAt      *v1.ZedToken `protobuf:"bytes,1,opt,name=change_at,json=changeAt,proto3" json:"change_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BreakingSchemaChange) Reset() {
	*x = BreakingSchemaChange{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*BreakingSchemaChange) ProtoMessage() {}

func (x *BreakingSchemaChange) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[9]
	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 BreakingSchemaChange.ProtoReflect.Descriptor instead.
func (*BreakingSchemaChange) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{9}
}

func (x *BreakingSchemaChange) GetChangeAt() *v1.ZedToken {
	if x != nil {
		return x.ChangeAt
	}
	return nil
}

type DownloadPermissionSetsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// optional_at_revision is a specific revision to download; for now this will
	// just validate that it matches the backing store if provided.
	OptionalAtRevision *v1.ZedToken `protobuf:"bytes,1,opt,name=optional_at_revision,json=optionalAtRevision,proto3" json:"optional_at_revision,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *DownloadPermissionSetsRequest) Reset() {
	*x = DownloadPermissionSetsRequest{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DownloadPermissionSetsRequest) ProtoMessage() {}

func (x *DownloadPermissionSetsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[10]
	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 DownloadPermissionSetsRequest.ProtoReflect.Descriptor instead.
func (*DownloadPermissionSetsRequest) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{10}
}

func (x *DownloadPermissionSetsRequest) GetOptionalAtRevision() *v1.ZedToken {
	if x != nil {
		return x.OptionalAtRevision
	}
	return nil
}

type File struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the filename of the downloadable file
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// url is the download URL for the file (typically a signed S3 URL)
	Url           string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *File) Reset() {
	*x = File{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*File) ProtoMessage() {}

func (x *File) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[11]
	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 File.ProtoReflect.Descriptor instead.
func (*File) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{11}
}

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

func (x *File) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

type DownloadPermissionSetsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// files contains the list of downloadable files with their URLs
	Files         []*File `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DownloadPermissionSetsResponse) Reset() {
	*x = DownloadPermissionSetsResponse{}
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DownloadPermissionSetsResponse) ProtoMessage() {}

func (x *DownloadPermissionSetsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[12]
	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 DownloadPermissionSetsResponse.ProtoReflect.Descriptor instead.
func (*DownloadPermissionSetsResponse) Descriptor() ([]byte, []int) {
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP(), []int{12}
}

func (x *DownloadPermissionSetsResponse) GetFiles() []*File {
	if x != nil {
		return x.Files
	}
	return nil
}

var File_authzed_api_materialize_v0_watchpermissionsets_proto protoreflect.FileDescriptor

const file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDesc = "" +
	"\n" +
	"4authzed/api/materialize/v0/watchpermissionsets.proto\x12\x1aauthzed.api.materialize.v0\x1a\x19authzed/api/v1/core.proto\"n\n" +
	"\x1aWatchPermissionSetsRequest\x12P\n" +
	"\x17optional_starting_after\x18\x01 \x01(\v2\x18.authzed.api.v1.ZedTokenR\x15optionalStartingAfter\"\xad\x03\n" +
	"\x1bWatchPermissionSetsResponse\x12I\n" +
	"\x06change\x18\x01 \x01(\v2/.authzed.api.materialize.v0.PermissionSetChangeH\x00R\x06change\x12I\n" +
	"\x12completed_revision\x18\x02 \x01(\v2\x18.authzed.api.v1.ZedTokenH\x00R\x11completedRevision\x12\x81\x01\n" +
	"\x1flookup_permission_sets_required\x18\x03 \x01(\v28.authzed.api.materialize.v0.LookupPermissionSetsRequiredH\x00R\x1clookupPermissionSetsRequired\x12h\n" +
	"\x16breaking_schema_change\x18\x04 \x01(\v20.authzed.api.materialize.v0.BreakingSchemaChangeH\x00R\x14breakingSchemaChangeB\n" +
	"\n" +
	"\bresponse\"\xdd\x01\n" +
	"\x06Cursor\x12\x14\n" +
	"\x05limit\x18\x01 \x01(\rR\x05limit\x12.\n" +
	"\x05token\x18\x04 \x01(\v2\x18.authzed.api.v1.ZedTokenR\x05token\x12%\n" +
	"\x0estarting_index\x18\x05 \x01(\rR\rstartingIndex\x12+\n" +
	"\x11completed_members\x18\x06 \x01(\bR\x10completedMembers\x12!\n" +
	"\fstarting_key\x18\a \x01(\tR\vstartingKey\x12\x16\n" +
	"\x06cursor\x18\b \x01(\tR\x06cursor\"\xe8\x01\n" +
	"\x1bLookupPermissionSetsRequest\x12\x14\n" +
	"\x05limit\x18\x01 \x01(\rR\x05limit\x12J\n" +
	"\x14optional_at_revision\x18\x02 \x01(\v2\x18.authzed.api.v1.ZedTokenR\x12optionalAtRevision\x12g\n" +
	"\x1eoptional_starting_after_cursor\x18\x04 \x01(\v2\".authzed.api.materialize.v0.CursorR\x1boptionalStartingAfterCursor\"\xa3\x01\n" +
	"\x1cLookupPermissionSetsResponse\x12G\n" +
	"\x06change\x18\x01 \x01(\v2/.authzed.api.materialize.v0.PermissionSetChangeR\x06change\x12:\n" +
	"\x06cursor\x18\x02 \x01(\v2\".authzed.api.materialize.v0.CursorR\x06cursor\"\xfc\x03\n" +
	"\x13PermissionSetChange\x129\n" +
	"\vat_revision\x18\x01 \x01(\v2\x18.authzed.api.v1.ZedTokenR\n" +
	"atRevision\x12Z\n" +
	"\toperation\x18\x02 \x01(\x0e2<.authzed.api.materialize.v0.PermissionSetChange.SetOperationR\toperation\x12G\n" +
	"\n" +
	"parent_set\x18\x03 \x01(\v2(.authzed.api.materialize.v0.SetReferenceR\tparentSet\x12G\n" +
	"\tchild_set\x18\x04 \x01(\v2(.authzed.api.materialize.v0.SetReferenceH\x00R\bchildSet\x12P\n" +
	"\fchild_member\x18\x05 \x01(\v2+.authzed.api.materialize.v0.MemberReferenceH\x00R\vchildMember\"a\n" +
	"\fSetOperation\x12\x1d\n" +
	"\x19SET_OPERATION_UNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13SET_OPERATION_ADDED\x10\x01\x12\x19\n" +
	"\x15SET_OPERATION_REMOVED\x10\x02B\a\n" +
	"\x05child\"\x82\x01\n" +
	"\fSetReference\x12\x1f\n" +
	"\vobject_type\x18\x01 \x01(\tR\n" +
	"objectType\x12\x1b\n" +
	"\tobject_id\x18\x02 \x01(\tR\bobjectId\x124\n" +
	"\x16permission_or_relation\x18\x03 \x01(\tR\x14permissionOrRelation\"\x96\x01\n" +
	"\x0fMemberReference\x12\x1f\n" +
	"\vobject_type\x18\x01 \x01(\tR\n" +
	"objectType\x12\x1b\n" +
	"\tobject_id\x18\x02 \x01(\tR\bobjectId\x12E\n" +
	"\x1foptional_permission_or_relation\x18\x03 \x01(\tR\x1coptionalPermissionOrRelation\"f\n" +
	"\x1cLookupPermissionSetsRequired\x12F\n" +
	"\x12required_lookup_at\x18\x01 \x01(\v2\x18.authzed.api.v1.ZedTokenR\x10requiredLookupAt\"M\n" +
	"\x14BreakingSchemaChange\x125\n" +
	"\tchange_at\x18\x01 \x01(\v2\x18.authzed.api.v1.ZedTokenR\bchangeAt\"k\n" +
	"\x1dDownloadPermissionSetsRequest\x12J\n" +
	"\x14optional_at_revision\x18\x01 \x01(\v2\x18.authzed.api.v1.ZedTokenR\x12optionalAtRevision\",\n" +
	"\x04File\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\"X\n" +
	"\x1eDownloadPermissionSetsResponse\x126\n" +
	"\x05files\x18\x01 \x03(\v2 .authzed.api.materialize.v0.FileR\x05files2\xcd\x03\n" +
	"\x1aWatchPermissionSetsService\x12\x8a\x01\n" +
	"\x13WatchPermissionSets\x126.authzed.api.materialize.v0.WatchPermissionSetsRequest\x1a7.authzed.api.materialize.v0.WatchPermissionSetsResponse\"\x000\x01\x12\x8d\x01\n" +
	"\x14LookupPermissionSets\x127.authzed.api.materialize.v0.LookupPermissionSetsRequest\x1a8.authzed.api.materialize.v0.LookupPermissionSetsResponse\"\x000\x01\x12\x91\x01\n" +
	"\x16DownloadPermissionSets\x129.authzed.api.materialize.v0.DownloadPermissionSetsRequest\x1a:.authzed.api.materialize.v0.DownloadPermissionSetsResponse\"\x00Bb\n" +
	"\x1ecom.authzed.api.materialize.v0P\x01Z>github.com/authzed/authzed-go/proto/authzed/api/materialize/v0b\x06proto3"

var (
	file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescOnce sync.Once
	file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescData []byte
)

func file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescGZIP() []byte {
	file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescOnce.Do(func() {
		file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDesc), len(file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDesc)))
	})
	return file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDescData
}

var file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_authzed_api_materialize_v0_watchpermissionsets_proto_goTypes = []any{
	(PermissionSetChange_SetOperation)(0),  // 0: authzed.api.materialize.v0.PermissionSetChange.SetOperation
	(*WatchPermissionSetsRequest)(nil),     // 1: authzed.api.materialize.v0.WatchPermissionSetsRequest
	(*WatchPermissionSetsResponse)(nil),    // 2: authzed.api.materialize.v0.WatchPermissionSetsResponse
	(*Cursor)(nil),                         // 3: authzed.api.materialize.v0.Cursor
	(*LookupPermissionSetsRequest)(nil),    // 4: authzed.api.materialize.v0.LookupPermissionSetsRequest
	(*LookupPermissionSetsResponse)(nil),   // 5: authzed.api.materialize.v0.LookupPermissionSetsResponse
	(*PermissionSetChange)(nil),            // 6: authzed.api.materialize.v0.PermissionSetChange
	(*SetReference)(nil),                   // 7: authzed.api.materialize.v0.SetReference
	(*MemberReference)(nil),                // 8: authzed.api.materialize.v0.MemberReference
	(*LookupPermissionSetsRequired)(nil),   // 9: authzed.api.materialize.v0.LookupPermissionSetsRequired
	(*BreakingSchemaChange)(nil),           // 10: authzed.api.materialize.v0.BreakingSchemaChange
	(*DownloadPermissionSetsRequest)(nil),  // 11: authzed.api.materialize.v0.DownloadPermissionSetsRequest
	(*File)(nil),                           // 12: authzed.api.materialize.v0.File
	(*DownloadPermissionSetsResponse)(nil), // 13: authzed.api.materialize.v0.DownloadPermissionSetsResponse
	(*v1.ZedToken)(nil),                    // 14: authzed.api.v1.ZedToken
}
var file_authzed_api_materialize_v0_watchpermissionsets_proto_depIdxs = []int32{
	14, // 0: authzed.api.materialize.v0.WatchPermissionSetsRequest.optional_starting_after:type_name -> authzed.api.v1.ZedToken
	6,  // 1: authzed.api.materialize.v0.WatchPermissionSetsResponse.change:type_name -> authzed.api.materialize.v0.PermissionSetChange
	14, // 2: authzed.api.materialize.v0.WatchPermissionSetsResponse.completed_revision:type_name -> authzed.api.v1.ZedToken
	9,  // 3: authzed.api.materialize.v0.WatchPermissionSetsResponse.lookup_permission_sets_required:type_name -> authzed.api.materialize.v0.LookupPermissionSetsRequired
	10, // 4: authzed.api.materialize.v0.WatchPermissionSetsResponse.breaking_schema_change:type_name -> authzed.api.materialize.v0.BreakingSchemaChange
	14, // 5: authzed.api.materialize.v0.Cursor.token:type_name -> authzed.api.v1.ZedToken
	14, // 6: authzed.api.materialize.v0.LookupPermissionSetsRequest.optional_at_revision:type_name -> authzed.api.v1.ZedToken
	3,  // 7: authzed.api.materialize.v0.LookupPermissionSetsRequest.optional_starting_after_cursor:type_name -> authzed.api.materialize.v0.Cursor
	6,  // 8: authzed.api.materialize.v0.LookupPermissionSetsResponse.change:type_name -> authzed.api.materialize.v0.PermissionSetChange
	3,  // 9: authzed.api.materialize.v0.LookupPermissionSetsResponse.cursor:type_name -> authzed.api.materialize.v0.Cursor
	14, // 10: authzed.api.materialize.v0.PermissionSetChange.at_revision:type_name -> authzed.api.v1.ZedToken
	0,  // 11: authzed.api.materialize.v0.PermissionSetChange.operation:type_name -> authzed.api.materialize.v0.PermissionSetChange.SetOperation
	7,  // 12: authzed.api.materialize.v0.PermissionSetChange.parent_set:type_name -> authzed.api.materialize.v0.SetReference
	7,  // 13: authzed.api.materialize.v0.PermissionSetChange.child_set:type_name -> authzed.api.materialize.v0.SetReference
	8,  // 14: authzed.api.materialize.v0.PermissionSetChange.child_member:type_name -> authzed.api.materialize.v0.MemberReference
	14, // 15: authzed.api.materialize.v0.LookupPermissionSetsRequired.required_lookup_at:type_name -> authzed.api.v1.ZedToken
	14, // 16: authzed.api.materialize.v0.BreakingSchemaChange.change_at:type_name -> authzed.api.v1.ZedToken
	14, // 17: authzed.api.materialize.v0.DownloadPermissionSetsRequest.optional_at_revision:type_name -> authzed.api.v1.ZedToken
	12, // 18: authzed.api.materialize.v0.DownloadPermissionSetsResponse.files:type_name -> authzed.api.materialize.v0.File
	1,  // 19: authzed.api.materialize.v0.WatchPermissionSetsService.WatchPermissionSets:input_type -> authzed.api.materialize.v0.WatchPermissionSetsRequest
	4,  // 20: authzed.api.materialize.v0.WatchPermissionSetsService.LookupPermissionSets:input_type -> authzed.api.materialize.v0.LookupPermissionSetsRequest
	11, // 21: authzed.api.materialize.v0.WatchPermissionSetsService.DownloadPermissionSets:input_type -> authzed.api.materialize.v0.DownloadPermissionSetsRequest
	2,  // 22: authzed.api.materialize.v0.WatchPermissionSetsService.WatchPermissionSets:output_type -> authzed.api.materialize.v0.WatchPermissionSetsResponse
	5,  // 23: authzed.api.materialize.v0.WatchPermissionSetsService.LookupPermissionSets:output_type -> authzed.api.materialize.v0.LookupPermissionSetsResponse
	13, // 24: authzed.api.materialize.v0.WatchPermissionSetsService.DownloadPermissionSets:output_type -> authzed.api.materialize.v0.DownloadPermissionSetsResponse
	22, // [22:25] is the sub-list for method output_type
	19, // [19:22] is the sub-list for method input_type
	19, // [19:19] is the sub-list for extension type_name
	19, // [19:19] is the sub-list for extension extendee
	0,  // [0:19] is the sub-list for field type_name
}

func init() { file_authzed_api_materialize_v0_watchpermissionsets_proto_init() }
func file_authzed_api_materialize_v0_watchpermissionsets_proto_init() {
	if File_authzed_api_materialize_v0_watchpermissionsets_proto != nil {
		return
	}
	file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[1].OneofWrappers = []any{
		(*WatchPermissionSetsResponse_Change)(nil),
		(*WatchPermissionSetsResponse_CompletedRevision)(nil),
		(*WatchPermissionSetsResponse_LookupPermissionSetsRequired)(nil),
		(*WatchPermissionSetsResponse_BreakingSchemaChange)(nil),
	}
	file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes[5].OneofWrappers = []any{
		(*PermissionSetChange_ChildSet)(nil),
		(*PermissionSetChange_ChildMember)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDesc), len(file_authzed_api_materialize_v0_watchpermissionsets_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_authzed_api_materialize_v0_watchpermissionsets_proto_goTypes,
		DependencyIndexes: file_authzed_api_materialize_v0_watchpermissionsets_proto_depIdxs,
		EnumInfos:         file_authzed_api_materialize_v0_watchpermissionsets_proto_enumTypes,
		MessageInfos:      file_authzed_api_materialize_v0_watchpermissionsets_proto_msgTypes,
	}.Build()
	File_authzed_api_materialize_v0_watchpermissionsets_proto = out.File
	file_authzed_api_materialize_v0_watchpermissionsets_proto_goTypes = nil
	file_authzed_api_materialize_v0_watchpermissionsets_proto_depIdxs = nil
}
