Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

80.7 KB
Raw Blame
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: store/instance.proto

package store

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

type DataSourceType int32

const (
	DataSourceType_DATA_SOURCE_UNSPECIFIED DataSourceType = 0
	DataSourceType_ADMIN                   DataSourceType = 1
	DataSourceType_READ_ONLY               DataSourceType = 2
)

// Enum value maps for DataSourceType.
var (
	DataSourceType_name = map[int32]string{
		0: "DATA_SOURCE_UNSPECIFIED",
		1: "ADMIN",
		2: "READ_ONLY",
	}
	DataSourceType_value = map[string]int32{
		"DATA_SOURCE_UNSPECIFIED": 0,
		"ADMIN":                   1,
		"READ_ONLY":               2,
	}
)

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

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

func (DataSourceType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[0].Descriptor()
}

func (DataSourceType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[0]
}

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

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

type DataSource_AuthenticationType int32

const (
	DataSource_AUTHENTICATION_UNSPECIFIED DataSource_AuthenticationType = 0
	DataSource_PASSWORD                   DataSource_AuthenticationType = 1
	DataSource_GOOGLE_CLOUD_SQL_IAM       DataSource_AuthenticationType = 2
	DataSource_AWS_RDS_IAM                DataSource_AuthenticationType = 3
	DataSource_AZURE_IAM                  DataSource_AuthenticationType = 4
)

// Enum value maps for DataSource_AuthenticationType.
var (
	DataSource_AuthenticationType_name = map[int32]string{
		0: "AUTHENTICATION_UNSPECIFIED",
		1: "PASSWORD",
		2: "GOOGLE_CLOUD_SQL_IAM",
		3: "AWS_RDS_IAM",
		4: "AZURE_IAM",
	}
	DataSource_AuthenticationType_value = map[string]int32{
		"AUTHENTICATION_UNSPECIFIED": 0,
		"PASSWORD":                   1,
		"GOOGLE_CLOUD_SQL_IAM":       2,
		"AWS_RDS_IAM":                3,
		"AZURE_IAM":                  4,
	}
)

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

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

func (DataSource_AuthenticationType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[1].Descriptor()
}

func (DataSource_AuthenticationType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[1]
}

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

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

// CloudSQLIPType selects which Cloud SQL IP to dial for Google Cloud SQL IAM connections.
type DataSource_CloudSQLIPType int32

const (
	DataSource_CLOUD_SQL_IP_TYPE_UNSPECIFIED DataSource_CloudSQLIPType = 0
	DataSource_PUBLIC                        DataSource_CloudSQLIPType = 1
	DataSource_PRIVATE                       DataSource_CloudSQLIPType = 2
	DataSource_PSC                           DataSource_CloudSQLIPType = 3
)

// Enum value maps for DataSource_CloudSQLIPType.
var (
	DataSource_CloudSQLIPType_name = map[int32]string{
		0: "CLOUD_SQL_IP_TYPE_UNSPECIFIED",
		1: "PUBLIC",
		2: "PRIVATE",
		3: "PSC",
	}
	DataSource_CloudSQLIPType_value = map[string]int32{
		"CLOUD_SQL_IP_TYPE_UNSPECIFIED": 0,
		"PUBLIC":                        1,
		"PRIVATE":                       2,
		"PSC":                           3,
	}
)

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

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

func (DataSource_CloudSQLIPType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[2].Descriptor()
}

func (DataSource_CloudSQLIPType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[2]
}

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

// Deprecated: Use DataSource_CloudSQLIPType.Descriptor instead.
func (DataSource_CloudSQLIPType) EnumDescriptor() ([]byte, []int) {
	return file_store_instance_proto_rawDescGZIP(), []int{3, 1}
}

type DataSource_RedisType int32

const (
	DataSource_REDIS_TYPE_UNSPECIFIED DataSource_RedisType = 0
	DataSource_STANDALONE             DataSource_RedisType = 1
	DataSource_SENTINEL               DataSource_RedisType = 2
	DataSource_CLUSTER                DataSource_RedisType = 3
)

// Enum value maps for DataSource_RedisType.
var (
	DataSource_RedisType_name = map[int32]string{
		0: "REDIS_TYPE_UNSPECIFIED",
		1: "STANDALONE",
		2: "SENTINEL",
		3: "CLUSTER",
	}
	DataSource_RedisType_value = map[string]int32{
		"REDIS_TYPE_UNSPECIFIED": 0,
		"STANDALONE":             1,
		"SENTINEL":               2,
		"CLUSTER":                3,
	}
)

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

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

func (DataSource_RedisType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[3].Descriptor()
}

func (DataSource_RedisType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[3]
}

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

// Deprecated: Use DataSource_RedisType.Descriptor instead.
func (DataSource_RedisType) EnumDescriptor() ([]byte, []int) {
	return file_store_instance_proto_rawDescGZIP(), []int{3, 2}
}

type DataSourceExternalSecret_SecretType int32

const (
	DataSourceExternalSecret_SECRET_TYPE_UNSPECIFIED DataSourceExternalSecret_SecretType = 0
	// ref: https://developer.hashicorp.com/vault/api-docs/secret/kv/kv-v2
	DataSourceExternalSecret_VAULT_KV_V2 DataSourceExternalSecret_SecretType = 1
	// ref: https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html
	DataSourceExternalSecret_AWS_SECRETS_MANAGER DataSourceExternalSecret_SecretType = 2
	// ref: https://cloud.google.com/secret-manager/docs
	DataSourceExternalSecret_GCP_SECRET_MANAGER DataSourceExternalSecret_SecretType = 3
	// ref: https://learn.microsoft.com/en-us/azure/key-vault/secrets/about-secrets
	DataSourceExternalSecret_AZURE_KEY_VAULT DataSourceExternalSecret_SecretType = 4
)

// Enum value maps for DataSourceExternalSecret_SecretType.
var (
	DataSourceExternalSecret_SecretType_name = map[int32]string{
		0: "SECRET_TYPE_UNSPECIFIED",
		1: "VAULT_KV_V2",
		2: "AWS_SECRETS_MANAGER",
		3: "GCP_SECRET_MANAGER",
		4: "AZURE_KEY_VAULT",
	}
	DataSourceExternalSecret_SecretType_value = map[string]int32{
		"SECRET_TYPE_UNSPECIFIED": 0,
		"VAULT_KV_V2":             1,
		"AWS_SECRETS_MANAGER":     2,
		"GCP_SECRET_MANAGER":      3,
		"AZURE_KEY_VAULT":         4,
	}
)

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

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

func (DataSourceExternalSecret_SecretType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[4].Descriptor()
}

func (DataSourceExternalSecret_SecretType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[4]
}

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

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

type DataSourceExternalSecret_AuthType int32

const (
	DataSourceExternalSecret_AUTH_TYPE_UNSPECIFIED DataSourceExternalSecret_AuthType = 0
	// ref: https://developer.hashicorp.com/vault/docs/auth/token
	DataSourceExternalSecret_TOKEN DataSourceExternalSecret_AuthType = 1
	// ref: https://developer.hashicorp.com/vault/docs/auth/approle
	DataSourceExternalSecret_VAULT_APP_ROLE DataSourceExternalSecret_AuthType = 2
)

// Enum value maps for DataSourceExternalSecret_AuthType.
var (
	DataSourceExternalSecret_AuthType_name = map[int32]string{
		0: "AUTH_TYPE_UNSPECIFIED",
		1: "TOKEN",
		2: "VAULT_APP_ROLE",
	}
	DataSourceExternalSecret_AuthType_value = map[string]int32{
		"AUTH_TYPE_UNSPECIFIED": 0,
		"TOKEN":                 1,
		"VAULT_APP_ROLE":        2,
	}
)

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

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

func (DataSourceExternalSecret_AuthType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[5].Descriptor()
}

func (DataSourceExternalSecret_AuthType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[5]
}

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

// Deprecated: Use DataSourceExternalSecret_AuthType.Descriptor instead.
func (DataSourceExternalSecret_AuthType) EnumDescriptor() ([]byte, []int) {
	return file_store_instance_proto_rawDescGZIP(), []int{6, 1}
}

type DataSourceExternalSecret_TokenType int32

const (
	DataSourceExternalSecret_TOKEN_TYPE_UNSPECIFIED DataSourceExternalSecret_TokenType = 0
	// The token field holds the literal token value.
	DataSourceExternalSecret_PLAIN DataSourceExternalSecret_TokenType = 1
	// The token field holds the name of an environment variable on the
	// Bytebase server that holds the token value.
	DataSourceExternalSecret_ENVIRONMENT DataSourceExternalSecret_TokenType = 2
	// The token field holds a path to a file on the Bytebase server that
	// holds the token value.
	DataSourceExternalSecret_FILE DataSourceExternalSecret_TokenType = 3
)

// Enum value maps for DataSourceExternalSecret_TokenType.
var (
	DataSourceExternalSecret_TokenType_name = map[int32]string{
		0: "TOKEN_TYPE_UNSPECIFIED",
		1: "PLAIN",
		2: "ENVIRONMENT",
		3: "FILE",
	}
	DataSourceExternalSecret_TokenType_value = map[string]int32{
		"TOKEN_TYPE_UNSPECIFIED": 0,
		"PLAIN":                  1,
		"ENVIRONMENT":            2,
		"FILE":                   3,
	}
)

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

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

func (DataSourceExternalSecret_TokenType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[6].Descriptor()
}

func (DataSourceExternalSecret_TokenType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[6]
}

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

// Deprecated: Use DataSourceExternalSecret_TokenType.Descriptor instead.
func (DataSourceExternalSecret_TokenType) EnumDescriptor() ([]byte, []int) {
	return file_store_instance_proto_rawDescGZIP(), []int{6, 2}
}

type DataSourceExternalSecret_AppRoleAuthOption_SecretType int32

const (
	DataSourceExternalSecret_AppRoleAuthOption_SECRET_TYPE_UNSPECIFIED DataSourceExternalSecret_AppRoleAuthOption_SecretType = 0
	DataSourceExternalSecret_AppRoleAuthOption_PLAIN                   DataSourceExternalSecret_AppRoleAuthOption_SecretType = 1
	DataSourceExternalSecret_AppRoleAuthOption_ENVIRONMENT             DataSourceExternalSecret_AppRoleAuthOption_SecretType = 2
)

// Enum value maps for DataSourceExternalSecret_AppRoleAuthOption_SecretType.
var (
	DataSourceExternalSecret_AppRoleAuthOption_SecretType_name = map[int32]string{
		0: "SECRET_TYPE_UNSPECIFIED",
		1: "PLAIN",
		2: "ENVIRONMENT",
	}
	DataSourceExternalSecret_AppRoleAuthOption_SecretType_value = map[string]int32{
		"SECRET_TYPE_UNSPECIFIED": 0,
		"PLAIN":                   1,
		"ENVIRONMENT":             2,
	}
)

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

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

func (DataSourceExternalSecret_AppRoleAuthOption_SecretType) Descriptor() protoreflect.EnumDescriptor {
	return file_store_instance_proto_enumTypes[7].Descriptor()
}

func (DataSourceExternalSecret_AppRoleAuthOption_SecretType) Type() protoreflect.EnumType {
	return &file_store_instance_proto_enumTypes[7]
}

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

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

type SyncDatabases struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Databases     []string               `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SyncDatabases) ProtoMessage() {}

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

func (x *SyncDatabases) GetDatabases() []string {
	if x != nil {
		return x.Databases
	}
	return nil
}

// Instance is the proto for instances.
type Instance struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	Title        string                 `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Engine       Engine                 `protobuf:"varint,2,opt,name=engine,proto3,enum=bytebase.store.Engine" json:"engine,omitempty"`
	Activation   bool                   `protobuf:"varint,3,opt,name=activation,proto3" json:"activation,omitempty"`
	Version      string                 `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	ExternalLink string                 `protobuf:"bytes,5,opt,name=external_link,json=externalLink,proto3" json:"external_link,omitempty"`
	DataSources  []*DataSource          `protobuf:"bytes,6,rep,name=data_sources,json=dataSources,proto3" json:"data_sources,omitempty"`
	// The interval between automatic instance synchronizations.
	SyncInterval *durationpb.Duration `protobuf:"bytes,7,opt,name=sync_interval,json=syncInterval,proto3" json:"sync_interval,omitempty"`
	// Enable sync for the following databases.
	// Not set means sync all schemas & databases.
	SyncDatabases *SyncDatabases `protobuf:"bytes,9,opt,name=sync_databases,json=syncDatabases,proto3" json:"sync_databases,omitempty"`
	// The lower_case_table_names config for MySQL instances.
	// It is used to determine whether the table names and database names are case sensitive.
	MysqlLowerCaseTableNames int32                  `protobuf:"varint,10,opt,name=mysql_lower_case_table_names,json=mysqlLowerCaseTableNames,proto3" json:"mysql_lower_case_table_names,omitempty"`
	LastSyncTime             *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=last_sync_time,json=lastSyncTime,proto3" json:"last_sync_time,omitempty"`
	Roles                    []*InstanceRole        `protobuf:"bytes,12,rep,name=roles,proto3" json:"roles,omitempty"`
	// Labels are key-value pairs that can be attached to the instance.
	// For example, { "org_group": "infrastructure", "environment": "production" }
	Labels        map[string]string `protobuf:"bytes,13,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Instance) ProtoMessage() {}

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

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

func (x *Instance) GetEngine() Engine {
	if x != nil {
		return x.Engine
	}
	return Engine_ENGINE_UNSPECIFIED
}

func (x *Instance) GetActivation() bool {
	if x != nil {
		return x.Activation
	}
	return false
}

func (x *Instance) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *Instance) GetExternalLink() string {
	if x != nil {
		return x.ExternalLink
	}
	return ""
}

func (x *Instance) GetDataSources() []*DataSource {
	if x != nil {
		return x.DataSources
	}
	return nil
}

func (x *Instance) GetSyncInterval() *durationpb.Duration {
	if x != nil {
		return x.SyncInterval
	}
	return nil
}

func (x *Instance) GetSyncDatabases() *SyncDatabases {
	if x != nil {
		return x.SyncDatabases
	}
	return nil
}

func (x *Instance) GetMysqlLowerCaseTableNames() int32 {
	if x != nil {
		return x.MysqlLowerCaseTableNames
	}
	return 0
}

func (x *Instance) GetLastSyncTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LastSyncTime
	}
	return nil
}

func (x *Instance) GetRoles() []*InstanceRole {
	if x != nil {
		return x.Roles
	}
	return nil
}

func (x *Instance) GetLabels() map[string]string {
	if x != nil {
		return x.Labels
	}
	return nil
}

// InstanceRole is the API message for instance role.
type InstanceRole struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The role name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The connection count limit for this role.
	ConnectionLimit *int32 `protobuf:"varint,2,opt,name=connection_limit,json=connectionLimit,proto3,oneof" json:"connection_limit,omitempty"`
	// The expiration for the role's password.
	ValidUntil *string `protobuf:"bytes,3,opt,name=valid_until,json=validUntil,proto3,oneof" json:"valid_until,omitempty"`
	// The role attribute.
	// For PostgreSQL, it contains super_user, no_inherit, create_role, create_db, can_login, replication and bypass_rls. Docs: https://www.postgresql.org/docs/current/role-attributes.html
	// For MySQL, it is the global privileges as GRANT statements, which means it only contains "GRANT ... ON *.* TO ...". Docs: https://dev.mysql.com/doc/refman/8.0/en/grant.html
	Attribute     *string `protobuf:"bytes,4,opt,name=attribute,proto3,oneof" json:"attribute,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InstanceRole) ProtoMessage() {}

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

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

func (x *InstanceRole) GetConnectionLimit() int32 {
	if x != nil && x.ConnectionLimit != nil {
		return *x.ConnectionLimit
	}
	return 0
}

func (x *InstanceRole) GetValidUntil() string {
	if x != nil && x.ValidUntil != nil {
		return *x.ValidUntil
	}
	return ""
}

func (x *InstanceRole) GetAttribute() string {
	if x != nil && x.Attribute != nil {
		return *x.Attribute
	}
	return ""
}

type DataSource struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	Id                 string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type               DataSourceType         `protobuf:"varint,2,opt,name=type,proto3,enum=bytebase.store.DataSourceType" json:"type,omitempty"`
	Username           string                 `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	Password           string                 `protobuf:"bytes,37,opt,name=password,proto3" json:"password,omitempty"`
	ObfuscatedPassword string                 `protobuf:"bytes,4,opt,name=obfuscated_password,json=obfuscatedPassword,proto3" json:"obfuscated_password,omitempty"`
	// Use SSL to connect to the data source. By default, we use the system's SSL configuration.
	UseSsl                bool   `protobuf:"varint,30,opt,name=use_ssl,json=useSsl,proto3" json:"use_ssl,omitempty"`
	SslCa                 string `protobuf:"bytes,38,opt,name=ssl_ca,json=sslCa,proto3" json:"ssl_ca,omitempty"`
	ObfuscatedSslCa       string `protobuf:"bytes,5,opt,name=obfuscated_ssl_ca,json=obfuscatedSslCa,proto3" json:"obfuscated_ssl_ca,omitempty"`
	SslCert               string `protobuf:"bytes,39,opt,name=ssl_cert,json=sslCert,proto3" json:"ssl_cert,omitempty"`
	ObfuscatedSslCert     string `protobuf:"bytes,6,opt,name=obfuscated_ssl_cert,json=obfuscatedSslCert,proto3" json:"obfuscated_ssl_cert,omitempty"`
	SslKey                string `protobuf:"bytes,40,opt,name=ssl_key,json=sslKey,proto3" json:"ssl_key,omitempty"`
	ObfuscatedSslKey      string `protobuf:"bytes,7,opt,name=obfuscated_ssl_key,json=obfuscatedSslKey,proto3" json:"obfuscated_ssl_key,omitempty"`
	SslCaPath             string `protobuf:"bytes,50,opt,name=ssl_ca_path,json=sslCaPath,proto3" json:"ssl_ca_path,omitempty"`
	ObfuscatedSslCaPath   string `protobuf:"bytes,51,opt,name=obfuscated_ssl_ca_path,json=obfuscatedSslCaPath,proto3" json:"obfuscated_ssl_ca_path,omitempty"`
	SslCertPath           string `protobuf:"bytes,52,opt,name=ssl_cert_path,json=sslCertPath,proto3" json:"ssl_cert_path,omitempty"`
	ObfuscatedSslCertPath string `protobuf:"bytes,53,opt,name=obfuscated_ssl_cert_path,json=obfuscatedSslCertPath,proto3" json:"obfuscated_ssl_cert_path,omitempty"`
	SslKeyPath            string `protobuf:"bytes,54,opt,name=ssl_key_path,json=sslKeyPath,proto3" json:"ssl_key_path,omitempty"`
	ObfuscatedSslKeyPath  string `protobuf:"bytes,55,opt,name=obfuscated_ssl_key_path,json=obfuscatedSslKeyPath,proto3" json:"obfuscated_ssl_key_path,omitempty"`
	// verify_tls_certificate enables TLS certificate verification for SSL connections.
	// Default is false (no verification) for backward compatibility.
	// Set to true for secure connections (recommended for production).
	// Only set to false for development or when certificates cannot be properly
	// validated (e.g., self-signed certs, VPN environments).
	VerifyTlsCertificate bool   `protobuf:"varint,47,opt,name=verify_tls_certificate,json=verifyTlsCertificate,proto3" json:"verify_tls_certificate,omitempty"`
	Host                 string `protobuf:"bytes,8,opt,name=host,proto3" json:"host,omitempty"`
	Port                 string `protobuf:"bytes,9,opt,name=port,proto3" json:"port,omitempty"`
	Database             string `protobuf:"bytes,10,opt,name=database,proto3" json:"database,omitempty"`
	// srv, authentication_database, and replica_set are used for MongoDB.
	// srv is a boolean flag that indicates whether the host is a DNS SRV record.
	Srv bool `protobuf:"varint,11,opt,name=srv,proto3" json:"srv,omitempty"`
	// authentication_database is the database name to authenticate against, which stores the user credentials.
	AuthenticationDatabase string `protobuf:"bytes,12,opt,name=authentication_database,json=authenticationDatabase,proto3" json:"authentication_database,omitempty"`
	// replica_set is used for MongoDB replica set.
	ReplicaSet string `protobuf:"bytes,25,opt,name=replica_set,json=replicaSet,proto3" json:"replica_set,omitempty"`
	// sid and service_name are used for Oracle.
	Sid         string `protobuf:"bytes,13,opt,name=sid,proto3" json:"sid,omitempty"`
	ServiceName string `protobuf:"bytes,14,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// SSH related
	// The hostname of the SSH server agent.
	SshHost string `protobuf:"bytes,15,opt,name=ssh_host,json=sshHost,proto3" json:"ssh_host,omitempty"`
	// The port of the SSH server agent. It's 22 typically.
	SshPort string `protobuf:"bytes,16,opt,name=ssh_port,json=sshPort,proto3" json:"ssh_port,omitempty"`
	// The user to login the server.
	SshUser string `protobuf:"bytes,17,opt,name=ssh_user,json=sshUser,proto3" json:"ssh_user,omitempty"`
	// The password to login the server. If it's empty string, no password is required.
	SshPassword           string `protobuf:"bytes,41,opt,name=ssh_password,json=sshPassword,proto3" json:"ssh_password,omitempty"`
	ObfuscatedSshPassword string `protobuf:"bytes,18,opt,name=obfuscated_ssh_password,json=obfuscatedSshPassword,proto3" json:"obfuscated_ssh_password,omitempty"`
	// The private key to login the server. If it's empty string, we will use the system default private key from os.Getenv("SSH_AUTH_SOCK").
	SshPrivateKey           string `protobuf:"bytes,42,opt,name=ssh_private_key,json=sshPrivateKey,proto3" json:"ssh_private_key,omitempty"`
	ObfuscatedSshPrivateKey string `protobuf:"bytes,19,opt,name=obfuscated_ssh_private_key,json=obfuscatedSshPrivateKey,proto3" json:"obfuscated_ssh_private_key,omitempty"`
	// PKCS#8 private key in PEM format. If it's empty string, no private key is required.
	// Used for authentication when connecting to the data source.
	AuthenticationPrivateKey           string `protobuf:"bytes,43,opt,name=authentication_private_key,json=authenticationPrivateKey,proto3" json:"authentication_private_key,omitempty"`
	ObfuscatedAuthenticationPrivateKey string `protobuf:"bytes,20,opt,name=obfuscated_authentication_private_key,json=obfuscatedAuthenticationPrivateKey,proto3" json:"obfuscated_authentication_private_key,omitempty"`
	// Passphrase for the encrypted PKCS#8 private key. Only used when the private key is encrypted.
	AuthenticationPrivateKeyPassphrase           string                        `protobuf:"bytes,48,opt,name=authentication_private_key_passphrase,json=authenticationPrivateKeyPassphrase,proto3" json:"authentication_private_key_passphrase,omitempty"`
	ObfuscatedAuthenticationPrivateKeyPassphrase string                        `protobuf:"bytes,49,opt,name=obfuscated_authentication_private_key_passphrase,json=obfuscatedAuthenticationPrivateKeyPassphrase,proto3" json:"obfuscated_authentication_private_key_passphrase,omitempty"`
	ExternalSecret                               *DataSourceExternalSecret     `protobuf:"bytes,21,opt,name=external_secret,json=externalSecret,proto3" json:"external_secret,omitempty"`
	AuthenticationType                           DataSource_AuthenticationType `protobuf:"varint,22,opt,name=authentication_type,json=authenticationType,proto3,enum=bytebase.store.DataSource_AuthenticationType" json:"authentication_type,omitempty"`
	// cloud_sql_ip_type selects the Cloud SQL IP type for Google Cloud SQL IAM connections.
	// CLOUD_SQL_IP_TYPE_UNSPECIFIED is treated as PUBLIC for backward compatibility.
	CloudSqlIpType DataSource_CloudSQLIPType `protobuf:"varint,56,opt,name=cloud_sql_ip_type,json=cloudSqlIpType,proto3,enum=bytebase.store.DataSource_CloudSQLIPType" json:"cloud_sql_ip_type,omitempty"`
	// Types that are valid to be assigned to IamExtension:
	//
	//	*DataSource_AzureCredential_
	//	*DataSource_AwsCredential
	//	*DataSource_GcpCredential
	IamExtension isDataSource_IamExtension `protobuf_oneof:"iam_extension"`
	SaslConfig   *SASLConfig               `protobuf:"bytes,24,opt,name=sasl_config,json=saslConfig,proto3" json:"sasl_config,omitempty"`
	// additional_addresses is used for MongoDB replica set.
	AdditionalAddresses []*DataSource_Address `protobuf:"bytes,26,rep,name=additional_addresses,json=additionalAddresses,proto3" json:"additional_addresses,omitempty"`
	// direct_connection is used for MongoDB to dispatch all the operations to the node specified in the connection string.
	DirectConnection bool `protobuf:"varint,27,opt,name=direct_connection,json=directConnection,proto3" json:"direct_connection,omitempty"`
	// Region is the location of the database, used for AWS RDS. For example, us-east-1.
	Region string `protobuf:"bytes,28,opt,name=region,proto3" json:"region,omitempty"`
	// warehouse_id is used by Databricks.
	WarehouseId string `protobuf:"bytes,29,opt,name=warehouse_id,json=warehouseId,proto3" json:"warehouse_id,omitempty"`
	// master_name is the master name used by connecting redis-master via redis sentinel.
	MasterName string `protobuf:"bytes,31,opt,name=master_name,json=masterName,proto3" json:"master_name,omitempty"`
	// master_username and master_obfuscated_password are master credentials used by redis sentinel mode.
	MasterUsername           string               `protobuf:"bytes,32,opt,name=master_username,json=masterUsername,proto3" json:"master_username,omitempty"`
	MasterPassword           string               `protobuf:"bytes,44,opt,name=master_password,json=masterPassword,proto3" json:"master_password,omitempty"`
	ObfuscatedMasterPassword string               `protobuf:"bytes,33,opt,name=obfuscated_master_password,json=obfuscatedMasterPassword,proto3" json:"obfuscated_master_password,omitempty"`
	RedisType                DataSource_RedisType `protobuf:"varint,34,opt,name=redis_type,json=redisType,proto3,enum=bytebase.store.DataSource_RedisType" json:"redis_type,omitempty"`
	// Extra connection parameters for the database connection.
	// For PostgreSQL HA, this can be used to set target_session_attrs=read-write
	ExtraConnectionParameters map[string]string `protobuf:"bytes,36,rep,name=extra_connection_parameters,json=extraConnectionParameters,proto3" json:"extra_connection_parameters,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// project_id and instance_id are the GCP resource identifiers.
	// project_id is used by Spanner and BigQuery; instance_id is used by Spanner.
	// For these engines, host and port optionally override the default Google API
	// endpoint (e.g. a Private Service Connect endpoint like
	// spanner-nonprod.p.googleapis.com).
	ProjectId     string `protobuf:"bytes,57,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	InstanceId    string `protobuf:"bytes,58,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DataSource) ProtoMessage() {}

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

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

func (x *DataSource) GetType() DataSourceType {
	if x != nil {
		return x.Type
	}
	return DataSourceType_DATA_SOURCE_UNSPECIFIED
}

func (x *DataSource) GetUsername() string {
	if x != nil {
		return x.Username
	}
	return ""
}

func (x *DataSource) GetPassword() string {
	if x != nil {
		return x.Password
	}
	return ""
}

func (x *DataSource) GetObfuscatedPassword() string {
	if x != nil {
		return x.ObfuscatedPassword
	}
	return ""
}

func (x *DataSource) GetUseSsl() bool {
	if x != nil {
		return x.UseSsl
	}
	return false
}

func (x *DataSource) GetSslCa() string {
	if x != nil {
		return x.SslCa
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslCa() string {
	if x != nil {
		return x.ObfuscatedSslCa
	}
	return ""
}

func (x *DataSource) GetSslCert() string {
	if x != nil {
		return x.SslCert
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslCert() string {
	if x != nil {
		return x.ObfuscatedSslCert
	}
	return ""
}

func (x *DataSource) GetSslKey() string {
	if x != nil {
		return x.SslKey
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslKey() string {
	if x != nil {
		return x.ObfuscatedSslKey
	}
	return ""
}

func (x *DataSource) GetSslCaPath() string {
	if x != nil {
		return x.SslCaPath
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslCaPath() string {
	if x != nil {
		return x.ObfuscatedSslCaPath
	}
	return ""
}

func (x *DataSource) GetSslCertPath() string {
	if x != nil {
		return x.SslCertPath
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslCertPath() string {
	if x != nil {
		return x.ObfuscatedSslCertPath
	}
	return ""
}

func (x *DataSource) GetSslKeyPath() string {
	if x != nil {
		return x.SslKeyPath
	}
	return ""
}

func (x *DataSource) GetObfuscatedSslKeyPath() string {
	if x != nil {
		return x.ObfuscatedSslKeyPath
	}
	return ""
}

func (x *DataSource) GetVerifyTlsCertificate() bool {
	if x != nil {
		return x.VerifyTlsCertificate
	}
	return false
}

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

func (x *DataSource) GetPort() string {
	if x != nil {
		return x.Port
	}
	return ""
}

func (x *DataSource) GetDatabase() string {
	if x != nil {
		return x.Database
	}
	return ""
}

func (x *DataSource) GetSrv() bool {
	if x != nil {
		return x.Srv
	}
	return false
}

func (x *DataSource) GetAuthenticationDatabase() string {
	if x != nil {
		return x.AuthenticationDatabase
	}
	return ""
}

func (x *DataSource) GetReplicaSet() string {
	if x != nil {
		return x.ReplicaSet
	}
	return ""
}

func (x *DataSource) GetSid() string {
	if x != nil {
		return x.Sid
	}
	return ""
}

func (x *DataSource) GetServiceName() string {
	if x != nil {
		return x.ServiceName
	}
	return ""
}

func (x *DataSource) GetSshHost() string {
	if x != nil {
		return x.SshHost
	}
	return ""
}

func (x *DataSource) GetSshPort() string {
	if x != nil {
		return x.SshPort
	}
	return ""
}

func (x *DataSource) GetSshUser() string {
	if x != nil {
		return x.SshUser
	}
	return ""
}

func (x *DataSource) GetSshPassword() string {
	if x != nil {
		return x.SshPassword
	}
	return ""
}

func (x *DataSource) GetObfuscatedSshPassword() string {
	if x != nil {
		return x.ObfuscatedSshPassword
	}
	return ""
}

func (x *DataSource) GetSshPrivateKey() string {
	if x != nil {
		return x.SshPrivateKey
	}
	return ""
}

func (x *DataSource) GetObfuscatedSshPrivateKey() string {
	if x != nil {
		return x.ObfuscatedSshPrivateKey
	}
	return ""
}

func (x *DataSource) GetAuthenticationPrivateKey() string {
	if x != nil {
		return x.AuthenticationPrivateKey
	}
	return ""
}

func (x *DataSource) GetObfuscatedAuthenticationPrivateKey() string {
	if x != nil {
		return x.ObfuscatedAuthenticationPrivateKey
	}
	return ""
}

func (x *DataSource) GetAuthenticationPrivateKeyPassphrase() string {
	if x != nil {
		return x.AuthenticationPrivateKeyPassphrase
	}
	return ""
}

func (x *DataSource) GetObfuscatedAuthenticationPrivateKeyPassphrase() string {
	if x != nil {
		return x.ObfuscatedAuthenticationPrivateKeyPassphrase
	}
	return ""
}

func (x *DataSource) GetExternalSecret() *DataSourceExternalSecret {
	if x != nil {
		return x.ExternalSecret
	}
	return nil
}

func (x *DataSource) GetAuthenticationType() DataSource_AuthenticationType {
	if x != nil {
		return x.AuthenticationType
	}
	return DataSource_AUTHENTICATION_UNSPECIFIED
}

func (x *DataSource) GetCloudSqlIpType() DataSource_CloudSQLIPType {
	if x != nil {
		return x.CloudSqlIpType
	}
	return DataSource_CLOUD_SQL_IP_TYPE_UNSPECIFIED
}

func (x *DataSource) GetIamExtension() isDataSource_IamExtension {
	if x != nil {
		return x.IamExtension
	}
	return nil
}

func (x *DataSource) GetAzureCredential() *DataSource_AzureCredential {
	if x != nil {
		if x, ok := x.IamExtension.(*DataSource_AzureCredential_); ok {
			return x.AzureCredential
		}
	}
	return nil
}

func (x *DataSource) GetAwsCredential() *DataSource_AWSCredential {
	if x != nil {
		if x, ok := x.IamExtension.(*DataSource_AwsCredential); ok {
			return x.AwsCredential
		}
	}
	return nil
}

func (x *DataSource) GetGcpCredential() *DataSource_GCPCredential {
	if x != nil {
		if x, ok := x.IamExtension.(*DataSource_GcpCredential); ok {
			return x.GcpCredential
		}
	}
	return nil
}

func (x *DataSource) GetSaslConfig() *SASLConfig {
	if x != nil {
		return x.SaslConfig
	}
	return nil
}

func (x *DataSource) GetAdditionalAddresses() []*DataSource_Address {
	if x != nil {
		return x.AdditionalAddresses
	}
	return nil
}

func (x *DataSource) GetDirectConnection() bool {
	if x != nil {
		return x.DirectConnection
	}
	return false
}

func (x *DataSource) GetRegion() string {
	if x != nil {
		return x.Region
	}
	return ""
}

func (x *DataSource) GetWarehouseId() string {
	if x != nil {
		return x.WarehouseId
	}
	return ""
}

func (x *DataSource) GetMasterName() string {
	if x != nil {
		return x.MasterName
	}
	return ""
}

func (x *DataSource) GetMasterUsername() string {
	if x != nil {
		return x.MasterUsername
	}
	return ""
}

func (x *DataSource) GetMasterPassword() string {
	if x != nil {
		return x.MasterPassword
	}
	return ""
}

func (x *DataSource) GetObfuscatedMasterPassword() string {
	if x != nil {
		return x.ObfuscatedMasterPassword
	}
	return ""
}

func (x *DataSource) GetRedisType() DataSource_RedisType {
	if x != nil {
		return x.RedisType
	}
	return DataSource_REDIS_TYPE_UNSPECIFIED
}

func (x *DataSource) GetExtraConnectionParameters() map[string]string {
	if x != nil {
		return x.ExtraConnectionParameters
	}
	return nil
}

func (x *DataSource) GetProjectId() string {
	if x != nil {
		return x.ProjectId
	}
	return ""
}

func (x *DataSource) GetInstanceId() string {
	if x != nil {
		return x.InstanceId
	}
	return ""
}

type isDataSource_IamExtension interface {
	isDataSource_IamExtension()
}

type DataSource_AzureCredential_ struct {
	AzureCredential *DataSource_AzureCredential `protobuf:"bytes,23,opt,name=azure_credential,json=azureCredential,proto3,oneof"`
}

type DataSource_AwsCredential struct {
	AwsCredential *DataSource_AWSCredential `protobuf:"bytes,45,opt,name=aws_credential,json=awsCredential,proto3,oneof"`
}

type DataSource_GcpCredential struct {
	GcpCredential *DataSource_GCPCredential `protobuf:"bytes,46,opt,name=gcp_credential,json=gcpCredential,proto3,oneof"`
}

func (*DataSource_AzureCredential_) isDataSource_IamExtension() {}

func (*DataSource_AwsCredential) isDataSource_IamExtension() {}

func (*DataSource_GcpCredential) isDataSource_IamExtension() {}

type SASLConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Mechanism:
	//
	//	*SASLConfig_KrbConfig
	Mechanism     isSASLConfig_Mechanism `protobuf_oneof:"mechanism"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SASLConfig) ProtoMessage() {}

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

func (x *SASLConfig) GetMechanism() isSASLConfig_Mechanism {
	if x != nil {
		return x.Mechanism
	}
	return nil
}

func (x *SASLConfig) GetKrbConfig() *KerberosConfig {
	if x != nil {
		if x, ok := x.Mechanism.(*SASLConfig_KrbConfig); ok {
			return x.KrbConfig
		}
	}
	return nil
}

type isSASLConfig_Mechanism interface {
	isSASLConfig_Mechanism()
}

type SASLConfig_KrbConfig struct {
	KrbConfig *KerberosConfig `protobuf:"bytes,1,opt,name=krb_config,json=krbConfig,proto3,oneof"`
}

func (*SASLConfig_KrbConfig) isSASLConfig_Mechanism() {}

type KerberosConfig struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	Primary              string                 `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
	Instance             string                 `protobuf:"bytes,2,opt,name=instance,proto3" json:"instance,omitempty"`
	Realm                string                 `protobuf:"bytes,3,opt,name=realm,proto3" json:"realm,omitempty"`
	Keytab               []byte                 `protobuf:"bytes,4,opt,name=keytab,proto3" json:"keytab,omitempty"`
	KdcHost              string                 `protobuf:"bytes,5,opt,name=kdc_host,json=kdcHost,proto3" json:"kdc_host,omitempty"`
	KdcPort              string                 `protobuf:"bytes,6,opt,name=kdc_port,json=kdcPort,proto3" json:"kdc_port,omitempty"`
	KdcTransportProtocol string                 `protobuf:"bytes,7,opt,name=kdc_transport_protocol,json=kdcTransportProtocol,proto3" json:"kdc_transport_protocol,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*KerberosConfig) ProtoMessage() {}

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

func (x *KerberosConfig) GetPrimary() string {
	if x != nil {
		return x.Primary
	}
	return ""
}

func (x *KerberosConfig) GetInstance() string {
	if x != nil {
		return x.Instance
	}
	return ""
}

func (x *KerberosConfig) GetRealm() string {
	if x != nil {
		return x.Realm
	}
	return ""
}

func (x *KerberosConfig) GetKeytab() []byte {
	if x != nil {
		return x.Keytab
	}
	return nil
}

func (x *KerberosConfig) GetKdcHost() string {
	if x != nil {
		return x.KdcHost
	}
	return ""
}

func (x *KerberosConfig) GetKdcPort() string {
	if x != nil {
		return x.KdcPort
	}
	return ""
}

func (x *KerberosConfig) GetKdcTransportProtocol() string {
	if x != nil {
		return x.KdcTransportProtocol
	}
	return ""
}

type DataSourceExternalSecret struct {
	state      protoimpl.MessageState              `protogen:"open.v1"`
	SecretType DataSourceExternalSecret_SecretType `protobuf:"varint,1,opt,name=secret_type,json=secretType,proto3,enum=bytebase.store.DataSourceExternalSecret_SecretType" json:"secret_type,omitempty"`
	Url        string                              `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	AuthType   DataSourceExternalSecret_AuthType   `protobuf:"varint,3,opt,name=auth_type,json=authType,proto3,enum=bytebase.store.DataSourceExternalSecret_AuthType" json:"auth_type,omitempty"`
	// Types that are valid to be assigned to AuthOption:
	//
	//	*DataSourceExternalSecret_AppRole
	//	*DataSourceExternalSecret_Token
	AuthOption isDataSourceExternalSecret_AuthOption `protobuf_oneof:"auth_option"`
	// How to interpret the token field when auth_type is TOKEN.
	TokenType DataSourceExternalSecret_TokenType `protobuf:"varint,16,opt,name=token_type,json=tokenType,proto3,enum=bytebase.store.DataSourceExternalSecret_TokenType" json:"token_type,omitempty"`
	// engine name is the name for secret engine.
	EngineName string `protobuf:"bytes,6,opt,name=engine_name,json=engineName,proto3" json:"engine_name,omitempty"`
	// the secret name in the engine to store the password.
	SecretName string `protobuf:"bytes,7,opt,name=secret_name,json=secretName,proto3" json:"secret_name,omitempty"`
	// the key name for the password.
	PasswordKeyName string `protobuf:"bytes,8,opt,name=password_key_name,json=passwordKeyName,proto3" json:"password_key_name,omitempty"`
	// TLS configuration for connecting to Vault server.
	// These fields are separate from the database TLS configuration in DataSource.
	// skip_vault_tls_verification disables TLS certificate verification for Vault connections.
	// Default is false (verification enabled) for security.
	// Only set to true for development or when certificates cannot be properly validated.
	SkipVaultTlsVerification bool `protobuf:"varint,9,opt,name=skip_vault_tls_verification,json=skipVaultTlsVerification,proto3" json:"skip_vault_tls_verification,omitempty"`
	// CA certificate for Vault server verification.
	VaultSslCa           string `protobuf:"bytes,10,opt,name=vault_ssl_ca,json=vaultSslCa,proto3" json:"vault_ssl_ca,omitempty"`
	ObfuscatedVaultSslCa string `protobuf:"bytes,11,opt,name=obfuscated_vault_ssl_ca,json=obfuscatedVaultSslCa,proto3" json:"obfuscated_vault_ssl_ca,omitempty"`
	// Client certificate for mutual TLS authentication with Vault.
	VaultSslCert           string `protobuf:"bytes,12,opt,name=vault_ssl_cert,json=vaultSslCert,proto3" json:"vault_ssl_cert,omitempty"`
	ObfuscatedVaultSslCert string `protobuf:"bytes,13,opt,name=obfuscated_vault_ssl_cert,json=obfuscatedVaultSslCert,proto3" json:"obfuscated_vault_ssl_cert,omitempty"`
	// Client private key for mutual TLS authentication with Vault.
	VaultSslKey           string `protobuf:"bytes,14,opt,name=vault_ssl_key,json=vaultSslKey,proto3" json:"vault_ssl_key,omitempty"`
	ObfuscatedVaultSslKey string `protobuf:"bytes,15,opt,name=obfuscated_vault_ssl_key,json=obfuscatedVaultSslKey,proto3" json:"obfuscated_vault_ssl_key,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

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

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

func (*DataSourceExternalSecret) ProtoMessage() {}

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

func (x *DataSourceExternalSecret) GetSecretType() DataSourceExternalSecret_SecretType {
	if x != nil {
		return x.SecretType
	}
	return DataSourceExternalSecret_SECRET_TYPE_UNSPECIFIED
}

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

func (x *DataSourceExternalSecret) GetAuthType() DataSourceExternalSecret_AuthType {
	if x != nil {
		return x.AuthType
	}
	return DataSourceExternalSecret_AUTH_TYPE_UNSPECIFIED
}

func (x *DataSourceExternalSecret) GetAuthOption() isDataSourceExternalSecret_AuthOption {
	if x != nil {
		return x.AuthOption
	}
	return nil
}

func (x *DataSourceExternalSecret) GetAppRole() *DataSourceExternalSecret_AppRoleAuthOption {
	if x != nil {
		if x, ok := x.AuthOption.(*DataSourceExternalSecret_AppRole); ok {
			return x.AppRole
		}
	}
	return nil
}

func (x *DataSourceExternalSecret) GetToken() string {
	if x != nil {
		if x, ok := x.AuthOption.(*DataSourceExternalSecret_Token); ok {
			return x.Token
		}
	}
	return ""
}

func (x *DataSourceExternalSecret) GetTokenType() DataSourceExternalSecret_TokenType {
	if x != nil {
		return x.TokenType
	}
	return DataSourceExternalSecret_TOKEN_TYPE_UNSPECIFIED
}

func (x *DataSourceExternalSecret) GetEngineName() string {
	if x != nil {
		return x.EngineName
	}
	return ""
}

func (x *DataSourceExternalSecret) GetSecretName() string {
	if x != nil {
		return x.SecretName
	}
	return ""
}

func (x *DataSourceExternalSecret) GetPasswordKeyName() string {
	if x != nil {
		return x.PasswordKeyName
	}
	return ""
}

func (x *DataSourceExternalSecret) GetSkipVaultTlsVerification() bool {
	if x != nil {
		return x.SkipVaultTlsVerification
	}
	return false
}

func (x *DataSourceExternalSecret) GetVaultSslCa() string {
	if x != nil {
		return x.VaultSslCa
	}
	return ""
}

func (x *DataSourceExternalSecret) GetObfuscatedVaultSslCa() string {
	if x != nil {
		return x.ObfuscatedVaultSslCa
	}
	return ""
}

func (x *DataSourceExternalSecret) GetVaultSslCert() string {
	if x != nil {
		return x.VaultSslCert
	}
	return ""
}

func (x *DataSourceExternalSecret) GetObfuscatedVaultSslCert() string {
	if x != nil {
		return x.ObfuscatedVaultSslCert
	}
	return ""
}

func (x *DataSourceExternalSecret) GetVaultSslKey() string {
	if x != nil {
		return x.VaultSslKey
	}
	return ""
}

func (x *DataSourceExternalSecret) GetObfuscatedVaultSslKey() string {
	if x != nil {
		return x.ObfuscatedVaultSslKey
	}
	return ""
}

type isDataSourceExternalSecret_AuthOption interface {
	isDataSourceExternalSecret_AuthOption()
}

type DataSourceExternalSecret_AppRole struct {
	AppRole *DataSourceExternalSecret_AppRoleAuthOption `protobuf:"bytes,4,opt,name=app_role,json=appRole,proto3,oneof"`
}

type DataSourceExternalSecret_Token struct {
	Token string `protobuf:"bytes,5,opt,name=token,proto3,oneof"`
}

func (*DataSourceExternalSecret_AppRole) isDataSourceExternalSecret_AuthOption() {}

func (*DataSourceExternalSecret_Token) isDataSourceExternalSecret_AuthOption() {}

type DataSource_AzureCredential struct {
	state                  protoimpl.MessageState `protogen:"open.v1"`
	TenantId               string                 `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	ClientId               string                 `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	ClientSecret           string                 `protobuf:"bytes,3,opt,name=client_secret,json=clientSecret,proto3" json:"client_secret,omitempty"`
	ObfuscatedClientSecret string                 `protobuf:"bytes,4,opt,name=obfuscated_client_secret,json=obfuscatedClientSecret,proto3" json:"obfuscated_client_secret,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*DataSource_AzureCredential) ProtoMessage() {}

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

func (x *DataSource_AzureCredential) GetTenantId() string {
	if x != nil {
		return x.TenantId
	}
	return ""
}

func (x *DataSource_AzureCredential) GetClientId() string {
	if x != nil {
		return x.ClientId
	}
	return ""
}

func (x *DataSource_AzureCredential) GetClientSecret() string {
	if x != nil {
		return x.ClientSecret
	}
	return ""
}

func (x *DataSource_AzureCredential) GetObfuscatedClientSecret() string {
	if x != nil {
		return x.ObfuscatedClientSecret
	}
	return ""
}

type DataSource_AWSCredential struct {
	state                     protoimpl.MessageState `protogen:"open.v1"`
	AccessKeyId               string                 `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
	ObfuscatedAccessKeyId     string                 `protobuf:"bytes,2,opt,name=obfuscated_access_key_id,json=obfuscatedAccessKeyId,proto3" json:"obfuscated_access_key_id,omitempty"`
	SecretAccessKey           string                 `protobuf:"bytes,3,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"`
	ObfuscatedSecretAccessKey string                 `protobuf:"bytes,4,opt,name=obfuscated_secret_access_key,json=obfuscatedSecretAccessKey,proto3" json:"obfuscated_secret_access_key,omitempty"`
	SessionToken              string                 `protobuf:"bytes,5,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
	ObfuscatedSessionToken    string                 `protobuf:"bytes,6,opt,name=obfuscated_session_token,json=obfuscatedSessionToken,proto3" json:"obfuscated_session_token,omitempty"`
	// ARN of IAM role to assume for cross-account access.
	// See: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html
	RoleArn string `protobuf:"bytes,7,opt,name=role_arn,json=roleArn,proto3" json:"role_arn,omitempty"`
	// Optional external ID for additional security when assuming role.
	// See: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html
	ExternalId    string `protobuf:"bytes,8,opt,name=external_id,json=externalId,proto3" json:"external_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DataSource_AWSCredential) ProtoMessage() {}

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

func (x *DataSource_AWSCredential) GetAccessKeyId() string {
	if x != nil {
		return x.AccessKeyId
	}
	return ""
}

func (x *DataSource_AWSCredential) GetObfuscatedAccessKeyId() string {
	if x != nil {
		return x.ObfuscatedAccessKeyId
	}
	return ""
}

func (x *DataSource_AWSCredential) GetSecretAccessKey() string {
	if x != nil {
		return x.SecretAccessKey
	}
	return ""
}

func (x *DataSource_AWSCredential) GetObfuscatedSecretAccessKey() string {
	if x != nil {
		return x.ObfuscatedSecretAccessKey
	}
	return ""
}

func (x *DataSource_AWSCredential) GetSessionToken() string {
	if x != nil {
		return x.SessionToken
	}
	return ""
}

func (x *DataSource_AWSCredential) GetObfuscatedSessionToken() string {
	if x != nil {
		return x.ObfuscatedSessionToken
	}
	return ""
}

func (x *DataSource_AWSCredential) GetRoleArn() string {
	if x != nil {
		return x.RoleArn
	}
	return ""
}

func (x *DataSource_AWSCredential) GetExternalId() string {
	if x != nil {
		return x.ExternalId
	}
	return ""
}

type DataSource_GCPCredential struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	Content           string                 `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	ObfuscatedContent string                 `protobuf:"bytes,2,opt,name=obfuscated_content,json=obfuscatedContent,proto3" json:"obfuscated_content,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*DataSource_GCPCredential) ProtoMessage() {}

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

func (x *DataSource_GCPCredential) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

func (x *DataSource_GCPCredential) GetObfuscatedContent() string {
	if x != nil {
		return x.ObfuscatedContent
	}
	return ""
}

type DataSource_Address struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Host          string                 `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	Port          string                 `protobuf:"bytes,2,opt,name=port,proto3" json:"port,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DataSource_Address) ProtoMessage() {}

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

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

func (x *DataSource_Address) GetPort() string {
	if x != nil {
		return x.Port
	}
	return ""
}

type DataSourceExternalSecret_AppRoleAuthOption struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	RoleId string                 `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
	// The secret ID for the role without TTL.
	SecretId string                                                `protobuf:"bytes,2,opt,name=secret_id,json=secretId,proto3" json:"secret_id,omitempty"`
	Type     DataSourceExternalSecret_AppRoleAuthOption_SecretType `protobuf:"varint,3,opt,name=type,proto3,enum=bytebase.store.DataSourceExternalSecret_AppRoleAuthOption_SecretType" json:"type,omitempty"`
	// The path where the approle auth method is mounted.
	MountPath     string `protobuf:"bytes,4,opt,name=mount_path,json=mountPath,proto3" json:"mount_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DataSourceExternalSecret_AppRoleAuthOption) Reset() {
	*x = DataSourceExternalSecret_AppRoleAuthOption{}
	mi := &file_store_instance_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DataSourceExternalSecret_AppRoleAuthOption) ProtoMessage() {}

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

func (x *DataSourceExternalSecret_AppRoleAuthOption) GetRoleId() string {
	if x != nil {
		return x.RoleId
	}
	return ""
}

func (x *DataSourceExternalSecret_AppRoleAuthOption) GetSecretId() string {
	if x != nil {
		return x.SecretId
	}
	return ""
}

func (x *DataSourceExternalSecret_AppRoleAuthOption) GetType() DataSourceExternalSecret_AppRoleAuthOption_SecretType {
	if x != nil {
		return x.Type
	}
	return DataSourceExternalSecret_AppRoleAuthOption_SECRET_TYPE_UNSPECIFIED
}

func (x *DataSourceExternalSecret_AppRoleAuthOption) GetMountPath() string {
	if x != nil {
		return x.MountPath
	}
	return ""
}

var File_store_instance_proto protoreflect.FileDescriptor

const file_store_instance_proto_rawDesc = "" +
	"\n" +
	"\x14store/instance.proto\x12\x0ebytebase.store\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x12store/common.proto\"-\n" +
	"\rSyncDatabases\x12\x1c\n" +
	"\tdatabases\x18\x01 \x03(\tR\tdatabases\"\xa9\x05\n" +
	"\bInstance\x12\x14\n" +
	"\x05title\x18\x01 \x01(\tR\x05title\x12.\n" +
	"\x06engine\x18\x02 \x01(\x0e2\x16.bytebase.store.EngineR\x06engine\x12\x1e\n" +
	"\n" +
	"activation\x18\x03 \x01(\bR\n" +
	"activation\x12\x18\n" +
	"\aversion\x18\x04 \x01(\tR\aversion\x12#\n" +
	"\rexternal_link\x18\x05 \x01(\tR\fexternalLink\x12=\n" +
	"\fdata_sources\x18\x06 \x03(\v2\x1a.bytebase.store.DataSourceR\vdataSources\x12>\n" +
	"\rsync_interval\x18\a \x01(\v2\x19.google.protobuf.DurationR\fsyncInterval\x12D\n" +
	"\x0esync_databases\x18\t \x01(\v2\x1d.bytebase.store.SyncDatabasesR\rsyncDatabases\x12>\n" +
	"\x1cmysql_lower_case_table_names\x18\n" +
	" \x01(\x05R\x18mysqlLowerCaseTableNames\x12@\n" +
	"\x0elast_sync_time\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\flastSyncTime\x122\n" +
	"\x05roles\x18\f \x03(\v2\x1c.bytebase.store.InstanceRoleR\x05roles\x12<\n" +
	"\x06labels\x18\r \x03(\v2$.bytebase.store.Instance.LabelsEntryR\x06labels\x1a9\n" +
	"\vLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01J\x04\b\b\x10\t\"\xce\x01\n" +
	"\fInstanceRole\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12.\n" +
	"\x10connection_limit\x18\x02 \x01(\x05H\x00R\x0fconnectionLimit\x88\x01\x01\x12$\n" +
	"\vvalid_until\x18\x03 \x01(\tH\x01R\n" +
	"validUntil\x88\x01\x01\x12!\n" +
	"\tattribute\x18\x04 \x01(\tH\x02R\tattribute\x88\x01\x01B\x13\n" +
	"\x11_connection_limitB\x0e\n" +
	"\f_valid_untilB\f\n" +
	"\n" +
	"_attribute\"\x9e\x1e\n" +
	"\n" +
	"DataSource\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x122\n" +
	"\x04type\x18\x02 \x01(\x0e2\x1e.bytebase.store.DataSourceTypeR\x04type\x12\x1a\n" +
	"\busername\x18\x03 \x01(\tR\busername\x12\x1a\n" +
	"\bpassword\x18% \x01(\tR\bpassword\x12/\n" +
	"\x13obfuscated_password\x18\x04 \x01(\tR\x12obfuscatedPassword\x12\x17\n" +
	"\ause_ssl\x18\x1e \x01(\bR\x06useSsl\x12\x15\n" +
	"\x06ssl_ca\x18& \x01(\tR\x05sslCa\x12*\n" +
	"\x11obfuscated_ssl_ca\x18\x05 \x01(\tR\x0fobfuscatedSslCa\x12\x19\n" +
	"\bssl_cert\x18' \x01(\tR\asslCert\x12.\n" +
	"\x13obfuscated_ssl_cert\x18\x06 \x01(\tR\x11obfuscatedSslCert\x12\x17\n" +
	"\assl_key\x18( \x01(\tR\x06sslKey\x12,\n" +
	"\x12obfuscated_ssl_key\x18\a \x01(\tR\x10obfuscatedSslKey\x12\x1e\n" +
	"\vssl_ca_path\x182 \x01(\tR\tsslCaPath\x123\n" +
	"\x16obfuscated_ssl_ca_path\x183 \x01(\tR\x13obfuscatedSslCaPath\x12\"\n" +
	"\rssl_cert_path\x184 \x01(\tR\vsslCertPath\x127\n" +
	"\x18obfuscated_ssl_cert_path\x185 \x01(\tR\x15obfuscatedSslCertPath\x12 \n" +
	"\fssl_key_path\x186 \x01(\tR\n" +
	"sslKeyPath\x125\n" +
	"\x17obfuscated_ssl_key_path\x187 \x01(\tR\x14obfuscatedSslKeyPath\x124\n" +
	"\x16verify_tls_certificate\x18/ \x01(\bR\x14verifyTlsCertificate\x12\x12\n" +
	"\x04host\x18\b \x01(\tR\x04host\x12\x12\n" +
	"\x04port\x18\t \x01(\tR\x04port\x12\x1a\n" +
	"\bdatabase\x18\n" +
	" \x01(\tR\bdatabase\x12\x10\n" +
	"\x03srv\x18\v \x01(\bR\x03srv\x127\n" +
	"\x17authentication_database\x18\f \x01(\tR\x16authenticationDatabase\x12\x1f\n" +
	"\vreplica_set\x18\x19 \x01(\tR\n" +
	"replicaSet\x12\x10\n" +
	"\x03sid\x18\r \x01(\tR\x03sid\x12!\n" +
	"\fservice_name\x18\x0e \x01(\tR\vserviceName\x12\x19\n" +
	"\bssh_host\x18\x0f \x01(\tR\asshHost\x12\x19\n" +
	"\bssh_port\x18\x10 \x01(\tR\asshPort\x12\x19\n" +
	"\bssh_user\x18\x11 \x01(\tR\asshUser\x12!\n" +
	"\fssh_password\x18) \x01(\tR\vsshPassword\x126\n" +
	"\x17obfuscated_ssh_password\x18\x12 \x01(\tR\x15obfuscatedSshPassword\x12&\n" +
	"\x0fssh_private_key\x18* \x01(\tR\rsshPrivateKey\x12;\n" +
	"\x1aobfuscated_ssh_private_key\x18\x13 \x01(\tR\x17obfuscatedSshPrivateKey\x12<\n" +
	"\x1aauthentication_private_key\x18+ \x01(\tR\x18authenticationPrivateKey\x12Q\n" +
	"%obfuscated_authentication_private_key\x18\x14 \x01(\tR\"obfuscatedAuthenticationPrivateKey\x12Q\n" +
	"%authentication_private_key_passphrase\x180 \x01(\tR\"authenticationPrivateKeyPassphrase\x12f\n" +
	"0obfuscated_authentication_private_key_passphrase\x181 \x01(\tR,obfuscatedAuthenticationPrivateKeyPassphrase\x12Q\n" +
	"\x0fexternal_secret\x18\x15 \x01(\v2(.bytebase.store.DataSourceExternalSecretR\x0eexternalSecret\x12^\n" +
	"\x13authentication_type\x18\x16 \x01(\x0e2-.bytebase.store.DataSource.AuthenticationTypeR\x12authenticationType\x12T\n" +
	"\x11cloud_sql_ip_type\x188 \x01(\x0e2).bytebase.store.DataSource.CloudSQLIPTypeR\x0ecloudSqlIpType\x12W\n" +
	"\x10azure_credential\x18\x17 \x01(\v2*.bytebase.store.DataSource.AzureCredentialH\x00R\x0fazureCredential\x12Q\n" +
	"\x0eaws_credential\x18- \x01(\v2(.bytebase.store.DataSource.AWSCredentialH\x00R\rawsCredential\x12Q\n" +
	"\x0egcp_credential\x18. \x01(\v2(.bytebase.store.DataSource.GCPCredentialH\x00R\rgcpCredential\x12;\n" +
	"\vsasl_config\x18\x18 \x01(\v2\x1a.bytebase.store.SASLConfigR\n" +
	"saslConfig\x12U\n" +
	"\x14additional_addresses\x18\x1a \x03(\v2\".bytebase.store.DataSource.AddressR\x13additionalAddresses\x12+\n" +
	"\x11direct_connection\x18\x1b \x01(\bR\x10directConnection\x12\x16\n" +
	"\x06region\x18\x1c \x01(\tR\x06region\x12!\n" +
	"\fwarehouse_id\x18\x1d \x01(\tR\vwarehouseId\x12\x1f\n" +
	"\vmaster_name\x18\x1f \x01(\tR\n" +
	"masterName\x12'\n" +
	"\x0fmaster_username\x18  \x01(\tR\x0emasterUsername\x12'\n" +
	"\x0fmaster_password\x18, \x01(\tR\x0emasterPassword\x12<\n" +
	"\x1aobfuscated_master_password\x18! \x01(\tR\x18obfuscatedMasterPassword\x12C\n" +
	"\n" +
	"redis_type\x18\" \x01(\x0e2$.bytebase.store.DataSource.RedisTypeR\tredisType\x12y\n" +
	"\x1bextra_connection_parameters\x18$ \x03(\v29.bytebase.store.DataSource.ExtraConnectionParametersEntryR\x19extraConnectionParameters\x12\x1d\n" +
	"\n" +
	"project_id\x189 \x01(\tR\tprojectId\x12\x1f\n" +
	"\vinstance_id\x18: \x01(\tR\n" +
	"instanceId\x1a\xaa\x01\n" +
	"\x0fAzureCredential\x12\x1b\n" +
	"\ttenant_id\x18\x01 \x01(\tR\btenantId\x12\x1b\n" +
	"\tclient_id\x18\x02 \x01(\tR\bclientId\x12#\n" +
	"\rclient_secret\x18\x03 \x01(\tR\fclientSecret\x128\n" +
	"\x18obfuscated_client_secret\x18\x04 \x01(\tR\x16obfuscatedClientSecret\x1a\xf4\x02\n" +
	"\rAWSCredential\x12\"\n" +
	"\raccess_key_id\x18\x01 \x01(\tR\vaccessKeyId\x127\n" +
	"\x18obfuscated_access_key_id\x18\x02 \x01(\tR\x15obfuscatedAccessKeyId\x12*\n" +
	"\x11secret_access_key\x18\x03 \x01(\tR\x0fsecretAccessKey\x12?\n" +
	"\x1cobfuscated_secret_access_key\x18\x04 \x01(\tR\x19obfuscatedSecretAccessKey\x12#\n" +
	"\rsession_token\x18\x05 \x01(\tR\fsessionToken\x128\n" +
	"\x18obfuscated_session_token\x18\x06 \x01(\tR\x16obfuscatedSessionToken\x12\x19\n" +
	"\brole_arn\x18\a \x01(\tR\aroleArn\x12\x1f\n" +
	"\vexternal_id\x18\b \x01(\tR\n" +
	"externalId\x1aX\n" +
	"\rGCPCredential\x12\x18\n" +
	"\acontent\x18\x01 \x01(\tR\acontent\x12-\n" +
	"\x12obfuscated_content\x18\x02 \x01(\tR\x11obfuscatedContent\x1a1\n" +
	"\aAddress\x12\x12\n" +
	"\x04host\x18\x01 \x01(\tR\x04host\x12\x12\n" +
	"\x04port\x18\x02 \x01(\tR\x04port\x1aL\n" +
	"\x1eExtraConnectionParametersEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"|\n" +
	"\x12AuthenticationType\x12\x1e\n" +
	"\x1aAUTHENTICATION_UNSPECIFIED\x10\x00\x12\f\n" +
	"\bPASSWORD\x10\x01\x12\x18\n" +
	"\x14GOOGLE_CLOUD_SQL_IAM\x10\x02\x12\x0f\n" +
	"\vAWS_RDS_IAM\x10\x03\x12\r\n" +
	"\tAZURE_IAM\x10\x04\"U\n" +
	"\x0eCloudSQLIPType\x12!\n" +
	"\x1dCLOUD_SQL_IP_TYPE_UNSPECIFIED\x10\x00\x12\n" +
	"\n" +
	"\x06PUBLIC\x10\x01\x12\v\n" +
	"\aPRIVATE\x10\x02\x12\a\n" +
	"\x03PSC\x10\x03\"R\n" +
	"\tRedisType\x12\x1a\n" +
	"\x16REDIS_TYPE_UNSPECIFIED\x10\x00\x12\x0e\n" +
	"\n" +
	"STANDALONE\x10\x01\x12\f\n" +
	"\bSENTINEL\x10\x02\x12\v\n" +
	"\aCLUSTER\x10\x03B\x0f\n" +
	"\riam_extensionJ\x04\b#\x10$\"Z\n" +
	"\n" +
	"SASLConfig\x12?\n" +
	"\n" +
	"krb_config\x18\x01 \x01(\v2\x1e.bytebase.store.KerberosConfigH\x00R\tkrbConfigB\v\n" +
	"\tmechanism\"\xe0\x01\n" +
	"\x0eKerberosConfig\x12\x18\n" +
	"\aprimary\x18\x01 \x01(\tR\aprimary\x12\x1a\n" +
	"\binstance\x18\x02 \x01(\tR\binstance\x12\x14\n" +
	"\x05realm\x18\x03 \x01(\tR\x05realm\x12\x16\n" +
	"\x06keytab\x18\x04 \x01(\fR\x06keytab\x12\x19\n" +
	"\bkdc_host\x18\x05 \x01(\tR\akdcHost\x12\x19\n" +
	"\bkdc_port\x18\x06 \x01(\tR\akdcPort\x124\n" +
	"\x16kdc_transport_protocol\x18\a \x01(\tR\x14kdcTransportProtocol\"\x8e\v\n" +
	"\x18DataSourceExternalSecret\x12T\n" +
	"\vsecret_type\x18\x01 \x01(\x0e23.bytebase.store.DataSourceExternalSecret.SecretTypeR\n" +
	"secretType\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\x12N\n" +
	"\tauth_type\x18\x03 \x01(\x0e21.bytebase.store.DataSourceExternalSecret.AuthTypeR\bauthType\x12W\n" +
	"\bapp_role\x18\x04 \x01(\v2:.bytebase.store.DataSourceExternalSecret.AppRoleAuthOptionH\x00R\aappRole\x12\x16\n" +
	"\x05token\x18\x05 \x01(\tH\x00R\x05token\x12Q\n" +
	"\n" +
	"token_type\x18\x10 \x01(\x0e22.bytebase.store.DataSourceExternalSecret.TokenTypeR\ttokenType\x12\x1f\n" +
	"\vengine_name\x18\x06 \x01(\tR\n" +
	"engineName\x12\x1f\n" +
	"\vsecret_name\x18\a \x01(\tR\n" +
	"secretName\x12*\n" +
	"\x11password_key_name\x18\b \x01(\tR\x0fpasswordKeyName\x12=\n" +
	"\x1bskip_vault_tls_verification\x18\t \x01(\bR\x18skipVaultTlsVerification\x12 \n" +
	"\fvault_ssl_ca\x18\n" +
	" \x01(\tR\n" +
	"vaultSslCa\x125\n" +
	"\x17obfuscated_vault_ssl_ca\x18\v \x01(\tR\x14obfuscatedVaultSslCa\x12$\n" +
	"\x0evault_ssl_cert\x18\f \x01(\tR\fvaultSslCert\x129\n" +
	"\x19obfuscated_vault_ssl_cert\x18\r \x01(\tR\x16obfuscatedVaultSslCert\x12\"\n" +
	"\rvault_ssl_key\x18\x0e \x01(\tR\vvaultSslKey\x127\n" +
	"\x18obfuscated_vault_ssl_key\x18\x0f \x01(\tR\x15obfuscatedVaultSslKey\x1a\x8a\x02\n" +
	"\x11AppRoleAuthOption\x12\x17\n" +
	"\arole_id\x18\x01 \x01(\tR\x06roleId\x12\x1b\n" +
	"\tsecret_id\x18\x02 \x01(\tR\bsecretId\x12Y\n" +
	"\x04type\x18\x03 \x01(\x0e2E.bytebase.store.DataSourceExternalSecret.AppRoleAuthOption.SecretTypeR\x04type\x12\x1d\n" +
	"\n" +
	"mount_path\x18\x04 \x01(\tR\tmountPath\"E\n" +
	"\n" +
	"SecretType\x12\x1b\n" +
	"\x17SECRET_TYPE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05PLAIN\x10\x01\x12\x0f\n" +
	"\vENVIRONMENT\x10\x02\"\x80\x01\n" +
	"\n" +
	"SecretType\x12\x1b\n" +
	"\x17SECRET_TYPE_UNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vVAULT_KV_V2\x10\x01\x12\x17\n" +
	"\x13AWS_SECRETS_MANAGER\x10\x02\x12\x16\n" +
	"\x12GCP_SECRET_MANAGER\x10\x03\x12\x13\n" +
	"\x0fAZURE_KEY_VAULT\x10\x04\"D\n" +
	"\bAuthType\x12\x19\n" +
	"\x15AUTH_TYPE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05TOKEN\x10\x01\x12\x12\n" +
	"\x0eVAULT_APP_ROLE\x10\x02\"M\n" +
	"\tTokenType\x12\x1a\n" +
	"\x16TOKEN_TYPE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05PLAIN\x10\x01\x12\x0f\n" +
	"\vENVIRONMENT\x10\x02\x12\b\n" +
	"\x04FILE\x10\x03B\r\n" +
	"\vauth_option*G\n" +
	"\x0eDataSourceType\x12\x1b\n" +
	"\x17DATA_SOURCE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05ADMIN\x10\x01\x12\r\n" +
	"\tREAD_ONLY\x10\x02B\x90\x01\n" +
	"\x12com.bytebase.storeB\rInstanceProtoP\x01Z\x12generated-go/store\xa2\x02\x03BSX\xaa\x02\x0eBytebase.Store\xca\x02\x0eBytebase\\Store\xe2\x02\x1aBytebase\\Store\\GPBMetadata\xea\x02\x0fBytebase::Storeb\x06proto3"

var (
	file_store_instance_proto_rawDescOnce sync.Once
	file_store_instance_proto_rawDescData []byte
)

func file_store_instance_proto_rawDescGZIP() []byte {
	file_store_instance_proto_rawDescOnce.Do(func() {
		file_store_instance_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_store_instance_proto_rawDesc), len(file_store_instance_proto_rawDesc)))
	})
	return file_store_instance_proto_rawDescData
}

var file_store_instance_proto_enumTypes = make([]protoimpl.EnumInfo, 8)
var file_store_instance_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_store_instance_proto_goTypes = []any{
	(DataSourceType)(0),                                        // 0: bytebase.store.DataSourceType
	(DataSource_AuthenticationType)(0),                         // 1: bytebase.store.DataSource.AuthenticationType
	(DataSource_CloudSQLIPType)(0),                             // 2: bytebase.store.DataSource.CloudSQLIPType
	(DataSource_RedisType)(0),                                  // 3: bytebase.store.DataSource.RedisType
	(DataSourceExternalSecret_SecretType)(0),                   // 4: bytebase.store.DataSourceExternalSecret.SecretType
	(DataSourceExternalSecret_AuthType)(0),                     // 5: bytebase.store.DataSourceExternalSecret.AuthType
	(DataSourceExternalSecret_TokenType)(0),                    // 6: bytebase.store.DataSourceExternalSecret.TokenType
	(DataSourceExternalSecret_AppRoleAuthOption_SecretType)(0), // 7: bytebase.store.DataSourceExternalSecret.AppRoleAuthOption.SecretType
	(*SyncDatabases)(nil),                                      // 8: bytebase.store.SyncDatabases
	(*Instance)(nil),                                           // 9: bytebase.store.Instance
	(*InstanceRole)(nil),                                       // 10: bytebase.store.InstanceRole
	(*DataSource)(nil),                                         // 11: bytebase.store.DataSource
	(*SASLConfig)(nil),                                         // 12: bytebase.store.SASLConfig
	(*KerberosConfig)(nil),                                     // 13: bytebase.store.KerberosConfig
	(*DataSourceExternalSecret)(nil),                           // 14: bytebase.store.DataSourceExternalSecret
	nil,                                                        // 15: bytebase.store.Instance.LabelsEntry
	(*DataSource_AzureCredential)(nil),                         // 16: bytebase.store.DataSource.AzureCredential
	(*DataSource_AWSCredential)(nil),                           // 17: bytebase.store.DataSource.AWSCredential
	(*DataSource_GCPCredential)(nil),                           // 18: bytebase.store.DataSource.GCPCredential
	(*DataSource_Address)(nil),                                 // 19: bytebase.store.DataSource.Address
	nil,                                                        // 20: bytebase.store.DataSource.ExtraConnectionParametersEntry
	(*DataSourceExternalSecret_AppRoleAuthOption)(nil),         // 21: bytebase.store.DataSourceExternalSecret.AppRoleAuthOption
	(Engine)(0),                                                // 22: bytebase.store.Engine
	(*durationpb.Duration)(nil),                                // 23: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),                              // 24: google.protobuf.Timestamp
}
var file_store_instance_proto_depIdxs = []int32{
	22, // 0: bytebase.store.Instance.engine:type_name -> bytebase.store.Engine
	11, // 1: bytebase.store.Instance.data_sources:type_name -> bytebase.store.DataSource
	23, // 2: bytebase.store.Instance.sync_interval:type_name -> google.protobuf.Duration
	8,  // 3: bytebase.store.Instance.sync_databases:type_name -> bytebase.store.SyncDatabases
	24, // 4: bytebase.store.Instance.last_sync_time:type_name -> google.protobuf.Timestamp
	10, // 5: bytebase.store.Instance.roles:type_name -> bytebase.store.InstanceRole
	15, // 6: bytebase.store.Instance.labels:type_name -> bytebase.store.Instance.LabelsEntry
	0,  // 7: bytebase.store.DataSource.type:type_name -> bytebase.store.DataSourceType
	14, // 8: bytebase.store.DataSource.external_secret:type_name -> bytebase.store.DataSourceExternalSecret
	1,  // 9: bytebase.store.DataSource.authentication_type:type_name -> bytebase.store.DataSource.AuthenticationType
	2,  // 10: bytebase.store.DataSource.cloud_sql_ip_type:type_name -> bytebase.store.DataSource.CloudSQLIPType
	16, // 11: bytebase.store.DataSource.azure_credential:type_name -> bytebase.store.DataSource.AzureCredential
	17, // 12: bytebase.store.DataSource.aws_credential:type_name -> bytebase.store.DataSource.AWSCredential
	18, // 13: bytebase.store.DataSource.gcp_credential:type_name -> bytebase.store.DataSource.GCPCredential
	12, // 14: bytebase.store.DataSource.sasl_config:type_name -> bytebase.store.SASLConfig
	19, // 15: bytebase.store.DataSource.additional_addresses:type_name -> bytebase.store.DataSource.Address
	3,  // 16: bytebase.store.DataSource.redis_type:type_name -> bytebase.store.DataSource.RedisType
	20, // 17: bytebase.store.DataSource.extra_connection_parameters:type_name -> bytebase.store.DataSource.ExtraConnectionParametersEntry
	13, // 18: bytebase.store.SASLConfig.krb_config:type_name -> bytebase.store.KerberosConfig
	4,  // 19: bytebase.store.DataSourceExternalSecret.secret_type:type_name -> bytebase.store.DataSourceExternalSecret.SecretType
	5,  // 20: bytebase.store.DataSourceExternalSecret.auth_type:type_name -> bytebase.store.DataSourceExternalSecret.AuthType
	21, // 21: bytebase.store.DataSourceExternalSecret.app_role:type_name -> bytebase.store.DataSourceExternalSecret.AppRoleAuthOption
	6,  // 22: bytebase.store.DataSourceExternalSecret.token_type:type_name -> bytebase.store.DataSourceExternalSecret.TokenType
	7,  // 23: bytebase.store.DataSourceExternalSecret.AppRoleAuthOption.type:type_name -> bytebase.store.DataSourceExternalSecret.AppRoleAuthOption.SecretType
	24, // [24:24] is the sub-list for method output_type
	24, // [24:24] is the sub-list for method input_type
	24, // [24:24] is the sub-list for extension type_name
	24, // [24:24] is the sub-list for extension extendee
	0,  // [0:24] is the sub-list for field type_name
}

func init() { file_store_instance_proto_init() }
func file_store_instance_proto_init() {
	if File_store_instance_proto != nil {
		return
	}
	file_store_common_proto_init()
	file_store_instance_proto_msgTypes[2].OneofWrappers = []any{}
	file_store_instance_proto_msgTypes[3].OneofWrappers = []any{
		(*DataSource_AzureCredential_)(nil),
		(*DataSource_AwsCredential)(nil),
		(*DataSource_GcpCredential)(nil),
	}
	file_store_instance_proto_msgTypes[4].OneofWrappers = []any{
		(*SASLConfig_KrbConfig)(nil),
	}
	file_store_instance_proto_msgTypes[6].OneofWrappers = []any{
		(*DataSourceExternalSecret_AppRole)(nil),
		(*DataSourceExternalSecret_Token)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_store_instance_proto_rawDesc), len(file_store_instance_proto_rawDesc)),
			NumEnums:      8,
			NumMessages:   14,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_store_instance_proto_goTypes,
		DependencyIndexes: file_store_instance_proto_depIdxs,
		EnumInfos:         file_store_instance_proto_enumTypes,
		MessageInfos:      file_store_instance_proto_msgTypes,
	}.Build()
	File_store_instance_proto = out.File
	file_store_instance_proto_goTypes = nil
	file_store_instance_proto_depIdxs = nil
}