// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        (unknown)
// source: adminapi/v1beta1/import.proto

package v1beta1

import (
	_ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
	common "github.com/tidbcloud/dataflow-service/idl/pbgen/proto/common"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	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)
)

// The validation item of the import.
type ImportValidationItem int32

const (
	// The validation item is unspecified.
	ImportValidationItem_IMPORT_VALIDATION_ITEM_UNSPECIFIED ImportValidationItem = 0
	// The validation item is source access check.
	ImportValidationItem_SOURCE_ACCESS_CHECK ImportValidationItem = 1
	// The validation item is target access check.(deprecated)
	ImportValidationItem_TARGET_ACCESS_CHECK ImportValidationItem = 2
	// The validation item is filter and rule check.(deprecated)
	ImportValidationItem_FILTER_AND_RULE_CHECK ImportValidationItem = 3
	// The validation item is import precheck.
	ImportValidationItem_IMPORT_PRECHECK ImportValidationItem = 4
	// The validation item is target table empty check.
	ImportValidationItem_TARGET_TABLE_EMPTY_CHECK ImportValidationItem = 5
	// The validation item is estimate size.(deprecated)
	ImportValidationItem_ESTIMATE_SIZE ImportValidationItem = 6
	// The validation item is import data only check.
	ImportValidationItem_IMPORT_DATA_ONLY_CHECK ImportValidationItem = 7
)

// Enum value maps for ImportValidationItem.
var (
	ImportValidationItem_name = map[int32]string{
		0: "IMPORT_VALIDATION_ITEM_UNSPECIFIED",
		1: "SOURCE_ACCESS_CHECK",
		2: "TARGET_ACCESS_CHECK",
		3: "FILTER_AND_RULE_CHECK",
		4: "IMPORT_PRECHECK",
		5: "TARGET_TABLE_EMPTY_CHECK",
		6: "ESTIMATE_SIZE",
		7: "IMPORT_DATA_ONLY_CHECK",
	}
	ImportValidationItem_value = map[string]int32{
		"IMPORT_VALIDATION_ITEM_UNSPECIFIED": 0,
		"SOURCE_ACCESS_CHECK":                1,
		"TARGET_ACCESS_CHECK":                2,
		"FILTER_AND_RULE_CHECK":              3,
		"IMPORT_PRECHECK":                    4,
		"TARGET_TABLE_EMPTY_CHECK":           5,
		"ESTIMATE_SIZE":                      6,
		"IMPORT_DATA_ONLY_CHECK":             7,
	}
)

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

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

func (ImportValidationItem) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[0].Descriptor()
}

func (ImportValidationItem) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[0]
}

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

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

// The source type of the import.
type ImportSourceType_Enum int32

const (
	// Indicates that the import source is not specified.
	ImportSourceType_UNSPECIFIED ImportSourceType_Enum = 0
	// Indicates that the import source is an AWS S3 resource.
	ImportSourceType_S3 ImportSourceType_Enum = 2
	// Indicates that the import source is a Google Cloud Storage resource.
	ImportSourceType_GCS ImportSourceType_Enum = 3
	// Indicates that the import source is an Azure Blob Storage resource.
	ImportSourceType_AZURE_BLOB ImportSourceType_Enum = 4
)

// Enum value maps for ImportSourceType_Enum.
var (
	ImportSourceType_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		2: "S3",
		3: "GCS",
		4: "AZURE_BLOB",
	}
	ImportSourceType_Enum_value = map[string]int32{
		"UNSPECIFIED": 0,
		"S3":          2,
		"GCS":         3,
		"AZURE_BLOB":  4,
	}
)

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

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

func (ImportSourceType_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[1].Descriptor()
}

func (ImportSourceType_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[1]
}

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

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

// The state of the import.
type ImportState_Enum int32

const (
	// Indicates that the import state is not specified.
	ImportState_UNSPECIFIED ImportState_Enum = 0
	// Indicates that the import is being prepared.
	ImportState_PREPARING ImportState_Enum = 1
	// Indicates that the import is in progress.
	ImportState_IMPORTING ImportState_Enum = 2
	// Indicates that the import is completed successfully.
	ImportState_COMPLETED ImportState_Enum = 3
	// Indicates that the import has failed.
	ImportState_FAILED ImportState_Enum = 4
	// Indicates that the import is in the process of being canceled.
	ImportState_CANCELING ImportState_Enum = 5
	// Indicates that the import has been canceled.
	ImportState_CANCELED ImportState_Enum = 6
)

// Enum value maps for ImportState_Enum.
var (
	ImportState_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "PREPARING",
		2: "IMPORTING",
		3: "COMPLETED",
		4: "FAILED",
		5: "CANCELING",
		6: "CANCELED",
	}
	ImportState_Enum_value = map[string]int32{
		"UNSPECIFIED": 0,
		"PREPARING":   1,
		"IMPORTING":   2,
		"COMPLETED":   3,
		"FAILED":      4,
		"CANCELING":   5,
		"CANCELED":    6,
	}
)

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

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

func (ImportState_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[2].Descriptor()
}

func (ImportState_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[2]
}

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

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

// The type of the file.
type ImportFileType_Enum int32

const (
	// The type of the file is unknown.
	ImportFileType_UNSPECIFIED ImportFileType_Enum = 0
	// CSV type.
	ImportFileType_CSV ImportFileType_Enum = 1
	// SQL type.
	ImportFileType_SQL ImportFileType_Enum = 2
	// Aurora snapshot type.
	ImportFileType_AURORA_SNAPSHOT ImportFileType_Enum = 3
	// Parquet type.
	ImportFileType_PARQUET ImportFileType_Enum = 4
)

// Enum value maps for ImportFileType_Enum.
var (
	ImportFileType_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "CSV",
		2: "SQL",
		3: "AURORA_SNAPSHOT",
		4: "PARQUET",
	}
	ImportFileType_Enum_value = map[string]int32{
		"UNSPECIFIED":     0,
		"CSV":             1,
		"SQL":             2,
		"AURORA_SNAPSHOT": 3,
		"PARQUET":         4,
	}
)

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

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

func (ImportFileType_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[3].Descriptor()
}

func (ImportFileType_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[3]
}

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

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

// The duplication handling for SQL.
type DuplicationHandlingForSQL_Enum int32

const (
	// The duplication handling for SQL is unknown.
	DuplicationHandlingForSQL_UNSPECIFIED DuplicationHandlingForSQL_Enum = 0
	// The duplication handling for SQL is replace.
	DuplicationHandlingForSQL_REPLACE DuplicationHandlingForSQL_Enum = 1
	// The duplication handling for SQL is ignore.
	DuplicationHandlingForSQL_IGNORE DuplicationHandlingForSQL_Enum = 2
	// The duplication handling for SQL is error.
	DuplicationHandlingForSQL_ERROR DuplicationHandlingForSQL_Enum = 3
)

// Enum value maps for DuplicationHandlingForSQL_Enum.
var (
	DuplicationHandlingForSQL_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "REPLACE",
		2: "IGNORE",
		3: "ERROR",
	}
	DuplicationHandlingForSQL_Enum_value = map[string]int32{
		"UNSPECIFIED": 0,
		"REPLACE":     1,
		"IGNORE":      2,
		"ERROR":       3,
	}
)

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

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

func (DuplicationHandlingForSQL_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[4].Descriptor()
}

func (DuplicationHandlingForSQL_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[4]
}

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

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

// The type of the access method.
type ImportS3AuthType_Enum int32

const (
	// The access method is unknown.
	ImportS3AuthType_UNSPECIFIED ImportS3AuthType_Enum = 0
	// The access method is role arn.
	ImportS3AuthType_ROLE_ARN ImportS3AuthType_Enum = 1
	// The access method is access key.
	ImportS3AuthType_ACCESS_KEY ImportS3AuthType_Enum = 2
)

// Enum value maps for ImportS3AuthType_Enum.
var (
	ImportS3AuthType_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "ROLE_ARN",
		2: "ACCESS_KEY",
	}
	ImportS3AuthType_Enum_value = map[string]int32{
		"UNSPECIFIED": 0,
		"ROLE_ARN":    1,
		"ACCESS_KEY":  2,
	}
)

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

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

func (ImportS3AuthType_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[5].Descriptor()
}

func (ImportS3AuthType_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[5]
}

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

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

// The type of the access method.
type ImportGcsAuthType_Enum int32

const (
	// The access method is unknown.
	ImportGcsAuthType_UNSPECIFIED ImportGcsAuthType_Enum = 0
	// The access method is service account key.
	ImportGcsAuthType_SERVICE_ACCOUNT_KEY ImportGcsAuthType_Enum = 1
)

// Enum value maps for ImportGcsAuthType_Enum.
var (
	ImportGcsAuthType_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "SERVICE_ACCOUNT_KEY",
	}
	ImportGcsAuthType_Enum_value = map[string]int32{
		"UNSPECIFIED":         0,
		"SERVICE_ACCOUNT_KEY": 1,
	}
)

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

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

func (ImportGcsAuthType_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[6].Descriptor()
}

func (ImportGcsAuthType_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[6]
}

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

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

// The type of the access method.
type ImportAzureBlobAuthType_Enum int32

const (
	// The access method is unknown.
	ImportAzureBlobAuthType_UNSPECIFIED ImportAzureBlobAuthType_Enum = 0
	// The access method is sas token.
	ImportAzureBlobAuthType_SAS_TOKEN ImportAzureBlobAuthType_Enum = 1
)

// Enum value maps for ImportAzureBlobAuthType_Enum.
var (
	ImportAzureBlobAuthType_Enum_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "SAS_TOKEN",
	}
	ImportAzureBlobAuthType_Enum_value = map[string]int32{
		"UNSPECIFIED": 0,
		"SAS_TOKEN":   1,
	}
)

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

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

func (ImportAzureBlobAuthType_Enum) Descriptor() protoreflect.EnumDescriptor {
	return file_adminapi_v1beta1_import_proto_enumTypes[7].Descriptor()
}

func (ImportAzureBlobAuthType_Enum) Type() protoreflect.EnumType {
	return &file_adminapi_v1beta1_import_proto_enumTypes[7]
}

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

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

// The request message for getting an import.
type GetImportRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ID of the cluster that contains the import task.
	ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	// The ID of the import task to retrieve.
	ImportId      string `protobuf:"bytes,2,opt,name=import_id,json=importId,proto3" json:"import_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetImportRequest) ProtoMessage() {}

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

func (x *GetImportRequest) GetClusterId() string {
	if x != nil {
		return x.ClusterId
	}
	return ""
}

func (x *GetImportRequest) GetImportId() string {
	if x != nil {
		return x.ImportId
	}
	return ""
}

// The format specification for CSV files.
type CSVFormat struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	Separator string                 `protobuf:"bytes,1,opt,name=separator,proto3" json:"separator,omitempty"`
	Delimiter *string                `protobuf:"bytes,2,opt,name=delimiter,proto3,oneof" json:"delimiter,omitempty"`
	Header    *bool                  `protobuf:"varint,3,opt,name=header,proto3,oneof" json:"header,omitempty"`
	NotNull   *bool                  `protobuf:"varint,4,opt,name=not_null,json=notNull,proto3,oneof" json:"not_null,omitempty"`
	NullValue *string                `protobuf:"bytes,5,opt,name=null_value,json=nullValue,proto3,oneof" json:"null_value,omitempty"`
	// Whether to escape backslashes in CSV files. Default is true.
	BackslashEscape   *bool `protobuf:"varint,6,opt,name=backslash_escape,json=backslashEscape,proto3,oneof" json:"backslash_escape,omitempty"`
	TrimLastSeparator *bool `protobuf:"varint,7,opt,name=trim_last_separator,json=trimLastSeparator,proto3,oneof" json:"trim_last_separator,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*CSVFormat) ProtoMessage() {}

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

func (x *CSVFormat) GetSeparator() string {
	if x != nil {
		return x.Separator
	}
	return ""
}

func (x *CSVFormat) GetDelimiter() string {
	if x != nil && x.Delimiter != nil {
		return *x.Delimiter
	}
	return ""
}

func (x *CSVFormat) GetHeader() bool {
	if x != nil && x.Header != nil {
		return *x.Header
	}
	return false
}

func (x *CSVFormat) GetNotNull() bool {
	if x != nil && x.NotNull != nil {
		return *x.NotNull
	}
	return false
}

func (x *CSVFormat) GetNullValue() string {
	if x != nil && x.NullValue != nil {
		return *x.NullValue
	}
	return ""
}

func (x *CSVFormat) GetBackslashEscape() bool {
	if x != nil && x.BackslashEscape != nil {
		return *x.BackslashEscape
	}
	return false
}

func (x *CSVFormat) GetTrimLastSeparator() bool {
	if x != nil && x.TrimLastSeparator != nil {
		return *x.TrimLastSeparator
	}
	return false
}

// The request message for creating an import.
type CreateImportRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ID of the target cluster where data will be imported.
	ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	// (-- api-linter: core::0140::reserved-words=disabled --)
	Import        *Import `protobuf:"bytes,2,opt,name=import,proto3" json:"import,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateImportRequest) ProtoMessage() {}

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

func (x *CreateImportRequest) GetClusterId() string {
	if x != nil {
		return x.ClusterId
	}
	return ""
}

func (x *CreateImportRequest) GetImport() *Import {
	if x != nil {
		return x.Import
	}
	return nil
}

// The details of the import.
type CreationDetails struct {
	state            protoimpl.MessageState   `protogen:"open.v1"`
	ImportOptions    *ImportOptions           `protobuf:"bytes,1,opt,name=import_options,json=importOptions,proto3" json:"import_options,omitempty"`
	Source           *ImportSource            `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	TargetTableInfos []*ImportTargetTableInfo `protobuf:"bytes,3,rep,name=target_table_infos,json=targetTableInfos,proto3" json:"target_table_infos,omitempty"`
	CheckItems       []ImportValidationItem   `protobuf:"varint,4,rep,packed,name=check_items,json=checkItems,proto3,enum=adminapi.v1beta1.ImportValidationItem" json:"check_items,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*CreationDetails) ProtoMessage() {}

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

func (x *CreationDetails) GetImportOptions() *ImportOptions {
	if x != nil {
		return x.ImportOptions
	}
	return nil
}

func (x *CreationDetails) GetSource() *ImportSource {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *CreationDetails) GetTargetTableInfos() []*ImportTargetTableInfo {
	if x != nil {
		return x.TargetTableInfos
	}
	return nil
}

func (x *CreationDetails) GetCheckItems() []ImportValidationItem {
	if x != nil {
		return x.CheckItems
	}
	return nil
}

// The target table info of the import task.
type ImportTargetTableInfo struct {
	state       protoimpl.MessageState `protogen:"open.v1"`
	TargetTable *common.Table          `protobuf:"bytes,1,opt,name=target_table,json=targetTable,proto3" json:"target_table,omitempty"`
	// If the custom_file is empty, will use the default rule to import data.
	CustomFile string `protobuf:"bytes,2,opt,name=custom_file,json=customFile,proto3" json:"custom_file,omitempty"`
	// The actual source file URI that is matched to this table during import processing.
	MatchedUri    string `protobuf:"bytes,3,opt,name=matched_uri,json=matchedUri,proto3" json:"matched_uri,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportTargetTableInfo) ProtoMessage() {}

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

func (x *ImportTargetTableInfo) GetTargetTable() *common.Table {
	if x != nil {
		return x.TargetTable
	}
	return nil
}

func (x *ImportTargetTableInfo) GetCustomFile() string {
	if x != nil {
		return x.CustomFile
	}
	return ""
}

func (x *ImportTargetTableInfo) GetMatchedUri() string {
	if x != nil {
		return x.MatchedUri
	}
	return ""
}

// The options of the import task.
type ImportOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The exported file type.
	FileType ImportFileType_Enum `protobuf:"varint,1,opt,name=file_type,json=fileType,proto3,enum=adminapi.v1beta1.ImportFileType_Enum" json:"file_type,omitempty"`
	// Types that are valid to be assigned to Format:
	//
	//	*ImportOptions_CsvFormat
	Format              isImportOptions_Format         `protobuf_oneof:"format"`
	DuplicationHandling DuplicationHandlingForSQL_Enum `protobuf:"varint,3,opt,name=duplication_handling,json=duplicationHandling,proto3,enum=adminapi.v1beta1.DuplicationHandlingForSQL_Enum" json:"duplication_handling,omitempty"`
	ValidateOnly        bool                           `protobuf:"varint,4,opt,name=validate_only,json=validateOnly,proto3" json:"validate_only,omitempty"`
	SkipChecksum        bool                           `protobuf:"varint,5,opt,name=skip_checksum,json=skipChecksum,proto3" json:"skip_checksum,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*ImportOptions) ProtoMessage() {}

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

func (x *ImportOptions) GetFileType() ImportFileType_Enum {
	if x != nil {
		return x.FileType
	}
	return ImportFileType_UNSPECIFIED
}

func (x *ImportOptions) GetFormat() isImportOptions_Format {
	if x != nil {
		return x.Format
	}
	return nil
}

func (x *ImportOptions) GetCsvFormat() *CSVFormat {
	if x != nil {
		if x, ok := x.Format.(*ImportOptions_CsvFormat); ok {
			return x.CsvFormat
		}
	}
	return nil
}

func (x *ImportOptions) GetDuplicationHandling() DuplicationHandlingForSQL_Enum {
	if x != nil {
		return x.DuplicationHandling
	}
	return DuplicationHandlingForSQL_UNSPECIFIED
}

func (x *ImportOptions) GetValidateOnly() bool {
	if x != nil {
		return x.ValidateOnly
	}
	return false
}

func (x *ImportOptions) GetSkipChecksum() bool {
	if x != nil {
		return x.SkipChecksum
	}
	return false
}

type isImportOptions_Format interface {
	isImportOptions_Format()
}

type ImportOptions_CsvFormat struct {
	CsvFormat *CSVFormat `protobuf:"bytes,2,opt,name=csv_format,json=csvFormat,proto3,oneof"`
}

func (*ImportOptions_CsvFormat) isImportOptions_Format() {}

// The source of the import.
type ImportSource struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Type  ImportSourceType_Enum  `protobuf:"varint,1,opt,name=type,proto3,enum=adminapi.v1beta1.ImportSourceType_Enum" json:"type,omitempty"`
	// Types that are valid to be assigned to Source:
	//
	//	*ImportSource_S3
	//	*ImportSource_Gcs
	//	*ImportSource_AzureBlob
	Source        isImportSource_Source `protobuf_oneof:"source"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportSource) ProtoMessage() {}

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

func (x *ImportSource) GetType() ImportSourceType_Enum {
	if x != nil {
		return x.Type
	}
	return ImportSourceType_UNSPECIFIED
}

func (x *ImportSource) GetSource() isImportSource_Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *ImportSource) GetS3() *S3Source {
	if x != nil {
		if x, ok := x.Source.(*ImportSource_S3); ok {
			return x.S3
		}
	}
	return nil
}

func (x *ImportSource) GetGcs() *GCSSource {
	if x != nil {
		if x, ok := x.Source.(*ImportSource_Gcs); ok {
			return x.Gcs
		}
	}
	return nil
}

func (x *ImportSource) GetAzureBlob() *AzureBlobSource {
	if x != nil {
		if x, ok := x.Source.(*ImportSource_AzureBlob); ok {
			return x.AzureBlob
		}
	}
	return nil
}

type isImportSource_Source interface {
	isImportSource_Source()
}

type ImportSource_S3 struct {
	S3 *S3Source `protobuf:"bytes,3,opt,name=s3,proto3,oneof"`
}

type ImportSource_Gcs struct {
	Gcs *GCSSource `protobuf:"bytes,4,opt,name=gcs,proto3,oneof"`
}

type ImportSource_AzureBlob struct {
	AzureBlob *AzureBlobSource `protobuf:"bytes,5,opt,name=azure_blob,json=azureBlob,proto3,oneof"`
}

func (*ImportSource_S3) isImportSource_Source() {}

func (*ImportSource_Gcs) isImportSource_Source() {}

func (*ImportSource_AzureBlob) isImportSource_Source() {}

// The local source of the import.
type LocalSource struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The upload id of import source file.
	UploadId string `protobuf:"bytes,1,opt,name=upload_id,json=uploadId,proto3" json:"upload_id,omitempty"`
	// The target database of import.
	TargetDatabase string `protobuf:"bytes,2,opt,name=target_database,json=targetDatabase,proto3" json:"target_database,omitempty"`
	// The target table of import.
	TargetTable string `protobuf:"bytes,3,opt,name=target_table,json=targetTable,proto3" json:"target_table,omitempty"`
	// The filename of import source file.
	Filename      string `protobuf:"bytes,4,opt,name=filename,proto3" json:"filename,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalSource) ProtoMessage() {}

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

func (x *LocalSource) GetUploadId() string {
	if x != nil {
		return x.UploadId
	}
	return ""
}

func (x *LocalSource) GetTargetDatabase() string {
	if x != nil {
		return x.TargetDatabase
	}
	return ""
}

func (x *LocalSource) GetTargetTable() string {
	if x != nil {
		return x.TargetTable
	}
	return ""
}

func (x *LocalSource) GetFilename() string {
	if x != nil {
		return x.Filename
	}
	return ""
}

// The S3 source of the import.
type S3Source struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	Uri      string                 `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	AuthType ImportS3AuthType_Enum  `protobuf:"varint,2,opt,name=auth_type,json=authType,proto3,enum=adminapi.v1beta1.ImportS3AuthType_Enum" json:"auth_type,omitempty"`
	// Types that are valid to be assigned to Auth:
	//
	//	*S3Source_RoleArn
	//	*S3Source_AccessKey_
	Auth          isS3Source_Auth `protobuf_oneof:"auth"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*S3Source) ProtoMessage() {}

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

func (x *S3Source) GetUri() string {
	if x != nil {
		return x.Uri
	}
	return ""
}

func (x *S3Source) GetAuthType() ImportS3AuthType_Enum {
	if x != nil {
		return x.AuthType
	}
	return ImportS3AuthType_UNSPECIFIED
}

func (x *S3Source) GetAuth() isS3Source_Auth {
	if x != nil {
		return x.Auth
	}
	return nil
}

func (x *S3Source) GetRoleArn() string {
	if x != nil {
		if x, ok := x.Auth.(*S3Source_RoleArn); ok {
			return x.RoleArn
		}
	}
	return ""
}

func (x *S3Source) GetAccessKey() *S3Source_AccessKey {
	if x != nil {
		if x, ok := x.Auth.(*S3Source_AccessKey_); ok {
			return x.AccessKey
		}
	}
	return nil
}

type isS3Source_Auth interface {
	isS3Source_Auth()
}

type S3Source_RoleArn struct {
	RoleArn string `protobuf:"bytes,3,opt,name=role_arn,json=roleArn,proto3,oneof"`
}

type S3Source_AccessKey_ struct {
	AccessKey *S3Source_AccessKey `protobuf:"bytes,4,opt,name=access_key,json=accessKey,proto3,oneof"`
}

func (*S3Source_RoleArn) isS3Source_Auth() {}

func (*S3Source_AccessKey_) isS3Source_Auth() {}

// The Google Cloud Storage source of the import.
type GCSSource struct {
	state    protoimpl.MessageState `protogen:"open.v1"`
	Uri      string                 `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	AuthType ImportGcsAuthType_Enum `protobuf:"varint,2,opt,name=auth_type,json=authType,proto3,enum=adminapi.v1beta1.ImportGcsAuthType_Enum" json:"auth_type,omitempty"`
	// Types that are valid to be assigned to Auth:
	//
	//	*GCSSource_ServiceAccountKey
	Auth          isGCSSource_Auth `protobuf_oneof:"auth"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GCSSource) ProtoMessage() {}

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

func (x *GCSSource) GetUri() string {
	if x != nil {
		return x.Uri
	}
	return ""
}

func (x *GCSSource) GetAuthType() ImportGcsAuthType_Enum {
	if x != nil {
		return x.AuthType
	}
	return ImportGcsAuthType_UNSPECIFIED
}

func (x *GCSSource) GetAuth() isGCSSource_Auth {
	if x != nil {
		return x.Auth
	}
	return nil
}

func (x *GCSSource) GetServiceAccountKey() string {
	if x != nil {
		if x, ok := x.Auth.(*GCSSource_ServiceAccountKey); ok {
			return x.ServiceAccountKey
		}
	}
	return ""
}

type isGCSSource_Auth interface {
	isGCSSource_Auth()
}

type GCSSource_ServiceAccountKey struct {
	// The service account key
	ServiceAccountKey string `protobuf:"bytes,3,opt,name=service_account_key,json=serviceAccountKey,proto3,oneof"`
}

func (*GCSSource_ServiceAccountKey) isGCSSource_Auth() {}

// The Azure Blob Storage source of the import.
type AzureBlobSource struct {
	state    protoimpl.MessageState       `protogen:"open.v1"`
	AuthType ImportAzureBlobAuthType_Enum `protobuf:"varint,1,opt,name=auth_type,json=authType,proto3,enum=adminapi.v1beta1.ImportAzureBlobAuthType_Enum" json:"auth_type,omitempty"`
	// Types that are valid to be assigned to Auth:
	//
	//	*AzureBlobSource_SasToken
	Auth          isAzureBlobSource_Auth `protobuf_oneof:"auth"`
	Uri           string                 `protobuf:"bytes,3,opt,name=uri,proto3" json:"uri,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AzureBlobSource) ProtoMessage() {}

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

func (x *AzureBlobSource) GetAuthType() ImportAzureBlobAuthType_Enum {
	if x != nil {
		return x.AuthType
	}
	return ImportAzureBlobAuthType_UNSPECIFIED
}

func (x *AzureBlobSource) GetAuth() isAzureBlobSource_Auth {
	if x != nil {
		return x.Auth
	}
	return nil
}

func (x *AzureBlobSource) GetSasToken() string {
	if x != nil {
		if x, ok := x.Auth.(*AzureBlobSource_SasToken); ok {
			return x.SasToken
		}
	}
	return ""
}

func (x *AzureBlobSource) GetUri() string {
	if x != nil {
		return x.Uri
	}
	return ""
}

type isAzureBlobSource_Auth interface {
	isAzureBlobSource_Auth()
}

type AzureBlobSource_SasToken struct {
	SasToken string `protobuf:"bytes,2,opt,name=sas_token,json=sasToken,proto3,oneof"`
}

func (*AzureBlobSource_SasToken) isAzureBlobSource_Auth() {}

type CancelImportRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ID of the cluster that contains the import task.
	ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	// The ID of the import task to cancel.
	ImportId      string `protobuf:"bytes,2,opt,name=import_id,json=importId,proto3" json:"import_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CancelImportRequest) ProtoMessage() {}

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

func (x *CancelImportRequest) GetClusterId() string {
	if x != nil {
		return x.ClusterId
	}
	return ""
}

func (x *CancelImportRequest) GetImportId() string {
	if x != nil {
		return x.ImportId
	}
	return ""
}

// The import.
type Import struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Name            string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	ClusterId       string                 `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	TotalSize       int64                  `protobuf:"varint,4,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
	CreateTime      *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	CompleteTime    *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=complete_time,json=completeTime,proto3,oneof" json:"complete_time,omitempty"`
	State           ImportState_Enum       `protobuf:"varint,7,opt,name=state,proto3,enum=adminapi.v1beta1.ImportState_Enum" json:"state,omitempty"`
	CompletePercent int32                  `protobuf:"varint,8,opt,name=complete_percent,json=completePercent,proto3" json:"complete_percent,omitempty"`
	Message         string                 `protobuf:"bytes,9,opt,name=message,proto3" json:"message,omitempty"`
	Creator         string                 `protobuf:"bytes,10,opt,name=creator,proto3" json:"creator,omitempty"`
	CreationDetails *CreationDetails       `protobuf:"bytes,11,opt,name=creation_details,json=creationDetails,proto3" json:"creation_details,omitempty"`
	ImportId        string                 `protobuf:"bytes,12,opt,name=import_id,json=importId,proto3" json:"import_id,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*Import) ProtoMessage() {}

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

// Deprecated: Use Import.ProtoReflect.Descriptor instead.
func (*Import) Descriptor() ([]byte, []int) {
	return file_adminapi_v1beta1_import_proto_rawDescGZIP(), []int{12}
}

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

func (x *Import) GetClusterId() string {
	if x != nil {
		return x.ClusterId
	}
	return ""
}

func (x *Import) GetTotalSize() int64 {
	if x != nil {
		return x.TotalSize
	}
	return 0
}

func (x *Import) GetCreateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CreateTime
	}
	return nil
}

func (x *Import) GetCompleteTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CompleteTime
	}
	return nil
}

func (x *Import) GetState() ImportState_Enum {
	if x != nil {
		return x.State
	}
	return ImportState_UNSPECIFIED
}

func (x *Import) GetCompletePercent() int32 {
	if x != nil {
		return x.CompletePercent
	}
	return 0
}

func (x *Import) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *Import) GetCreator() string {
	if x != nil {
		return x.Creator
	}
	return ""
}

func (x *Import) GetCreationDetails() *CreationDetails {
	if x != nil {
		return x.CreationDetails
	}
	return nil
}

func (x *Import) GetImportId() string {
	if x != nil {
		return x.ImportId
	}
	return ""
}

// The request message for listing import tasks.
type ListImportsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ID of the cluster to list import tasks from.
	ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	// The pagination token received from a previous [List import tasks](#tag/ImportService/operation/ListImports) request. Use this token to retrieve the next page of results.
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	PageSize  int32  `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// Specifies the sorting order of results. Use a comma-separated list of field names, optionally appending `desc` for descending order. For example, `createTime, name desc`. By default, fields are sorted in ascending order.
	OrderBy       string `protobuf:"bytes,4,opt,name=order_by,json=orderBy,proto3" json:"order_by,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListImportsRequest) ProtoMessage() {}

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

func (x *ListImportsRequest) GetClusterId() string {
	if x != nil {
		return x.ClusterId
	}
	return ""
}

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

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

func (x *ListImportsRequest) GetOrderBy() string {
	if x != nil {
		return x.OrderBy
	}
	return ""
}

// The response message for listing imports.
type ListImportsResponse struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Imports []*Import              `protobuf:"bytes,1,rep,name=imports,proto3" json:"imports,omitempty"`
	// aip:ignore
	TotalSize     int32  `protobuf:"varint,2,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
	NextPageToken string `protobuf:"bytes,3,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListImportsResponse) Reset() {
	*x = ListImportsResponse{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ListImportsResponse) ProtoMessage() {}

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

func (x *ListImportsResponse) GetImports() []*Import {
	if x != nil {
		return x.Imports
	}
	return nil
}

func (x *ListImportsResponse) GetTotalSize() int32 {
	if x != nil {
		return x.TotalSize
	}
	return 0
}

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

// The source type of the import.
type ImportSourceType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportSourceType) Reset() {
	*x = ImportSourceType{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportSourceType) ProtoMessage() {}

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

// The state of the import.
type ImportState struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportState) Reset() {
	*x = ImportState{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportState) ProtoMessage() {}

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

// The file type of the import.
type ImportFileType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportFileType) Reset() {
	*x = ImportFileType{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportFileType) ProtoMessage() {}

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

// The duplication handling for SQL.
type DuplicationHandlingForSQL struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DuplicationHandlingForSQL) Reset() {
	*x = DuplicationHandlingForSQL{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DuplicationHandlingForSQL) ProtoMessage() {}

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

// The S3 auth type of the import.
type ImportS3AuthType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportS3AuthType) Reset() {
	*x = ImportS3AuthType{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportS3AuthType) ProtoMessage() {}

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

// The Google Cloud Storage auth type of the import.
type ImportGcsAuthType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportGcsAuthType) Reset() {
	*x = ImportGcsAuthType{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportGcsAuthType) ProtoMessage() {}

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

// The Azure Blob Storage auth type of the import.
type ImportAzureBlobAuthType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportAzureBlobAuthType) Reset() {
	*x = ImportAzureBlobAuthType{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ImportAzureBlobAuthType) ProtoMessage() {}

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

// The access key of the import source.
type S3Source_AccessKey struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Secret        string                 `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *S3Source_AccessKey) Reset() {
	*x = S3Source_AccessKey{}
	mi := &file_adminapi_v1beta1_import_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*S3Source_AccessKey) ProtoMessage() {}

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

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

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

var File_adminapi_v1beta1_import_proto protoreflect.FileDescriptor

const file_adminapi_v1beta1_import_proto_rawDesc = "" +
	"\n" +
	"\x1dadminapi/v1beta1/import.proto\x12\x10adminapi.v1beta1\x1a\x13common/common.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a.protoc-gen-openapiv2/options/annotations.proto\"\x9a\x01\n" +
	"\x10GetImportRequest\x12C\n" +
	"\n" +
	"cluster_id\x18\x01 \x01(\tB$\xe0A\x02\xfaA\x1e\n" +
	"\x1cdedicated.tidbapi.com/ImportR\tclusterId\x12A\n" +
	"\timport_id\x18\x02 \x01(\tB$\xe0A\x02\xfaA\x1e\n" +
	"\x1cdedicated.tidbapi.com/ImportR\bimportId\"\xbe\a\n" +
	"\tCSVFormat\x12d\n" +
	"\tseparator\x18\x01 \x01(\tBF\x92A@26The character used to separate values in the CSV file.:\x01,J\x03\",\"\xe0A\x01R\tseparator\x12p\n" +
	"\tdelimiter\x18\x02 \x01(\tBM\x92AG2<The character used to enclose string values in the CSV file.:\x01\"J\x04\"\\\"\"\xe0A\x01H\x00R\tdelimiter\x88\x01\x01\x12y\n" +
	"\x06header\x18\x03 \x01(\bB\\\x92AV2HIndicates whether the first row of the CSV file contains column headers.:\x04trueJ\x04true\xe0A\x01H\x01R\x06header\x88\x01\x01\x12p\n" +
	"\bnot_null\x18\x04 \x01(\bBP\x92AJ2:Indicates whether the columns in the CSV file can be NULL.:\x05falseJ\x05false\xe0A\x01H\x02R\anotNull\x88\x01\x01\x12p\n" +
	"\n" +
	"null_value\x18\x05 \x01(\tBL\x92AF29The string representation of NULL values in the CSV file.:\x02\\NJ\x05\"\\\\N\"\xe0A\x01H\x03R\tnullValue\x88\x01\x01\x12|\n" +
	"\x10backslash_escape\x18\x06 \x01(\bBL\x92AF28Indicates whether to escape backslashes in the CSV file.:\x04trueJ\x04true\xe0A\x01H\x04R\x0fbackslashEscape\x88\x01\x01\x12\x99\x01\n" +
	"\x13trim_last_separator\x18\a \x01(\bBd\x92A^2NIndicates whether to remove trailing separators from each row in the CSV file.:\x05falseJ\x05false\xe0A\x01H\x05R\x11trimLastSeparator\x88\x01\x01B\f\n" +
	"\n" +
	"_delimiterB\t\n" +
	"\a_headerB\v\n" +
	"\t_not_nullB\r\n" +
	"\v_null_valueB\x13\n" +
	"\x11_backslash_escapeB\x16\n" +
	"\x14_trim_last_separator\"\xda\x01\n" +
	"\x13CreateImportRequest\x12D\n" +
	"\n" +
	"cluster_id\x18\x01 \x01(\tB%\xe0A\x02\xfaA\x1f\n" +
	"\x1ddedicated.tidbapi.com/ClusterR\tclusterId\x12}\n" +
	"\x06import\x18\x02 \x01(\v2\x18.adminapi.v1beta1.ImportBK\x92AE*\x06Import2;The configuration details of the import task to be created.\xe0A\x02R\x06import\"\x87\x05\n" +
	"\x0fCreationDetails\x12\x8d\x01\n" +
	"\x0eimport_options\x18\x01 \x01(\v2\x1f.adminapi.v1beta1.ImportOptionsBE\x92A?*\rImportOptions2.The configuration options for the import task.\xe0A\x02R\rimportOptions\x12r\n" +
	"\x06source\x18\x02 \x01(\v2\x1e.adminapi.v1beta1.ImportSourceB:\x92A4*\fImportSource2$The data source for the import task.\xe0A\x02R\x06source\x12\xbb\x01\n" +
	"\x12target_table_infos\x18\x03 \x03(\v2'.adminapi.v1beta1.ImportTargetTableInfoBd\x92A^*\x15ImportTargetTableInfo2EA list of destination tables and their configurations for the import.\xe0A\x01R\x10targetTableInfos\x12\xb1\x01\n" +
	"\vcheck_items\x18\x04 \x03(\x0e2&.adminapi.v1beta1.ImportValidationItemBh\x92Ab*\x14ImportValidationItem2FA list of validation items that are checked during the import process.J\x02[]\xe0A\x01R\n" +
	"checkItems\"\xa0\x03\n" +
	"\x15ImportTargetTableInfo\x12m\n" +
	"\ftarget_table\x18\x01 \x01(\v2\r.common.TableB;\x92A5*\x05Table2,The target table where the data is imported.\xe0A\x01R\vtargetTable\x12\xf1\x01\n" +
	"\vcustom_file\x18\x02 \x01(\tB\xcf\x01\x92A\xc8\x012\x9e\x01The custom file URI to import data into the target table. If not specified, TiDB Cloud Dedicated uses the default naming conventions to match files to tables.J%\"s3://mybucket/myfolder/my-data1.csv\"\xe0A\x01R\n" +
	"customFile\x12$\n" +
	"\vmatched_uri\x18\x03 \x01(\tB\x03\xe0A\x01R\n" +
	"matchedUri\"\xe1\n" +
	"\n" +
	"\rImportOptions\x12\xb2\x04\n" +
	"\tfile_type\x18\x01 \x01(\x0e2%.adminapi.v1beta1.ImportFileType.EnumB\xed\x03\x92A\xe6\x032\xdc\x03The format of the file to import.\n" +
	"\n" +
	"- `\"CSV\"`: CSV files. For more information, see [Import CSV Files from Cloud Storage into TiDB Cloud Dedicated](https://docs.pingcap.com/tidbcloud/import-csv-files/).\n" +
	"\n" +
	"- `\"PARQUET\"`: Apache Parquet files. For more information, see [Import Apache Parquet Files from Cloud Storage into TiDB Cloud Dedicated](https://docs.pingcap.com/tidbcloud/import-parquet-files/).\n" +
	"\n" +
	"- `\"SQL\"`: SQL files.\n" +
	"\n" +
	"- `\"AURORA_SNAPSHOT\"`: Amazon Aurora snapshot files.J\x05\"CSV\"\xe0A\x02R\bfileType\x12x\n" +
	"\n" +
	"csv_format\x18\x02 \x01(\v2\x1b.adminapi.v1beta1.CSVFormatB:\x92A4*\tCSVFormat2'The format specification for CSV files.\xe0A\x01H\x00R\tcsvFormat\x12\xa3\x03\n" +
	"\x14duplication_handling\x18\x03 \x01(\x0e20.adminapi.v1beta1.DuplicationHandlingForSQL.EnumB\xbd\x02\x92A\xb6\x022\xa8\x02Specifies how to handle duplicate records when importing SQL files.\n" +
	"\n" +
	"- `\"UNSPECIFIED\"`: the behavior is undefined.\n" +
	"\n" +
	"- `\"REPLACE\"`: existing rows are replaced with new data from the import file.\n" +
	"\n" +
	"- `\"IGNORE\"`: duplicate rows are skipped.\n" +
	"\n" +
	"- `\"ERROR\"`: the import fails if a duplicate row is found.J\t\"REPLACE\"\xe0A\x01R\x13duplicationHandling\x12\x85\x01\n" +
	"\rvalidate_only\x18\x04 \x01(\bB`\x92AZ2QIf set to `true`, the request is validated but not executed. Defaults to `false`.J\x05false\xe0A\x01R\fvalidateOnly\x12i\n" +
	"\rskip_checksum\x18\x05 \x01(\bBD\x92A>25If set to `true`, skip the post-import checksum step.J\x05false\xe0A\x01R\fskipChecksumB\b\n" +
	"\x06format\"\x81\b\n" +
	"\fImportSource\x12\xc6\x03\n" +
	"\x04type\x18\x01 \x01(\x0e2'.adminapi.v1beta1.ImportSourceType.EnumB\x88\x03\x92A\x81\x032\xf8\x02The source from which data is imported.\n" +
	"\n" +
	"When this field is set, the corresponding configuration field must also be provided. For example, if type is `S3`, the `s3` field must be specified.\n" +
	"\n" +
	"- `\"UNSPECIFIED\"`: the import source is not specified.\n" +
	"\n" +
	"- `\"S3\"`: import from Amazon S3.\n" +
	"\n" +
	"- `\"GCS\"`: import from Google Cloud Storage.\n" +
	"\n" +
	"- `\"AZURE_BLOB\"`: import from Azure Blob Storage.J\x04\"S3\"\xe0A\x02R\x04type\x12\x9d\x01\n" +
	"\x02s3\x18\x03 \x01(\v2\x1a.adminapi.v1beta1.S3SourceBo\x92Ai*\bS3Source2]The configuration details for importing from Amazon S3. This is required when `type` is `S3`.\xe0A\x01H\x00R\x02s3\x12\xad\x01\n" +
	"\x03gcs\x18\x04 \x01(\v2\x1b.adminapi.v1beta1.GCSSourceB|\x92Av*\tGCSSource2iThe configuration details for importing from Google Cloud Storage. This is required when `type` is `GCS`.\xe0A\x01H\x00R\x03gcs\x12\xcd\x01\n" +
	"\n" +
	"azure_blob\x18\x05 \x01(\v2!.adminapi.v1beta1.AzureBlobSourceB\x88\x01\x92A\x81\x01*\x0fAzureBlobSource2nThe configuration details for importing from Azure Blob Storage. This is required when `type` is `AZURE_BLOB`.\xe0A\x01H\x00R\tazureBlobB\b\n" +
	"\x06source\"\xa6\x01\n" +
	"\vLocalSource\x12 \n" +
	"\tupload_id\x18\x01 \x01(\tB\x03\xe0A\x02R\buploadId\x12,\n" +
	"\x0ftarget_database\x18\x02 \x01(\tB\x03\xe0A\x02R\x0etargetDatabase\x12&\n" +
	"\ftarget_table\x18\x03 \x01(\tB\x03\xe0A\x02R\vtargetTable\x12\x1f\n" +
	"\bfilename\x18\x04 \x01(\tB\x03\xe0A\x03R\bfilename\"\x82\a\n" +
	"\bS3Source\x12T\n" +
	"\x03uri\x18\x01 \x01(\tBB\x92A<2 The S3 URI of the import source.J\x18\"s3://bucket-name/path/\"\xe0A\x02R\x03uri\x12\x90\x01\n" +
	"\tauth_type\x18\x02 \x01(\x0e2'.adminapi.v1beta1.ImportS3AuthType.EnumBJ\x92AD26The authentication method for accessing the S3 bucket.J\n" +
	"\"ROLE_ARN\"\xe0A\x02R\bauthType\x12\xae\x01\n" +
	"\brole_arn\x18\x03 \x01(\tB\x90\x01\x92A\x89\x012^The AWS IAM role ARN used for access. This is required when `authType` is set to `\"ROLE_ARN\"`.J'\"arn:aws:iam::123456789012:role/MyRole\"\xe0A\x01H\x00R\aroleArn\x12\xc4\x01\n" +
	"\n" +
	"access_key\x18\x04 \x01(\v2$.adminapi.v1beta1.S3Source.AccessKeyB}\x92Aw*\tAccessKey2jThe AWS access key credentials used for access. This is required when `authType` is set to `\"ACCESS_KEY\"`.\xe0A\x01H\x00R\taccessKey\x1a\x8c\x02\n" +
	"\tAccessKey\x12^\n" +
	"\x02id\x18\x01 \x01(\tBN\x92AH2.The access key ID for accessing the S3 source.J\x16\"AKIAIOSFODNN7EXAMPLE\"\xe0A\x02R\x02id\x12\x9e\x01\n" +
	"\x06secret\x18\x02 \x01(\tB\x85\x01\x92A|2jThe secret access key for accessing the S3 source. This field is input-only and not returned in responses.J\x0e\"THESECRETKEY\"\xe0A\x02\xe0A\x04R\x06secretB\x06\n" +
	"\x04auth\"\xaf\x03\n" +
	"\tGCSSource\x12f\n" +
	"\x03uri\x18\x01 \x01(\tBT\x92AN22The Google Cloud Storage URI of the import source.J\x18\"gs://bucket-name/path/\"\xe0A\x02R\x03uri\x12\xae\x01\n" +
	"\tauth_type\x18\x02 \x01(\x0e2(.adminapi.v1beta1.ImportGcsAuthType.EnumBg\x92Aa2HThe authentication method for accessing the Google Cloud Storage source.J\x15\"SERVICE_ACCOUNT_KEY\"\xe0A\x02R\bauthType\x12\x80\x01\n" +
	"\x13service_account_key\x18\x03 \x01(\tBN\x92AH2FThe service account key for accessing the Google Cloud Storage source.\xe0A\x01H\x00R\x11serviceAccountKeyB\x06\n" +
	"\x04auth\"\x8c\x06\n" +
	"\x0fAzureBlobSource\x12\xa8\x01\n" +
	"\tauth_type\x18\x01 \x01(\x0e2..adminapi.v1beta1.ImportAzureBlobAuthType.EnumB[\x92AU2FThe authentication method for accessing the Azure Blob Storage source.J\v\"SAS_TOKEN\"\xe0A\x02R\bauthType\x12\xa7\x02\n" +
	"\tsas_token\x18\x02 \x01(\tB\x87\x02\x92A\x80\x022\x8c\x01The Shared Access Signature (SAS) token for accessing the Azure Blob Storage source. This field is input-only and not returned in responses.Jo\"?sv=2020-08-04&ss=b&srt=sco&sp=rwdlacup&se=2023-10-01T12:00:00Z&st=2023-09-30T12:00:00Z&spr=https&sig=example\"\xe0A\x04H\x00R\bsasToken\x12\x9b\x02\n" +
	"\x03uri\x18\x03 \x01(\tB\x88\x02\x92A\x81\x022\xbf\x01The Azure Blob Storage URI of the import source, in the format of `azure://<account>.blob.core.windows.net/<container>/<path>` or `https://<account>.blob.core.windows.net/<container>/<path>`.J=\"azure://myaccount.blob.core.windows.net/mycontainer/mypath/\"\xe0A\x02R\x03uriB\x06\n" +
	"\x04auth\"\x9d\x01\n" +
	"\x13CancelImportRequest\x12C\n" +
	"\n" +
	"cluster_id\x18\x01 \x01(\tB$\xe0A\x02\xfaA\x1e\n" +
	"\x1cdedicated.tidbapi.com/ImportR\tclusterId\x12A\n" +
	"\timport_id\x18\x02 \x01(\tB$\xe0A\x02\xfaA\x1e\n" +
	"\x1cdedicated.tidbapi.com/ImportR\bimportId\"\xb2\f\n" +
	"\x06Import\x12\x91\x01\n" +
	"\x04name\x18\x02 \x01(\tB}\x92At2ZThe name of the import task, in the format of `clusters/{cluster_id}/imports/{import_id}`.J\x16\"clusters/1/imports/1\"\xe0A\x03\xe0A\bR\x04name\x12X\n" +
	"\n" +
	"cluster_id\x18\x03 \x01(\tB9\x92A32,The ID of the target cluster for the import.J\x03\"1\"\xe0A\x03R\tclusterId\x12^\n" +
	"\n" +
	"total_size\x18\x04 \x01(\x03B?\x92A924The total size of the data to be imported, in bytes.J\x010\xe0A\x03R\ttotalSize\x12\xd0\x01\n" +
	"\vcreate_time\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampB\x92\x01\x92A\x8b\x012qThe timestamp when the import task was created, in the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.J\x16\"2023-10-01T12:00:00Z\"\xe0A\x03R\n" +
	"createTime\x12\xdb\x01\n" +
	"\rcomplete_time\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampB\x94\x01\x92A\x8d\x012sThe timestamp when the import task was completed, in the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.J\x16\"2023-10-01T12:01:00Z\"\xe0A\x03H\x00R\fcompleteTime\x88\x01\x01\x12l\n" +
	"\x05state\x18\a \x01(\x0e2\".adminapi.v1beta1.ImportState.EnumB2\x92A,2\x1dThe state of the import task.J\v\"COMPLETED\"\xe0A\x03R\x05state\x12~\n" +
	"\x10complete_percent\x18\b \x01(\x05BS\x92AM2=The percentage of import progress, excluding post-processing.J\x03100Y\x00\x00\x00\x00\x00\x00Y@\xe0A\x03R\x0fcompletePercent\x12c\n" +
	"\amessage\x18\t \x01(\tBI\x92AC2=An error message if the import task failed. Otherwise, empty.J\x02\"\"\xe0A\x03R\amessage\x12o\n" +
	"\acreator\x18\n" +
	" \x01(\tBU\x92AO29The email address of the user who create the import task.J\x12\"test@example.com\"\xe0A\x03R\acreator\x12\xa3\x01\n" +
	"\x10creation_details\x18\v \x01(\v2!.adminapi.v1beta1.CreationDetailsBU\x92AO*\x0fCreationDetails2<The additional details about how the import task is created.\xe0A\x02R\x0fcreationDetails\x12S\n" +
	"\timport_id\x18\f \x01(\tB6\x92A02)The unique identifier of the import task.J\x03\"1\"\xe0A\x03R\bimportId:X\xeaAU\n" +
	"\x1ddataflow.tidbcloud.com/Import\x12#clusters/{cluster}/imports/{import}*\aimports2\x06importB\x10\n" +
	"\x0e_complete_time\"\xbe\x02\n" +
	"\x12ListImportsRequest\x12C\n" +
	"\n" +
	"cluster_id\x18\x01 \x01(\tB$\xe0A\x02\xfaA\x1e\n" +
	"\x1cdedicated.tidbapi.com/ImportR\tclusterId\x12\"\n" +
	"\n" +
	"page_token\x18\x02 \x01(\tB\x03\xe0A\x01R\tpageToken\x12\x9e\x01\n" +
	"\tpage_size\x18\x03 \x01(\x05B\x80\x01\x92Az2gThe maximum number of import tasks to return. If not specified, at most 10 node specs will be returned.:\x0210J\x0210i\x00\x00\x00\x00\x00\x00\xf0?\xe0A\x01R\bpageSize\x12\x1e\n" +
	"\border_by\x18\x04 \x01(\tB\x03\xe0A\x01R\aorderBy\"\xac\x03\n" +
	"\x13ListImportsResponse\x12]\n" +
	"\aimports\x18\x01 \x03(\v2\x18.adminapi.v1beta1.ImportB)\x92A#*\x06Import2\x19The list of import tasks.\xe0A\x03R\aimports\x12K\n" +
	"\n" +
	"total_size\x18\x02 \x01(\x05B,\x92A&2!The total number of import tasks.J\x011\xe0A\x03R\ttotalSize\x12\xe8\x01\n" +
	"\x0fnext_page_token\x18\x03 \x01(\tB\xbf\x01\x92A\xb8\x012\xa2\x01The token to retrieve the next page of results. Use this value as the `pageToken` parameter in the next request. This field is empty when there are no more pages.J\x11\"next_page_token\"\xe0A\x03R\rnextPageToken\"L\n" +
	"\x10ImportSourceType\"8\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\x06\n" +
	"\x02S3\x10\x02\x12\a\n" +
	"\x03GCS\x10\x03\x12\x0e\n" +
	"\n" +
	"AZURE_BLOB\x10\x04\"|\n" +
	"\vImportState\"m\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\r\n" +
	"\tPREPARING\x10\x01\x12\r\n" +
	"\tIMPORTING\x10\x02\x12\r\n" +
	"\tCOMPLETED\x10\x03\x12\n" +
	"\n" +
	"\x06FAILED\x10\x04\x12\r\n" +
	"\tCANCELING\x10\x05\x12\f\n" +
	"\bCANCELED\x10\x06\"]\n" +
	"\x0eImportFileType\"K\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\a\n" +
	"\x03CSV\x10\x01\x12\a\n" +
	"\x03SQL\x10\x02\x12\x13\n" +
	"\x0fAURORA_SNAPSHOT\x10\x03\x12\v\n" +
	"\aPARQUET\x10\x04\"X\n" +
	"\x19DuplicationHandlingForSQL\";\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\v\n" +
	"\aREPLACE\x10\x01\x12\n" +
	"\n" +
	"\x06IGNORE\x10\x02\x12\t\n" +
	"\x05ERROR\x10\x03\"I\n" +
	"\x10ImportS3AuthType\"5\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\f\n" +
	"\bROLE_ARN\x10\x01\x12\x0e\n" +
	"\n" +
	"ACCESS_KEY\x10\x02\"E\n" +
	"\x11ImportGcsAuthType\"0\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13SERVICE_ACCOUNT_KEY\x10\x01\"A\n" +
	"\x17ImportAzureBlobAuthType\"&\n" +
	"\x04Enum\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\r\n" +
	"\tSAS_TOKEN\x10\x01*\xed\x01\n" +
	"\x14ImportValidationItem\x12&\n" +
	"\"IMPORT_VALIDATION_ITEM_UNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13SOURCE_ACCESS_CHECK\x10\x01\x12\x17\n" +
	"\x13TARGET_ACCESS_CHECK\x10\x02\x12\x19\n" +
	"\x15FILTER_AND_RULE_CHECK\x10\x03\x12\x13\n" +
	"\x0fIMPORT_PRECHECK\x10\x04\x12\x1c\n" +
	"\x18TARGET_TABLE_EMPTY_CHECK\x10\x05\x12\x11\n" +
	"\rESTIMATE_SIZE\x10\x06\x12\x1a\n" +
	"\x16IMPORT_DATA_ONLY_CHECK\x10\a2\xbc\b\n" +
	"\rImportService\x12\xc7\x02\n" +
	"\vListImports\x12$.adminapi.v1beta1.ListImportsRequest\x1a%.adminapi.v1beta1.ListImportsResponse\"\xea\x01\x92A\xb8\x01\n" +
	"\rImportService\x12\x11List import tasks\x1a\x86\x01Lists all import tasks for a cluster. You can use query parameters to control sorting, pagination, and the number of results returned.*\vListImports\x82\xd3\xe4\x93\x02(\x12&/v1beta1/clusters/{cluster_id}/imports\x12\xf6\x01\n" +
	"\fCreateImport\x12%.adminapi.v1beta1.CreateImportRequest\x1a\x18.adminapi.v1beta1.Import\"\xa4\x01\x92Ak\n" +
	"\rImportService\x12\x15Create an import task\x1a5Creates an import task to import data into a cluster.*\fCreateImport\x82\xd3\xe4\x93\x020:\x06import\"&/v1beta1/clusters/{cluster_id}/imports\x12\xef\x01\n" +
	"\tGetImport\x12\".adminapi.v1beta1.GetImportRequest\x1a\x18.adminapi.v1beta1.Import\"\xa3\x01\x92Af\n" +
	"\rImportService\x12\x12Get an import task\x1a6Retrieves details of a specific import task by its ID.*\tGetImport\x82\xd3\xe4\x93\x024\x122/v1beta1/clusters/{cluster_id}/imports/{import_id}\x12\xf5\x01\n" +
	"\fCancelImport\x12%.adminapi.v1beta1.CancelImportRequest\x1a\x16.google.protobuf.Empty\"\xa5\x01\x92A^\n" +
	"\rImportService\x12\x15Cancel an import task\x1a(Cancels a running import task by its ID.*\fCancelImport\x82\xd3\xe4\x93\x02>:\x01*\"9/v1beta1/clusters/{cluster_id}/imports/{import_id}:cancelB\xf3\x01\x92Ah\n" +
	"\x032.0\x12G\n" +
	"\x1dTiDB Cloud Dedicated Open API\x12\x1dTiDB Cloud Dedicated Open API2\av1beta1\x1a\x15dedicated.tidbapi.com*\x01\x02\n" +
	"'com.tidbcloud.dataflow.adminapi.v1beta1B\vImportProtoP\x01ZNgithub.com/tidbcloud/dataflow-service/idl/pbgen/proto/adminapi/v1beta1;v1beta1b\x06proto3"

var (
	file_adminapi_v1beta1_import_proto_rawDescOnce sync.Once
	file_adminapi_v1beta1_import_proto_rawDescData []byte
)

func file_adminapi_v1beta1_import_proto_rawDescGZIP() []byte {
	file_adminapi_v1beta1_import_proto_rawDescOnce.Do(func() {
		file_adminapi_v1beta1_import_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_adminapi_v1beta1_import_proto_rawDesc), len(file_adminapi_v1beta1_import_proto_rawDesc)))
	})
	return file_adminapi_v1beta1_import_proto_rawDescData
}

var file_adminapi_v1beta1_import_proto_enumTypes = make([]protoimpl.EnumInfo, 8)
var file_adminapi_v1beta1_import_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_adminapi_v1beta1_import_proto_goTypes = []any{
	(ImportValidationItem)(0),           // 0: adminapi.v1beta1.ImportValidationItem
	(ImportSourceType_Enum)(0),          // 1: adminapi.v1beta1.ImportSourceType.Enum
	(ImportState_Enum)(0),               // 2: adminapi.v1beta1.ImportState.Enum
	(ImportFileType_Enum)(0),            // 3: adminapi.v1beta1.ImportFileType.Enum
	(DuplicationHandlingForSQL_Enum)(0), // 4: adminapi.v1beta1.DuplicationHandlingForSQL.Enum
	(ImportS3AuthType_Enum)(0),          // 5: adminapi.v1beta1.ImportS3AuthType.Enum
	(ImportGcsAuthType_Enum)(0),         // 6: adminapi.v1beta1.ImportGcsAuthType.Enum
	(ImportAzureBlobAuthType_Enum)(0),   // 7: adminapi.v1beta1.ImportAzureBlobAuthType.Enum
	(*GetImportRequest)(nil),            // 8: adminapi.v1beta1.GetImportRequest
	(*CSVFormat)(nil),                   // 9: adminapi.v1beta1.CSVFormat
	(*CreateImportRequest)(nil),         // 10: adminapi.v1beta1.CreateImportRequest
	(*CreationDetails)(nil),             // 11: adminapi.v1beta1.CreationDetails
	(*ImportTargetTableInfo)(nil),       // 12: adminapi.v1beta1.ImportTargetTableInfo
	(*ImportOptions)(nil),               // 13: adminapi.v1beta1.ImportOptions
	(*ImportSource)(nil),                // 14: adminapi.v1beta1.ImportSource
	(*LocalSource)(nil),                 // 15: adminapi.v1beta1.LocalSource
	(*S3Source)(nil),                    // 16: adminapi.v1beta1.S3Source
	(*GCSSource)(nil),                   // 17: adminapi.v1beta1.GCSSource
	(*AzureBlobSource)(nil),             // 18: adminapi.v1beta1.AzureBlobSource
	(*CancelImportRequest)(nil),         // 19: adminapi.v1beta1.CancelImportRequest
	(*Import)(nil),                      // 20: adminapi.v1beta1.Import
	(*ListImportsRequest)(nil),          // 21: adminapi.v1beta1.ListImportsRequest
	(*ListImportsResponse)(nil),         // 22: adminapi.v1beta1.ListImportsResponse
	(*ImportSourceType)(nil),            // 23: adminapi.v1beta1.ImportSourceType
	(*ImportState)(nil),                 // 24: adminapi.v1beta1.ImportState
	(*ImportFileType)(nil),              // 25: adminapi.v1beta1.ImportFileType
	(*DuplicationHandlingForSQL)(nil),   // 26: adminapi.v1beta1.DuplicationHandlingForSQL
	(*ImportS3AuthType)(nil),            // 27: adminapi.v1beta1.ImportS3AuthType
	(*ImportGcsAuthType)(nil),           // 28: adminapi.v1beta1.ImportGcsAuthType
	(*ImportAzureBlobAuthType)(nil),     // 29: adminapi.v1beta1.ImportAzureBlobAuthType
	(*S3Source_AccessKey)(nil),          // 30: adminapi.v1beta1.S3Source.AccessKey
	(*common.Table)(nil),                // 31: common.Table
	(*timestamppb.Timestamp)(nil),       // 32: google.protobuf.Timestamp
	(*emptypb.Empty)(nil),               // 33: google.protobuf.Empty
}
var file_adminapi_v1beta1_import_proto_depIdxs = []int32{
	20, // 0: adminapi.v1beta1.CreateImportRequest.import:type_name -> adminapi.v1beta1.Import
	13, // 1: adminapi.v1beta1.CreationDetails.import_options:type_name -> adminapi.v1beta1.ImportOptions
	14, // 2: adminapi.v1beta1.CreationDetails.source:type_name -> adminapi.v1beta1.ImportSource
	12, // 3: adminapi.v1beta1.CreationDetails.target_table_infos:type_name -> adminapi.v1beta1.ImportTargetTableInfo
	0,  // 4: adminapi.v1beta1.CreationDetails.check_items:type_name -> adminapi.v1beta1.ImportValidationItem
	31, // 5: adminapi.v1beta1.ImportTargetTableInfo.target_table:type_name -> common.Table
	3,  // 6: adminapi.v1beta1.ImportOptions.file_type:type_name -> adminapi.v1beta1.ImportFileType.Enum
	9,  // 7: adminapi.v1beta1.ImportOptions.csv_format:type_name -> adminapi.v1beta1.CSVFormat
	4,  // 8: adminapi.v1beta1.ImportOptions.duplication_handling:type_name -> adminapi.v1beta1.DuplicationHandlingForSQL.Enum
	1,  // 9: adminapi.v1beta1.ImportSource.type:type_name -> adminapi.v1beta1.ImportSourceType.Enum
	16, // 10: adminapi.v1beta1.ImportSource.s3:type_name -> adminapi.v1beta1.S3Source
	17, // 11: adminapi.v1beta1.ImportSource.gcs:type_name -> adminapi.v1beta1.GCSSource
	18, // 12: adminapi.v1beta1.ImportSource.azure_blob:type_name -> adminapi.v1beta1.AzureBlobSource
	5,  // 13: adminapi.v1beta1.S3Source.auth_type:type_name -> adminapi.v1beta1.ImportS3AuthType.Enum
	30, // 14: adminapi.v1beta1.S3Source.access_key:type_name -> adminapi.v1beta1.S3Source.AccessKey
	6,  // 15: adminapi.v1beta1.GCSSource.auth_type:type_name -> adminapi.v1beta1.ImportGcsAuthType.Enum
	7,  // 16: adminapi.v1beta1.AzureBlobSource.auth_type:type_name -> adminapi.v1beta1.ImportAzureBlobAuthType.Enum
	32, // 17: adminapi.v1beta1.Import.create_time:type_name -> google.protobuf.Timestamp
	32, // 18: adminapi.v1beta1.Import.complete_time:type_name -> google.protobuf.Timestamp
	2,  // 19: adminapi.v1beta1.Import.state:type_name -> adminapi.v1beta1.ImportState.Enum
	11, // 20: adminapi.v1beta1.Import.creation_details:type_name -> adminapi.v1beta1.CreationDetails
	20, // 21: adminapi.v1beta1.ListImportsResponse.imports:type_name -> adminapi.v1beta1.Import
	21, // 22: adminapi.v1beta1.ImportService.ListImports:input_type -> adminapi.v1beta1.ListImportsRequest
	10, // 23: adminapi.v1beta1.ImportService.CreateImport:input_type -> adminapi.v1beta1.CreateImportRequest
	8,  // 24: adminapi.v1beta1.ImportService.GetImport:input_type -> adminapi.v1beta1.GetImportRequest
	19, // 25: adminapi.v1beta1.ImportService.CancelImport:input_type -> adminapi.v1beta1.CancelImportRequest
	22, // 26: adminapi.v1beta1.ImportService.ListImports:output_type -> adminapi.v1beta1.ListImportsResponse
	20, // 27: adminapi.v1beta1.ImportService.CreateImport:output_type -> adminapi.v1beta1.Import
	20, // 28: adminapi.v1beta1.ImportService.GetImport:output_type -> adminapi.v1beta1.Import
	33, // 29: adminapi.v1beta1.ImportService.CancelImport:output_type -> google.protobuf.Empty
	26, // [26:30] is the sub-list for method output_type
	22, // [22:26] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_adminapi_v1beta1_import_proto_init() }
func file_adminapi_v1beta1_import_proto_init() {
	if File_adminapi_v1beta1_import_proto != nil {
		return
	}
	file_adminapi_v1beta1_import_proto_msgTypes[1].OneofWrappers = []any{}
	file_adminapi_v1beta1_import_proto_msgTypes[5].OneofWrappers = []any{
		(*ImportOptions_CsvFormat)(nil),
	}
	file_adminapi_v1beta1_import_proto_msgTypes[6].OneofWrappers = []any{
		(*ImportSource_S3)(nil),
		(*ImportSource_Gcs)(nil),
		(*ImportSource_AzureBlob)(nil),
	}
	file_adminapi_v1beta1_import_proto_msgTypes[8].OneofWrappers = []any{
		(*S3Source_RoleArn)(nil),
		(*S3Source_AccessKey_)(nil),
	}
	file_adminapi_v1beta1_import_proto_msgTypes[9].OneofWrappers = []any{
		(*GCSSource_ServiceAccountKey)(nil),
	}
	file_adminapi_v1beta1_import_proto_msgTypes[10].OneofWrappers = []any{
		(*AzureBlobSource_SasToken)(nil),
	}
	file_adminapi_v1beta1_import_proto_msgTypes[12].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_adminapi_v1beta1_import_proto_rawDesc), len(file_adminapi_v1beta1_import_proto_rawDesc)),
			NumEnums:      8,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_adminapi_v1beta1_import_proto_goTypes,
		DependencyIndexes: file_adminapi_v1beta1_import_proto_depIdxs,
		EnumInfos:         file_adminapi_v1beta1_import_proto_enumTypes,
		MessageInfos:      file_adminapi_v1beta1_import_proto_msgTypes,
	}.Build()
	File_adminapi_v1beta1_import_proto = out.File
	file_adminapi_v1beta1_import_proto_goTypes = nil
	file_adminapi_v1beta1_import_proto_depIdxs = nil
}