// Copyright 2026 The OPA Authors.  All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.35.1
// source: v1/bundle/manifest.proto

package v1pb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	structpb "google.golang.org/protobuf/types/known/structpb"
	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)
)

// Manifest mirrors `bundle.Manifest` in v1/bundle/bundle.go.
type Manifest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Bundle revision string.
	Revision *string `protobuf:"bytes,1,opt,name=revision" json:"revision,omitempty"`
	// Root paths the bundle owns. See `roots_set` for nil-vs-empty.
	Roots []string `protobuf:"bytes,2,rep,name=roots" json:"roots,omitempty"`
	// Wasm resolvers attached to the bundle. JSON key is `wasm`.
	Wasm []*WasmResolver `protobuf:"bytes,3,rep,name=wasm" json:"wasm,omitempty"`
	// Global Rego version for the bundle. Currently 0 (RegoV0) or 1 (RegoV1).
	RegoVersion *int32 `protobuf:"varint,4,opt,name=rego_version,json=regoVersion" json:"rego_version,omitempty"`
	// Per-file Rego version overrides keyed by file path.
	FileRegoVersions map[string]int32 `protobuf:"bytes,5,rep,name=file_rego_versions,json=fileRegoVersions" json:"file_rego_versions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	// Free-form metadata object. Modeled as `Struct` because the Go field
	// is `map[string]any`.
	Metadata *structpb.Struct `protobuf:"bytes,6,opt,name=metadata" json:"metadata,omitempty"`
	// True iff `bundle.Manifest.Roots` was non-nil. `repeated string` can't
	// distinguish nil (default to [""]) from explicit-empty (owns no paths).
	RootsSet      *bool `protobuf:"varint,7,opt,name=roots_set,json=rootsSet" json:"roots_set,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Manifest) ProtoMessage() {}

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

func (x *Manifest) GetRevision() string {
	if x != nil && x.Revision != nil {
		return *x.Revision
	}
	return ""
}

func (x *Manifest) GetRoots() []string {
	if x != nil {
		return x.Roots
	}
	return nil
}

func (x *Manifest) GetWasm() []*WasmResolver {
	if x != nil {
		return x.Wasm
	}
	return nil
}

func (x *Manifest) GetRegoVersion() int32 {
	if x != nil && x.RegoVersion != nil {
		return *x.RegoVersion
	}
	return 0
}

func (x *Manifest) GetFileRegoVersions() map[string]int32 {
	if x != nil {
		return x.FileRegoVersions
	}
	return nil
}

func (x *Manifest) GetMetadata() *structpb.Struct {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *Manifest) GetRootsSet() bool {
	if x != nil && x.RootsSet != nil {
		return *x.RootsSet
	}
	return false
}

// WasmResolver mirrors `bundle.WasmResolver` in v1/bundle/bundle.go.
type WasmResolver struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Entrypoint policy ref this resolver targets.
	Entrypoint *string `protobuf:"bytes,1,opt,name=entrypoint" json:"entrypoint,omitempty"`
	// Path to the wasm module within the bundle.
	Module *string `protobuf:"bytes,2,opt,name=module" json:"module,omitempty"`
	// Rego annotations attached to the entrypoint.
	Annotations   []*Annotations `protobuf:"bytes,3,rep,name=annotations" json:"annotations,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WasmResolver) ProtoMessage() {}

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

func (x *WasmResolver) GetEntrypoint() string {
	if x != nil && x.Entrypoint != nil {
		return *x.Entrypoint
	}
	return ""
}

func (x *WasmResolver) GetModule() string {
	if x != nil && x.Module != nil {
		return *x.Module
	}
	return ""
}

func (x *WasmResolver) GetAnnotations() []*Annotations {
	if x != nil {
		return x.Annotations
	}
	return nil
}

// Annotations mirrors `ast.Annotations` in v1/ast/annotations.go.
type Annotations struct {
	state            protoimpl.MessageState       `protogen:"open.v1"`
	Scope            *string                      `protobuf:"bytes,1,opt,name=scope" json:"scope,omitempty"`
	Title            *string                      `protobuf:"bytes,2,opt,name=title" json:"title,omitempty"`
	Entrypoint       *bool                        `protobuf:"varint,3,opt,name=entrypoint" json:"entrypoint,omitempty"`
	Description      *string                      `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"`
	Organizations    []string                     `protobuf:"bytes,5,rep,name=organizations" json:"organizations,omitempty"`
	RelatedResources []*RelatedResourceAnnotation `protobuf:"bytes,6,rep,name=related_resources,json=relatedResources" json:"related_resources,omitempty"`
	Authors          []*AuthorAnnotation          `protobuf:"bytes,7,rep,name=authors" json:"authors,omitempty"`
	Schemas          []*SchemaAnnotation          `protobuf:"bytes,8,rep,name=schemas" json:"schemas,omitempty"`
	Compile          *CompileAnnotation           `protobuf:"bytes,9,opt,name=compile" json:"compile,omitempty"`
	// `custom` and `labels` are `map[string]any` in Go — genuinely
	// free-form, so `Struct` is the right model.
	Custom        *structpb.Struct `protobuf:"bytes,10,opt,name=custom" json:"custom,omitempty"`
	Labels        *structpb.Struct `protobuf:"bytes,11,opt,name=labels" json:"labels,omitempty"`
	Location      *Location        `protobuf:"bytes,12,opt,name=location" json:"location,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Annotations) ProtoMessage() {}

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

func (x *Annotations) GetScope() string {
	if x != nil && x.Scope != nil {
		return *x.Scope
	}
	return ""
}

func (x *Annotations) GetTitle() string {
	if x != nil && x.Title != nil {
		return *x.Title
	}
	return ""
}

func (x *Annotations) GetEntrypoint() bool {
	if x != nil && x.Entrypoint != nil {
		return *x.Entrypoint
	}
	return false
}

func (x *Annotations) GetDescription() string {
	if x != nil && x.Description != nil {
		return *x.Description
	}
	return ""
}

func (x *Annotations) GetOrganizations() []string {
	if x != nil {
		return x.Organizations
	}
	return nil
}

func (x *Annotations) GetRelatedResources() []*RelatedResourceAnnotation {
	if x != nil {
		return x.RelatedResources
	}
	return nil
}

func (x *Annotations) GetAuthors() []*AuthorAnnotation {
	if x != nil {
		return x.Authors
	}
	return nil
}

func (x *Annotations) GetSchemas() []*SchemaAnnotation {
	if x != nil {
		return x.Schemas
	}
	return nil
}

func (x *Annotations) GetCompile() *CompileAnnotation {
	if x != nil {
		return x.Compile
	}
	return nil
}

func (x *Annotations) GetCustom() *structpb.Struct {
	if x != nil {
		return x.Custom
	}
	return nil
}

func (x *Annotations) GetLabels() *structpb.Struct {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *Annotations) GetLocation() *Location {
	if x != nil {
		return x.Location
	}
	return nil
}

// SchemaAnnotation mirrors `ast.SchemaAnnotation`. Path/Schema are
// `ast.Ref` in Go (a list of terms); the wire form is the canonical
// dotted ref string (e.g. `data.foo.bar`). Modeling the term tree
// faithfully would pull most of the AST into this schema and isn't
// worth the cost for annotations.
type SchemaAnnotation struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Path   *string                `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	Schema *string                `protobuf:"bytes,2,opt,name=schema" json:"schema,omitempty"`
	// `*any` on the Go side — a parsed JSON Schema document or any
	// JSON value. `Value` (not `Struct`) because the top level may be
	// a scalar, list, or null, not just an object.
	Definition    *structpb.Value `protobuf:"bytes,3,opt,name=definition" json:"definition,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SchemaAnnotation) ProtoMessage() {}

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

func (x *SchemaAnnotation) GetPath() string {
	if x != nil && x.Path != nil {
		return *x.Path
	}
	return ""
}

func (x *SchemaAnnotation) GetSchema() string {
	if x != nil && x.Schema != nil {
		return *x.Schema
	}
	return ""
}

func (x *SchemaAnnotation) GetDefinition() *structpb.Value {
	if x != nil {
		return x.Definition
	}
	return nil
}

// CompileAnnotation mirrors `ast.CompileAnnotation`. Refs are the
// canonical dotted form; see SchemaAnnotation for the trade-off.
type CompileAnnotation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Unknowns      []string               `protobuf:"bytes,1,rep,name=unknowns" json:"unknowns,omitempty"`
	MaskRule      *string                `protobuf:"bytes,2,opt,name=mask_rule,json=maskRule" json:"mask_rule,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CompileAnnotation) ProtoMessage() {}

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

func (x *CompileAnnotation) GetUnknowns() []string {
	if x != nil {
		return x.Unknowns
	}
	return nil
}

func (x *CompileAnnotation) GetMaskRule() string {
	if x != nil && x.MaskRule != nil {
		return *x.MaskRule
	}
	return ""
}

// AuthorAnnotation mirrors `ast.AuthorAnnotation`.
type AuthorAnnotation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          *string                `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Email         *string                `protobuf:"bytes,2,opt,name=email" json:"email,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AuthorAnnotation) ProtoMessage() {}

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

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

func (x *AuthorAnnotation) GetEmail() string {
	if x != nil && x.Email != nil {
		return *x.Email
	}
	return ""
}

// RelatedResourceAnnotation mirrors `ast.RelatedResourceAnnotation`.
// `Ref` is a `url.URL` in Go, serialized to its `String()` form.
type RelatedResourceAnnotation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ref           *string                `protobuf:"bytes,1,opt,name=ref" json:"ref,omitempty"`
	Description   *string                `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RelatedResourceAnnotation) ProtoMessage() {}

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

func (x *RelatedResourceAnnotation) GetRef() string {
	if x != nil && x.Ref != nil {
		return *x.Ref
	}
	return ""
}

func (x *RelatedResourceAnnotation) GetDescription() string {
	if x != nil && x.Description != nil {
		return *x.Description
	}
	return ""
}

// Location mirrors `ast.Location` (= `location.Location`). Only the
// File/Row/Col triple is wire-relevant; `Text`, `Offset`, and `Tabs`
// are tagged `json:"-"` and intentionally absent.
//
// Distinct from `ir.Location`, which is promoted onto the `Stmt`
// envelope in plan.proto. The two are independent Go types.
type Location struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	File          *string                `protobuf:"bytes,1,opt,name=file" json:"file,omitempty"`
	Row           *int32                 `protobuf:"varint,2,opt,name=row" json:"row,omitempty"`
	Col           *int32                 `protobuf:"varint,3,opt,name=col" json:"col,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Location) ProtoMessage() {}

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

func (x *Location) GetFile() string {
	if x != nil && x.File != nil {
		return *x.File
	}
	return ""
}

func (x *Location) GetRow() int32 {
	if x != nil && x.Row != nil {
		return *x.Row
	}
	return 0
}

func (x *Location) GetCol() int32 {
	if x != nil && x.Col != nil {
		return *x.Col
	}
	return 0
}

var File_v1_bundle_manifest_proto protoreflect.FileDescriptor

const file_v1_bundle_manifest_proto_rawDesc = "" +
	"\n" +
	"\x18v1/bundle/manifest.proto\x12\ropa.bundle.v1\x1a\x1cgoogle/protobuf/struct.proto\"\x84\x03\n" +
	"\bManifest\x12\x1a\n" +
	"\brevision\x18\x01 \x01(\tR\brevision\x12\x14\n" +
	"\x05roots\x18\x02 \x03(\tR\x05roots\x12/\n" +
	"\x04wasm\x18\x03 \x03(\v2\x1b.opa.bundle.v1.WasmResolverR\x04wasm\x12!\n" +
	"\frego_version\x18\x04 \x01(\x05R\vregoVersion\x12[\n" +
	"\x12file_rego_versions\x18\x05 \x03(\v2-.opa.bundle.v1.Manifest.FileRegoVersionsEntryR\x10fileRegoVersions\x123\n" +
	"\bmetadata\x18\x06 \x01(\v2\x17.google.protobuf.StructR\bmetadata\x12\x1b\n" +
	"\troots_set\x18\a \x01(\bR\brootsSet\x1aC\n" +
	"\x15FileRegoVersionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\"\x84\x01\n" +
	"\fWasmResolver\x12\x1e\n" +
	"\n" +
	"entrypoint\x18\x01 \x01(\tR\n" +
	"entrypoint\x12\x16\n" +
	"\x06module\x18\x02 \x01(\tR\x06module\x12<\n" +
	"\vannotations\x18\x03 \x03(\v2\x1a.opa.bundle.v1.AnnotationsR\vannotations\"\xc1\x04\n" +
	"\vAnnotations\x12\x14\n" +
	"\x05scope\x18\x01 \x01(\tR\x05scope\x12\x14\n" +
	"\x05title\x18\x02 \x01(\tR\x05title\x12\x1e\n" +
	"\n" +
	"entrypoint\x18\x03 \x01(\bR\n" +
	"entrypoint\x12 \n" +
	"\vdescription\x18\x04 \x01(\tR\vdescription\x12$\n" +
	"\rorganizations\x18\x05 \x03(\tR\rorganizations\x12U\n" +
	"\x11related_resources\x18\x06 \x03(\v2(.opa.bundle.v1.RelatedResourceAnnotationR\x10relatedResources\x129\n" +
	"\aauthors\x18\a \x03(\v2\x1f.opa.bundle.v1.AuthorAnnotationR\aauthors\x129\n" +
	"\aschemas\x18\b \x03(\v2\x1f.opa.bundle.v1.SchemaAnnotationR\aschemas\x12:\n" +
	"\acompile\x18\t \x01(\v2 .opa.bundle.v1.CompileAnnotationR\acompile\x12/\n" +
	"\x06custom\x18\n" +
	" \x01(\v2\x17.google.protobuf.StructR\x06custom\x12/\n" +
	"\x06labels\x18\v \x01(\v2\x17.google.protobuf.StructR\x06labels\x123\n" +
	"\blocation\x18\f \x01(\v2\x17.opa.bundle.v1.LocationR\blocation\"v\n" +
	"\x10SchemaAnnotation\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x16\n" +
	"\x06schema\x18\x02 \x01(\tR\x06schema\x126\n" +
	"\n" +
	"definition\x18\x03 \x01(\v2\x16.google.protobuf.ValueR\n" +
	"definition\"L\n" +
	"\x11CompileAnnotation\x12\x1a\n" +
	"\bunknowns\x18\x01 \x03(\tR\bunknowns\x12\x1b\n" +
	"\tmask_rule\x18\x02 \x01(\tR\bmaskRule\"<\n" +
	"\x10AuthorAnnotation\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05email\x18\x02 \x01(\tR\x05email\"O\n" +
	"\x19RelatedResourceAnnotation\x12\x10\n" +
	"\x03ref\x18\x01 \x01(\tR\x03ref\x12 \n" +
	"\vdescription\x18\x02 \x01(\tR\vdescription\"B\n" +
	"\bLocation\x12\x12\n" +
	"\x04file\x18\x01 \x01(\tR\x04file\x12\x10\n" +
	"\x03row\x18\x02 \x01(\x05R\x03row\x12\x10\n" +
	"\x03col\x18\x03 \x01(\x05R\x03colB3P\x01Z/github.com/open-policy-agent/opa/v1/bundle/v1pbb\beditionsp\xe8\a"

var (
	file_v1_bundle_manifest_proto_rawDescOnce sync.Once
	file_v1_bundle_manifest_proto_rawDescData []byte
)

func file_v1_bundle_manifest_proto_rawDescGZIP() []byte {
	file_v1_bundle_manifest_proto_rawDescOnce.Do(func() {
		file_v1_bundle_manifest_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_v1_bundle_manifest_proto_rawDesc), len(file_v1_bundle_manifest_proto_rawDesc)))
	})
	return file_v1_bundle_manifest_proto_rawDescData
}

var file_v1_bundle_manifest_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_v1_bundle_manifest_proto_goTypes = []any{
	(*Manifest)(nil),                  // 0: opa.bundle.v1.Manifest
	(*WasmResolver)(nil),              // 1: opa.bundle.v1.WasmResolver
	(*Annotations)(nil),               // 2: opa.bundle.v1.Annotations
	(*SchemaAnnotation)(nil),          // 3: opa.bundle.v1.SchemaAnnotation
	(*CompileAnnotation)(nil),         // 4: opa.bundle.v1.CompileAnnotation
	(*AuthorAnnotation)(nil),          // 5: opa.bundle.v1.AuthorAnnotation
	(*RelatedResourceAnnotation)(nil), // 6: opa.bundle.v1.RelatedResourceAnnotation
	(*Location)(nil),                  // 7: opa.bundle.v1.Location
	nil,                               // 8: opa.bundle.v1.Manifest.FileRegoVersionsEntry
	(*structpb.Struct)(nil),           // 9: google.protobuf.Struct
	(*structpb.Value)(nil),            // 10: google.protobuf.Value
}
var file_v1_bundle_manifest_proto_depIdxs = []int32{
	1,  // 0: opa.bundle.v1.Manifest.wasm:type_name -> opa.bundle.v1.WasmResolver
	8,  // 1: opa.bundle.v1.Manifest.file_rego_versions:type_name -> opa.bundle.v1.Manifest.FileRegoVersionsEntry
	9,  // 2: opa.bundle.v1.Manifest.metadata:type_name -> google.protobuf.Struct
	2,  // 3: opa.bundle.v1.WasmResolver.annotations:type_name -> opa.bundle.v1.Annotations
	6,  // 4: opa.bundle.v1.Annotations.related_resources:type_name -> opa.bundle.v1.RelatedResourceAnnotation
	5,  // 5: opa.bundle.v1.Annotations.authors:type_name -> opa.bundle.v1.AuthorAnnotation
	3,  // 6: opa.bundle.v1.Annotations.schemas:type_name -> opa.bundle.v1.SchemaAnnotation
	4,  // 7: opa.bundle.v1.Annotations.compile:type_name -> opa.bundle.v1.CompileAnnotation
	9,  // 8: opa.bundle.v1.Annotations.custom:type_name -> google.protobuf.Struct
	9,  // 9: opa.bundle.v1.Annotations.labels:type_name -> google.protobuf.Struct
	7,  // 10: opa.bundle.v1.Annotations.location:type_name -> opa.bundle.v1.Location
	10, // 11: opa.bundle.v1.SchemaAnnotation.definition:type_name -> google.protobuf.Value
	12, // [12:12] is the sub-list for method output_type
	12, // [12:12] is the sub-list for method input_type
	12, // [12:12] is the sub-list for extension type_name
	12, // [12:12] is the sub-list for extension extendee
	0,  // [0:12] is the sub-list for field type_name
}

func init() { file_v1_bundle_manifest_proto_init() }
func file_v1_bundle_manifest_proto_init() {
	if File_v1_bundle_manifest_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_bundle_manifest_proto_rawDesc), len(file_v1_bundle_manifest_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_v1_bundle_manifest_proto_goTypes,
		DependencyIndexes: file_v1_bundle_manifest_proto_depIdxs,
		MessageInfos:      file_v1_bundle_manifest_proto_msgTypes,
	}.Build()
	File_v1_bundle_manifest_proto = out.File
	file_v1_bundle_manifest_proto_goTypes = nil
	file_v1_bundle_manifest_proto_depIdxs = nil
}
