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

package dp

import (
	_ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
	_ "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"
	_ "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 ImportSource_ImportSourceType int32

const (
	ImportSource_UNSPECIFIED ImportSource_ImportSourceType = 0
	ImportSource_S3          ImportSource_ImportSourceType = 1
	ImportSource_GCS         ImportSource_ImportSourceType = 2
	ImportSource_LOCAL_FILE  ImportSource_ImportSourceType = 3
	ImportSource_AZBLOB      ImportSource_ImportSourceType = 4
)

// Enum value maps for ImportSource_ImportSourceType.
var (
	ImportSource_ImportSourceType_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "S3",
		2: "GCS",
		3: "LOCAL_FILE",
		4: "AZBLOB",
	}
	ImportSource_ImportSourceType_value = map[string]int32{
		"UNSPECIFIED": 0,
		"S3":          1,
		"GCS":         2,
		"LOCAL_FILE":  3,
		"AZBLOB":      4,
	}
)

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

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

func (ImportSource_ImportSourceType) Descriptor() protoreflect.EnumDescriptor {
	return file_openapi_dp_import_proto_enumTypes[0].Descriptor()
}

func (ImportSource_ImportSourceType) Type() protoreflect.EnumType {
	return &file_openapi_dp_import_proto_enumTypes[0]
}

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

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

type ImportSourceFormat_ImportSourceFormatType int32

const (
	ImportSourceFormat_UNSPECIFIED     ImportSourceFormat_ImportSourceFormatType = 0
	ImportSourceFormat_CSV             ImportSourceFormat_ImportSourceFormatType = 1
	ImportSourceFormat_PARQUET         ImportSourceFormat_ImportSourceFormatType = 2
	ImportSourceFormat_SQL             ImportSourceFormat_ImportSourceFormatType = 3
	ImportSourceFormat_AURORA_SNAPSHOT ImportSourceFormat_ImportSourceFormatType = 4
)

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

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

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

func (ImportSourceFormat_ImportSourceFormatType) Descriptor() protoreflect.EnumDescriptor {
	return file_openapi_dp_import_proto_enumTypes[1].Descriptor()
}

func (ImportSourceFormat_ImportSourceFormatType) Type() protoreflect.EnumType {
	return &file_openapi_dp_import_proto_enumTypes[1]
}

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

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

type ImportStatus_ImportTaskPhase int32

const (
	ImportStatus_UNSPECIFIED ImportStatus_ImportTaskPhase = 0
	ImportStatus_PREPARING   ImportStatus_ImportTaskPhase = 1
	ImportStatus_IMPORTING   ImportStatus_ImportTaskPhase = 2
	ImportStatus_COMPLETED   ImportStatus_ImportTaskPhase = 3
	ImportStatus_FAILED      ImportStatus_ImportTaskPhase = 4
	ImportStatus_CANCELING   ImportStatus_ImportTaskPhase = 5
	ImportStatus_CANCELED    ImportStatus_ImportTaskPhase = 6
)

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

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

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

func (ImportStatus_ImportTaskPhase) Descriptor() protoreflect.EnumDescriptor {
	return file_openapi_dp_import_proto_enumTypes[2].Descriptor()
}

func (ImportStatus_ImportTaskPhase) Type() protoreflect.EnumType {
	return &file_openapi_dp_import_proto_enumTypes[2]
}

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

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

type UpdateImportTaskReq_ImportTaskAction int32

const (
	UpdateImportTaskReq_UNSPECIFIED UpdateImportTaskReq_ImportTaskAction = 0
	UpdateImportTaskReq_CANCEL      UpdateImportTaskReq_ImportTaskAction = 1
)

// Enum value maps for UpdateImportTaskReq_ImportTaskAction.
var (
	UpdateImportTaskReq_ImportTaskAction_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "CANCEL",
	}
	UpdateImportTaskReq_ImportTaskAction_value = map[string]int32{
		"UNSPECIFIED": 0,
		"CANCEL":      1,
	}
)

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

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

func (UpdateImportTaskReq_ImportTaskAction) Descriptor() protoreflect.EnumDescriptor {
	return file_openapi_dp_import_proto_enumTypes[3].Descriptor()
}

func (UpdateImportTaskReq_ImportTaskAction) Type() protoreflect.EnumType {
	return &file_openapi_dp_import_proto_enumTypes[3]
}

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

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

type ImportItem struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Metadata      *ImportMetadata        `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec          *ImportSpec            `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	Status        *ImportStatus          `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportItem) ProtoMessage() {}

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

func (x *ImportItem) GetMetadata() *ImportMetadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *ImportItem) GetSpec() *ImportSpec {
	if x != nil {
		return x.Spec
	}
	return nil
}

func (x *ImportItem) GetStatus() *ImportStatus {
	if x != nil {
		return x.Status
	}
	return nil
}

type ImportMetadata struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Id              uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name            string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	CreateTimestamp int64                  `protobuf:"varint,3,opt,name=create_timestamp,json=createTimestamp,proto3" json:"create_timestamp,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ImportMetadata) ProtoMessage() {}

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

func (x *ImportMetadata) GetId() uint64 {
	if x != nil {
		return x.Id
	}
	return 0
}

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

func (x *ImportMetadata) GetCreateTimestamp() int64 {
	if x != nil {
		return x.CreateTimestamp
	}
	return 0
}

type ImportSpec struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Source        *ImportSource          `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Target        *ImportTarget          `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportSpec) ProtoMessage() {}

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

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

func (x *ImportSpec) GetTarget() *ImportTarget {
	if x != nil {
		return x.Target
	}
	return nil
}

type ImportSource struct {
	state protoimpl.MessageState        `protogen:"open.v1"`
	Type  ImportSource_ImportSourceType `protobuf:"varint,1,opt,name=type,proto3,enum=openapi.ImportSource_ImportSourceType" json:"type,omitempty"`
	Uri   string                        `protobuf:"bytes,2,opt,name=uri,proto3" json:"uri,omitempty"`
	// Types that are valid to be assigned to Access:
	//
	//	*ImportSource_AwsAssumeRoleAccess
	//	*ImportSource_AwsKeyAccess
	//	*ImportSource_AzureTokenAccess
	Access        isImportSource_Access `protobuf_oneof:"access"`
	Format        *ImportSourceFormat   `protobuf:"bytes,5,opt,name=format,proto3" json:"format,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ImportSource) Reset() {
	*x = ImportSource{}
	mi := &file_openapi_dp_import_proto_msgTypes[3]
	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_openapi_dp_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 ImportSource.ProtoReflect.Descriptor instead.
func (*ImportSource) Descriptor() ([]byte, []int) {
	return file_openapi_dp_import_proto_rawDescGZIP(), []int{3}
}

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

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

func (x *ImportSource) GetAccess() isImportSource_Access {
	if x != nil {
		return x.Access
	}
	return nil
}

func (x *ImportSource) GetAwsAssumeRoleAccess() *AwsAssumeRoleAccess {
	if x != nil {
		if x, ok := x.Access.(*ImportSource_AwsAssumeRoleAccess); ok {
			return x.AwsAssumeRoleAccess
		}
	}
	return nil
}

func (x *ImportSource) GetAwsKeyAccess() *AwsKeyAccess {
	if x != nil {
		if x, ok := x.Access.(*ImportSource_AwsKeyAccess); ok {
			return x.AwsKeyAccess
		}
	}
	return nil
}

func (x *ImportSource) GetAzureTokenAccess() *AzureTokenAccess {
	if x != nil {
		if x, ok := x.Access.(*ImportSource_AzureTokenAccess); ok {
			return x.AzureTokenAccess
		}
	}
	return nil
}

func (x *ImportSource) GetFormat() *ImportSourceFormat {
	if x != nil {
		return x.Format
	}
	return nil
}

type isImportSource_Access interface {
	isImportSource_Access()
}

type ImportSource_AwsAssumeRoleAccess struct {
	AwsAssumeRoleAccess *AwsAssumeRoleAccess `protobuf:"bytes,3,opt,name=aws_assume_role_access,json=awsAssumeRoleAccess,proto3,oneof"`
}

type ImportSource_AwsKeyAccess struct {
	AwsKeyAccess *AwsKeyAccess `protobuf:"bytes,4,opt,name=aws_key_access,json=awsKeyAccess,proto3,oneof"`
}

type ImportSource_AzureTokenAccess struct {
	AzureTokenAccess *AzureTokenAccess `protobuf:"bytes,6,opt,name=azure_token_access,json=azureTokenAccess,proto3,oneof"`
}

func (*ImportSource_AwsAssumeRoleAccess) isImportSource_Access() {}

func (*ImportSource_AwsKeyAccess) isImportSource_Access() {}

func (*ImportSource_AzureTokenAccess) isImportSource_Access() {}

type AwsAssumeRoleAccess struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AssumeRole    string                 `protobuf:"bytes,1,opt,name=assume_role,json=assumeRole,proto3" json:"assume_role,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AwsAssumeRoleAccess) ProtoMessage() {}

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

func (x *AwsAssumeRoleAccess) GetAssumeRole() string {
	if x != nil {
		return x.AssumeRole
	}
	return ""
}

type AwsKeyAccess 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"`
	SecretAccessKey string                 `protobuf:"bytes,2,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*AwsKeyAccess) ProtoMessage() {}

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

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

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

type AzureTokenAccess struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SasToken      string                 `protobuf:"bytes,1,opt,name=sas_token,json=sasToken,proto3" json:"sas_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AzureTokenAccess) ProtoMessage() {}

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

func (x *AzureTokenAccess) GetSasToken() string {
	if x != nil {
		return x.SasToken
	}
	return ""
}

type ImportSourceFormat struct {
	state protoimpl.MessageState                    `protogen:"open.v1"`
	Type  ImportSourceFormat_ImportSourceFormatType `protobuf:"varint,1,opt,name=type,proto3,enum=openapi.ImportSourceFormat_ImportSourceFormatType" json:"type,omitempty"`
	// Types that are valid to be assigned to FormatConfig:
	//
	//	*ImportSourceFormat_CsvConfig
	FormatConfig  isImportSourceFormat_FormatConfig `protobuf_oneof:"format_config"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportSourceFormat) ProtoMessage() {}

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

func (x *ImportSourceFormat) GetType() ImportSourceFormat_ImportSourceFormatType {
	if x != nil {
		return x.Type
	}
	return ImportSourceFormat_UNSPECIFIED
}

func (x *ImportSourceFormat) GetFormatConfig() isImportSourceFormat_FormatConfig {
	if x != nil {
		return x.FormatConfig
	}
	return nil
}

func (x *ImportSourceFormat) GetCsvConfig() *ImportSourceCSVConfig {
	if x != nil {
		if x, ok := x.FormatConfig.(*ImportSourceFormat_CsvConfig); ok {
			return x.CsvConfig
		}
	}
	return nil
}

type isImportSourceFormat_FormatConfig interface {
	isImportSourceFormat_FormatConfig()
}

type ImportSourceFormat_CsvConfig struct {
	CsvConfig *ImportSourceCSVConfig `protobuf:"bytes,2,opt,name=csv_config,json=csvConfig,proto3,oneof"`
}

func (*ImportSourceFormat_CsvConfig) isImportSourceFormat_FormatConfig() {}

type ImportSourceCSVConfig struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Delimiter       string                 `protobuf:"bytes,1,opt,name=delimiter,proto3" json:"delimiter,omitempty"`
	Quote           string                 `protobuf:"bytes,2,opt,name=quote,proto3" json:"quote,omitempty"`
	BackslashEscape bool                   `protobuf:"varint,3,opt,name=backslash_escape,json=backslashEscape,proto3" json:"backslash_escape,omitempty"`
	HasHeaderRow    bool                   `protobuf:"varint,4,opt,name=has_header_row,json=hasHeaderRow,proto3" json:"has_header_row,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ImportSourceCSVConfig) ProtoMessage() {}

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

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

func (x *ImportSourceCSVConfig) GetQuote() string {
	if x != nil {
		return x.Quote
	}
	return ""
}

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

func (x *ImportSourceCSVConfig) GetHasHeaderRow() bool {
	if x != nil {
		return x.HasHeaderRow
	}
	return false
}

type ImportTarget struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Tables        []*ImportTargetTable   `protobuf:"bytes,1,rep,name=tables,proto3" json:"tables,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportTarget) ProtoMessage() {}

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

func (x *ImportTarget) GetTables() []*ImportTargetTable {
	if x != nil {
		return x.Tables
	}
	return nil
}

type ImportTargetTable struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	DatabaseName    string                 `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
	TableName       string                 `protobuf:"bytes,2,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	FileNamePattern string                 `protobuf:"bytes,3,opt,name=file_name_pattern,json=fileNamePattern,proto3" json:"file_name_pattern,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*ImportTargetTable) ProtoMessage() {}

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

func (x *ImportTargetTable) GetDatabaseName() string {
	if x != nil {
		return x.DatabaseName
	}
	return ""
}

func (x *ImportTargetTable) GetTableName() string {
	if x != nil {
		return x.TableName
	}
	return ""
}

func (x *ImportTargetTable) GetFileNamePattern() string {
	if x != nil {
		return x.FileNamePattern
	}
	return ""
}

type ImportStatus struct {
	state                protoimpl.MessageState       `protogen:"open.v1"`
	Phase                ImportStatus_ImportTaskPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=openapi.ImportStatus_ImportTaskPhase" json:"phase,omitempty"`
	ErrorMessage         string                       `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	StartTimestamp       int64                        `protobuf:"varint,3,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
	EndTimestamp         int64                        `protobuf:"varint,4,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"`
	Progress             *ImportProgress              `protobuf:"bytes,5,opt,name=progress,proto3" json:"progress,omitempty"`
	SourceTotalSizeBytes uint64                       `protobuf:"varint,6,opt,name=source_total_size_bytes,json=sourceTotalSizeBytes,proto3" json:"source_total_size_bytes,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*ImportStatus) ProtoMessage() {}

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

func (x *ImportStatus) GetPhase() ImportStatus_ImportTaskPhase {
	if x != nil {
		return x.Phase
	}
	return ImportStatus_UNSPECIFIED
}

func (x *ImportStatus) GetErrorMessage() string {
	if x != nil {
		return x.ErrorMessage
	}
	return ""
}

func (x *ImportStatus) GetStartTimestamp() int64 {
	if x != nil {
		return x.StartTimestamp
	}
	return 0
}

func (x *ImportStatus) GetEndTimestamp() int64 {
	if x != nil {
		return x.EndTimestamp
	}
	return 0
}

func (x *ImportStatus) GetProgress() *ImportProgress {
	if x != nil {
		return x.Progress
	}
	return nil
}

func (x *ImportStatus) GetSourceTotalSizeBytes() uint64 {
	if x != nil {
		return x.SourceTotalSizeBytes
	}
	return 0
}

type ImportProgress struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	ImportProgress     float64                `protobuf:"fixed64,1,opt,name=import_progress,json=importProgress,proto3" json:"import_progress,omitempty"`
	ValidationProgress float64                `protobuf:"fixed64,2,opt,name=validation_progress,json=validationProgress,proto3" json:"validation_progress,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*ImportProgress) ProtoMessage() {}

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

func (x *ImportProgress) GetImportProgress() float64 {
	if x != nil {
		return x.ImportProgress
	}
	return 0
}

func (x *ImportProgress) GetValidationProgress() float64 {
	if x != nil {
		return x.ValidationProgress
	}
	return 0
}

type ListImportTasksReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Page          uint32                 `protobuf:"varint,100,opt,name=page,proto3" json:"page,omitempty"`
	PageSize      uint32                 `protobuf:"varint,101,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	ProjectId     uint64                 `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                 `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListImportTasksReq) ProtoMessage() {}

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

func (x *ListImportTasksReq) GetPage() uint32 {
	if x != nil {
		return x.Page
	}
	return 0
}

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

func (x *ListImportTasksReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *ListImportTasksReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

type ListImportTasksResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Items         []*ImportItem          `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Total         uint32                 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListImportTasksResp) ProtoMessage() {}

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

func (x *ListImportTasksResp) GetItems() []*ImportItem {
	if x != nil {
		return x.Items
	}
	return nil
}

func (x *ListImportTasksResp) GetTotal() uint32 {
	if x != nil {
		return x.Total
	}
	return 0
}

type GetImportTaskReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ProjectId     uint64                 `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                 `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ImportId      uint64                 `protobuf:"varint,3,opt,name=import_id,json=importId,proto3" json:"import_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetImportTaskReq) ProtoMessage() {}

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

func (x *GetImportTaskReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *GetImportTaskReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

func (x *GetImportTaskReq) GetImportId() uint64 {
	if x != nil {
		return x.ImportId
	}
	return 0
}

type CreateImportTaskReq struct {
	state         protoimpl.MessageState   `protogen:"open.v1"`
	Name          string                   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ProjectId     uint64                   `protobuf:"varint,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                   `protobuf:"varint,3,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	Spec          *ImportSpec              `protobuf:"bytes,4,opt,name=spec,proto3" json:"spec,omitempty"`
	Options       *CreateImportTaskOptions `protobuf:"bytes,5,opt,name=options,proto3" json:"options,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateImportTaskReq) ProtoMessage() {}

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

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

func (x *CreateImportTaskReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *CreateImportTaskReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

func (x *CreateImportTaskReq) GetSpec() *ImportSpec {
	if x != nil {
		return x.Spec
	}
	return nil
}

func (x *CreateImportTaskReq) GetOptions() *CreateImportTaskOptions {
	if x != nil {
		return x.Options
	}
	return nil
}

type CreateImportTaskOptions struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	PreCreateTables []*TableDefinition     `protobuf:"bytes,1,rep,name=pre_create_tables,json=preCreateTables,proto3" json:"pre_create_tables,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*CreateImportTaskOptions) ProtoMessage() {}

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

func (x *CreateImportTaskOptions) GetPreCreateTables() []*TableDefinition {
	if x != nil {
		return x.PreCreateTables
	}
	return nil
}

type TableDefinition struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DatabaseName  string                 `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
	TableName     string                 `protobuf:"bytes,2,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	Schema        *TableSchema           `protobuf:"bytes,3,opt,name=schema,proto3" json:"schema,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TableDefinition) ProtoMessage() {}

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

func (x *TableDefinition) GetDatabaseName() string {
	if x != nil {
		return x.DatabaseName
	}
	return ""
}

func (x *TableDefinition) GetTableName() string {
	if x != nil {
		return x.TableName
	}
	return ""
}

func (x *TableDefinition) GetSchema() *TableSchema {
	if x != nil {
		return x.Schema
	}
	return nil
}

type CreateImportTaskResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            uint64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateImportTaskResp) ProtoMessage() {}

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

func (x *CreateImportTaskResp) GetId() uint64 {
	if x != nil {
		return x.Id
	}
	return 0
}

type GetImportTaskRoleInfoReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ProjectId     uint64                 `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                 `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetImportTaskRoleInfoReq) ProtoMessage() {}

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

func (x *GetImportTaskRoleInfoReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *GetImportTaskRoleInfoReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

type ImportTaskRoleInfo struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to RoleInfo:
	//
	//	*ImportTaskRoleInfo_AwsImportRole
	//	*ImportTaskRoleInfo_GcpImportRole
	RoleInfo      isImportTaskRoleInfo_RoleInfo `protobuf_oneof:"role_info"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ImportTaskRoleInfo) ProtoMessage() {}

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

func (x *ImportTaskRoleInfo) GetRoleInfo() isImportTaskRoleInfo_RoleInfo {
	if x != nil {
		return x.RoleInfo
	}
	return nil
}

func (x *ImportTaskRoleInfo) GetAwsImportRole() *AwsImportTaskRoleInfo {
	if x != nil {
		if x, ok := x.RoleInfo.(*ImportTaskRoleInfo_AwsImportRole); ok {
			return x.AwsImportRole
		}
	}
	return nil
}

func (x *ImportTaskRoleInfo) GetGcpImportRole() *GcpImportTaskRoleInfo {
	if x != nil {
		if x, ok := x.RoleInfo.(*ImportTaskRoleInfo_GcpImportRole); ok {
			return x.GcpImportRole
		}
	}
	return nil
}

type isImportTaskRoleInfo_RoleInfo interface {
	isImportTaskRoleInfo_RoleInfo()
}

type ImportTaskRoleInfo_AwsImportRole struct {
	AwsImportRole *AwsImportTaskRoleInfo `protobuf:"bytes,1,opt,name=aws_import_role,json=awsImportRole,proto3,oneof"`
}

type ImportTaskRoleInfo_GcpImportRole struct {
	GcpImportRole *GcpImportTaskRoleInfo `protobuf:"bytes,2,opt,name=gcp_import_role,json=gcpImportRole,proto3,oneof"`
}

func (*ImportTaskRoleInfo_AwsImportRole) isImportTaskRoleInfo_RoleInfo() {}

func (*ImportTaskRoleInfo_GcpImportRole) isImportTaskRoleInfo_RoleInfo() {}

type AwsImportTaskRoleInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AccountId     string                 `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	ExternalId    string                 `protobuf:"bytes,2,opt,name=external_id,json=externalId,proto3" json:"external_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AwsImportTaskRoleInfo) ProtoMessage() {}

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

func (x *AwsImportTaskRoleInfo) GetAccountId() string {
	if x != nil {
		return x.AccountId
	}
	return ""
}

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

type GcpImportTaskRoleInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AccountId     string                 `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GcpImportTaskRoleInfo) Reset() {
	*x = GcpImportTaskRoleInfo{}
	mi := &file_openapi_dp_import_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GcpImportTaskRoleInfo) ProtoMessage() {}

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

func (x *GcpImportTaskRoleInfo) GetAccountId() string {
	if x != nil {
		return x.AccountId
	}
	return ""
}

type UpdateImportTaskReq struct {
	state         protoimpl.MessageState               `protogen:"open.v1"`
	ProjectId     uint64                               `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                               `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ImportId      uint64                               `protobuf:"varint,3,opt,name=import_id,json=importId,proto3" json:"import_id,omitempty"`
	Action        UpdateImportTaskReq_ImportTaskAction `protobuf:"varint,4,opt,name=action,proto3,enum=openapi.UpdateImportTaskReq_ImportTaskAction" json:"action,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpdateImportTaskReq) Reset() {
	*x = UpdateImportTaskReq{}
	mi := &file_openapi_dp_import_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UpdateImportTaskReq) ProtoMessage() {}

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

func (x *UpdateImportTaskReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *UpdateImportTaskReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

func (x *UpdateImportTaskReq) GetImportId() uint64 {
	if x != nil {
		return x.ImportId
	}
	return 0
}

func (x *UpdateImportTaskReq) GetAction() UpdateImportTaskReq_ImportTaskAction {
	if x != nil {
		return x.Action
	}
	return UpdateImportTaskReq_UNSPECIFIED
}

type UploadLocalFileReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ProjectId     uint64                 `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId     uint64                 `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	LocalFileName string                 `protobuf:"bytes,3,opt,name=local_file_name,json=localFileName,proto3" json:"local_file_name,omitempty"`
	Payload       *LocalFilePayload      `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UploadLocalFileReq) Reset() {
	*x = UploadLocalFileReq{}
	mi := &file_openapi_dp_import_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UploadLocalFileReq) ProtoMessage() {}

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

func (x *UploadLocalFileReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *UploadLocalFileReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

func (x *UploadLocalFileReq) GetLocalFileName() string {
	if x != nil {
		return x.LocalFileName
	}
	return ""
}

func (x *UploadLocalFileReq) GetPayload() *LocalFilePayload {
	if x != nil {
		return x.Payload
	}
	return nil
}

type LocalFilePayload struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	TotalSizeBytes uint64                 `protobuf:"varint,1,opt,name=total_size_bytes,json=totalSizeBytes,proto3" json:"total_size_bytes,omitempty"`
	Content        []byte                 `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *LocalFilePayload) Reset() {
	*x = LocalFilePayload{}
	mi := &file_openapi_dp_import_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*LocalFilePayload) ProtoMessage() {}

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

func (x *LocalFilePayload) GetTotalSizeBytes() uint64 {
	if x != nil {
		return x.TotalSizeBytes
	}
	return 0
}

func (x *LocalFilePayload) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

type UploadLocalFileResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	UploadStubId  uint64                 `protobuf:"varint,1,opt,name=upload_stub_id,json=uploadStubId,proto3" json:"upload_stub_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UploadLocalFileResp) Reset() {
	*x = UploadLocalFileResp{}
	mi := &file_openapi_dp_import_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UploadLocalFileResp) ProtoMessage() {}

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

func (x *UploadLocalFileResp) GetUploadStubId() uint64 {
	if x != nil {
		return x.UploadStubId
	}
	return 0
}

type PreviewImportDataReq struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	ProjectId      uint64                 `protobuf:"varint,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	ClusterId      uint64                 `protobuf:"varint,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	Spec           *ImportSpec            `protobuf:"bytes,3,opt,name=spec,proto3" json:"spec,omitempty"`
	LimitRowsCount *uint32                `protobuf:"varint,4,opt,name=limit_rows_count,json=limitRowsCount,proto3,oneof" json:"limit_rows_count,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *PreviewImportDataReq) Reset() {
	*x = PreviewImportDataReq{}
	mi := &file_openapi_dp_import_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PreviewImportDataReq) ProtoMessage() {}

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

func (x *PreviewImportDataReq) GetProjectId() uint64 {
	if x != nil {
		return x.ProjectId
	}
	return 0
}

func (x *PreviewImportDataReq) GetClusterId() uint64 {
	if x != nil {
		return x.ClusterId
	}
	return 0
}

func (x *PreviewImportDataReq) GetSpec() *ImportSpec {
	if x != nil {
		return x.Spec
	}
	return nil
}

func (x *PreviewImportDataReq) GetLimitRowsCount() uint32 {
	if x != nil && x.LimitRowsCount != nil {
		return *x.LimitRowsCount
	}
	return 0
}

type PreviewImportDataResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TablePreviews []*TablePreview        `protobuf:"bytes,1,rep,name=table_previews,json=tablePreviews,proto3" json:"table_previews,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PreviewImportDataResp) Reset() {
	*x = PreviewImportDataResp{}
	mi := &file_openapi_dp_import_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PreviewImportDataResp) ProtoMessage() {}

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

func (x *PreviewImportDataResp) GetTablePreviews() []*TablePreview {
	if x != nil {
		return x.TablePreviews
	}
	return nil
}

type TablePreview struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	DatabaseName  string                 `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
	TableName     string                 `protobuf:"bytes,2,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	SchemaPreview *TableSchema           `protobuf:"bytes,3,opt,name=schema_preview,json=schemaPreview,proto3" json:"schema_preview,omitempty"`
	DataPreview   *TableData             `protobuf:"bytes,4,opt,name=data_preview,json=dataPreview,proto3" json:"data_preview,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TablePreview) Reset() {
	*x = TablePreview{}
	mi := &file_openapi_dp_import_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TablePreview) ProtoMessage() {}

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

func (x *TablePreview) GetDatabaseName() string {
	if x != nil {
		return x.DatabaseName
	}
	return ""
}

func (x *TablePreview) GetTableName() string {
	if x != nil {
		return x.TableName
	}
	return ""
}

func (x *TablePreview) GetSchemaPreview() *TableSchema {
	if x != nil {
		return x.SchemaPreview
	}
	return nil
}

func (x *TablePreview) GetDataPreview() *TableData {
	if x != nil {
		return x.DataPreview
	}
	return nil
}

type TableSchema struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	ColumnDefinitions []*ColumnDefinition    `protobuf:"bytes,1,rep,name=column_definitions,json=columnDefinitions,proto3" json:"column_definitions,omitempty"`
	PrimaryKeyColumns []string               `protobuf:"bytes,2,rep,name=primary_key_columns,json=primaryKeyColumns,proto3" json:"primary_key_columns,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *TableSchema) Reset() {
	*x = TableSchema{}
	mi := &file_openapi_dp_import_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TableSchema) ProtoMessage() {}

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

func (x *TableSchema) GetColumnDefinitions() []*ColumnDefinition {
	if x != nil {
		return x.ColumnDefinitions
	}
	return nil
}

func (x *TableSchema) GetPrimaryKeyColumns() []string {
	if x != nil {
		return x.PrimaryKeyColumns
	}
	return nil
}

type ColumnDefinition struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ColumnName    string                 `protobuf:"bytes,1,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"`
	ColumnType    string                 `protobuf:"bytes,2,opt,name=column_type,json=columnType,proto3" json:"column_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ColumnDefinition) Reset() {
	*x = ColumnDefinition{}
	mi := &file_openapi_dp_import_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ColumnDefinition) ProtoMessage() {}

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

func (x *ColumnDefinition) GetColumnName() string {
	if x != nil {
		return x.ColumnName
	}
	return ""
}

func (x *ColumnDefinition) GetColumnType() string {
	if x != nil {
		return x.ColumnType
	}
	return ""
}

type TableData struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ColumnNames   []string               `protobuf:"bytes,1,rep,name=column_names,json=columnNames,proto3" json:"column_names,omitempty"`
	Rows          []*TableDataRow        `protobuf:"bytes,2,rep,name=rows,proto3" json:"rows,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TableData) Reset() {
	*x = TableData{}
	mi := &file_openapi_dp_import_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TableData) ProtoMessage() {}

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

func (x *TableData) GetColumnNames() []string {
	if x != nil {
		return x.ColumnNames
	}
	return nil
}

func (x *TableData) GetRows() []*TableDataRow {
	if x != nil {
		return x.Rows
	}
	return nil
}

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

func (x *TableDataRow) Reset() {
	*x = TableDataRow{}
	mi := &file_openapi_dp_import_proto_msgTypes[34]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TableDataRow) ProtoMessage() {}

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

func (x *TableDataRow) GetColumns() []string {
	if x != nil {
		return x.Columns
	}
	return nil
}

var File_openapi_dp_import_proto protoreflect.FileDescriptor

const file_openapi_dp_import_proto_rawDesc = "" +
	"\n" +
	"\x17openapi/dp/import.proto\x12\aopenapi\x1a\x1cgoogle/api/annotations.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a.protoc-gen-openapiv2/options/annotations.proto\"\xe4\x02\n" +
	"\n" +
	"ImportItem\x12Z\n" +
	"\bmetadata\x18\x01 \x01(\v2\x17.openapi.ImportMetadataB%\x92A\"2 The metadata of the import task.R\bmetadata\x12S\n" +
	"\x04spec\x18\x02 \x01(\v2\x13.openapi.ImportSpecB*\x92A'2%The specification of the import task.R\x04spec\x12R\n" +
	"\x06status\x18\x03 \x01(\v2\x15.openapi.ImportStatusB#\x92A 2\x1eThe status of the import task.R\x06status:Q\x92AN\n" +
	"L*\n" +
	"ImportItem2>ImportItem represents the information of a single import task.\"\x97\x03\n" +
	"\x0eImportMetadata\x124\n" +
	"\x02id\x18\x01 \x01(\x04B$\x92A!2\x1aThe ID of the import task.J\x03\"1\"R\x02id\x12B\n" +
	"\x04name\x18\x02 \x01(\tB.\x92A+2\x1cThe name of the import task.J\v\"my_import\"R\x04name\x12\x96\x01\n" +
	"\x10create_timestamp\x18\x03 \x01(\x03Bk\x92Ah2LThe creation time of the import task in Unix timestamp seconds (epoch time).J\f\"1676450597\"\xa2\x02\ttimestampR\x0fcreateTimestamp:r\x92Ao\n" +
	"m*\x0eImportMetadata2CImportMetadata represents some basic metadata about an import task.\xd2\x01\x02id\xd2\x01\x10create_timestamp\"\xba\x02\n" +
	"\n" +
	"ImportSpec\x12`\n" +
	"\x06source\x18\x01 \x01(\v2\x15.openapi.ImportSourceB1\x92A.2,The data source settings of the import task.R\x06source\x12[\n" +
	"\x06target\x18\x02 \x01(\v2\x15.openapi.ImportTargetB,\x92A)2'The target settings of the import task.R\x06target:m\x92Aj\n" +
	"h*\n" +
	"ImportSpec2HImportSpec represents the settings and specifications of an import task.\xd2\x01\x06source\xd2\x01\x06target\"\xcf\x17\n" +
	"\fImportSource\x12\x80\b\n" +
	"\x04type\x18\x01 \x01(\x0e2&.openapi.ImportSource.ImportSourceTypeB\xc3\a\x92A\xbf\a2\xb6\aThe data source type of an import task.\n" +
	"\n" +
	"- `\"S3\"`: import data from Amazon S3\n" +
	"- `\"GCS\"`: import data from Google Cloud Storage (only available for [TiDB Cloud Dedicated](https://docs.pingcap.com/tidbcloud/select-cluster-tier#tidb-cloud-dedicated) clusters)\n" +
	"- `\"AZBLOB\"`: import data from Azure Blob Storage (only available for [TiDB Cloud Dedicated](https://docs.pingcap.com/tidbcloud/select-cluster-tier#tidb-cloud-dedicated) clusters)\n" +
	"- `\"LOCAL_FILE\"`: import data from a local file (only available for [TiDB Cloud Starter](https://docs.pingcap.com/tidbcloud/select-cluster-tier/#tidb-cloud-serverless) clusters). Before you import from a local file, you need to first upload the file using the [Upload a local file for an import task](#tag/Import/operation/UploadLocalFile) endpoint.\n" +
	"\n" +
	"**Note:** Currently, if this import spec is used for a [preview](#tag/Import/operation/PreviewImportData) request, only the `LOCAL_FILE` source type is supported.J\x04\"S3\"R\x04type\x12\x85\x05\n" +
	"\x03uri\x18\x02 \x01(\tB\xf2\x04\x92A\xee\x042\xbf\x04The data source URI of an import task. The URI scheme must match the data source type. Here are the scheme of each source type:\n" +
	"* `S3`: `s3://`\n" +
	"* `GCS`: `gs://`\n" +
	"* `LOCAL_FILE`: `file://`.\n" +
	"\n" +
	"**Note:** If the import source type is `LOCAL_FILE`, just provide the `upload_stub_id` of the uploaded file from the response of [Upload a local file for an import task](#tag/Import/operation/UploadLocalFile), and make it as the data source folder. For example: `file://12345/`.\n" +
	"\n" +
	"**Limitation**: If the import source type is `LOCAL_FILE`, only the `CSV` source format type is supported.J*\"s3://example-bucket/example-source-data/\"R\x03uri\x12\x9e\x03\n" +
	"\x16aws_assume_role_access\x18\x03 \x01(\v2\x1c.openapi.AwsAssumeRoleAccessB\xc8\x02\x92A\xc4\x022\xc1\x02The settings to access the S3 data by assuming a specific AWS role. This field is only needed if you need to access S3 data by assuming an AWS role.\n" +
	"\n" +
	"**Note:** Provide only one of `aws_assume_role_access` and `aws_key_access`. If both `aws_assume_role_access` and `aws_key_access` are provided, an error will be reported.H\x00R\x13awsAssumeRoleAccess\x12\xfa\x02\n" +
	"\x0eaws_key_access\x18\x04 \x01(\v2\x15.openapi.AwsKeyAccessB\xba\x02\x92A\xb6\x022\xb3\x02The settings to access the S3 data with an access key. This field is only needed if you want to access the S3 data with an access key.\n" +
	"\n" +
	"**Note:** Provide only one of `aws_assume_role_access` and `aws_key_access`. If both `aws_assume_role_access` and `aws_key_access` are provided, an error will be reported.H\x00R\fawsKeyAccess\x12\xdf\x01\n" +
	"\x12azure_token_access\x18\x06 \x01(\v2\x19.openapi.AzureTokenAccessB\x93\x01\x92A\x8f\x012\x8c\x01The settings to access the Azblob data with an sas token. This field is only needed if you want to access the Azblob data with an sas token.H\x00R\x10azureTokenAccess\x12h\n" +
	"\x06format\x18\x05 \x01(\v2\x1b.openapi.ImportSourceFormatB3\x92A02.The format settings of the import data source.R\x06format\"P\n" +
	"\x10ImportSourceType\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\x06\n" +
	"\x02S3\x10\x01\x12\a\n" +
	"\x03GCS\x10\x02\x12\x0e\n" +
	"\n" +
	"LOCAL_FILE\x10\x03\x12\n" +
	"\n" +
	"\x06AZBLOB\x10\x04:n\x92Ak\n" +
	"i*\fImportSource2CImportSource represents the data source settings of an import task.\xd2\x01\x04type\xd2\x01\x03uri\xd2\x01\x06formatB\b\n" +
	"\x06access\"\xe2\x02\n" +
	"\x13AwsAssumeRoleAccess\x12\xad\x01\n" +
	"\vassume_role\x18\x01 \x01(\tB\x8b\x01\x92A\x87\x012WThe specific AWS role ARN that needs to be assumed to access the Amazon S3 data source.J,\"arn:aws:iam::999999999999:role/sample-role\"R\n" +
	"assumeRole:\x9a\x01\x92A\x96\x01\n" +
	"\x93\x01*\x13AwsAssumeRoleAccess2nAwsAssumeRoleAccess represents the settings to access the Amazon S3 source by assuming to a specific AWS role.\xd2\x01\vassume_role\"\xe4\x04\n" +
	"\fAwsKeyAccess\x12\xd4\x01\n" +
	"\raccess_key_id\x18\x01 \x01(\tB\xaf\x01\x92A\xab\x012\x92\x01The access key ID of the account to access the data. This information will be redacted when it is retrieved to obtain the import task information.J\x14\"YOUR_ACCESS_KEY_ID\"R\vaccessKeyId\x12\xe5\x01\n" +
	"\x11secret_access_key\x18\x02 \x01(\tB\xb8\x01\x92A\xb4\x012\x97\x01The secret access key for the account to access the data. This information will be redacted when it is retrieved to obtain the import task information.J\x18\"YOUR_SECRET_ACCESS_KEY\"R\x0fsecretAccessKey:\x94\x01\x92A\x90\x01\n" +
	"\x8d\x01*\fAwsKeyAccess2YAwsKeyAccess represents the settings to access the Amazon S3 source by using access keys.\xd2\x01\raccess_key_id\xd2\x01\x11secret_access_key\"\xce\x02\n" +
	"\x10AzureTokenAccess\x12\xb5\x01\n" +
	"\tsas_token\x18\x01 \x01(\tB\x97\x01\x92A\x93\x012\x7fThe sas token to access the data. This information will be redacted when it is retrieved to obtain the import task information.J\x10\"YOUR_SAS_TOKEN\"R\bsasToken:\x81\x01\x92A~\n" +
	"|*\x10AzureTokenAccess2\\AzureTokenAccess represents the settings to access the Azure blob source by using sas token.\xd2\x01\tsas_token\"\xc0\x04\n" +
	"\x12ImportSourceFormat\x12x\n" +
	"\x04type\x18\x01 \x01(\x0e22.openapi.ImportSourceFormat.ImportSourceFormatTypeB0\x92A-2$The format type of an import source.J\x05\"CSV\"R\x04type\x12\xb3\x01\n" +
	"\n" +
	"csv_config\x18\x02 \x01(\v2\x1e.openapi.ImportSourceCSVConfigBr\x92Ao2mThe CSV format settings to parse the source CSV files. This field is only needed if the source format is CSV.H\x00R\tcsvConfig\"]\n" +
	"\x16ImportSourceFormatType\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\a\n" +
	"\x03CSV\x10\x01\x12\v\n" +
	"\aPARQUET\x10\x02\x12\a\n" +
	"\x03SQL\x10\x03\x12\x13\n" +
	"\x0fAURORA_SNAPSHOT\x10\x04:\x89\x01\x92A\x85\x01\n" +
	"\x82\x01*\x12ImportSourceFormat2eImportSourceFormat represents the settings for reading and parsing source data in the correct format.\xd2\x01\x04typeB\x0f\n" +
	"\rformat_config\"\xb5\t\n" +
	"\x15ImportSourceCSVConfig\x12f\n" +
	"\tdelimiter\x18\x01 \x01(\tBH\x92AE2@The delimiter character used to separate fields in the CSV data.:\x01,R\tdelimiter\x12U\n" +
	"\x05quote\x18\x02 \x01(\tB?\x92A<27The character used to quote the fields in the CSV data.:\x01\"R\x05quote\x12\xdd\x04\n" +
	"\x10backslash_escape\x18\x03 \x01(\bB\xb1\x04\x92A\xad\x042\xa4\x04Whether a backslash (`\\`) symbol followed by a character should be combined as a whole and treated as an escape sequence in a CSV field. For example, if this parameter is set to `true`, `\\n` will be treated as a 'new-line' character. If it is set to `false`, `\\n` will be treated as two separate characters: backslash and `n`.\n" +
	"\n" +
	"Currently, these are several supported escape sequences: `\\0`, `\\b`, `\\n`, `\\r`, `\\t`, and `\\Z`. If the parameter is set to `true`, but the backslash escape sequence is not recognized, the backslash character is ignored.:\x04trueR\x0fbackslashEscape\x12\xfc\x01\n" +
	"\x0ehas_header_row\x18\x04 \x01(\bB\xd5\x01\x92A\xd1\x012\xc8\x01Whether the CSV data has a header row, which is not part of the data. If it is set to `true`, the import task will use the column names in the header row to match the column names in the target table.:\x04trueR\fhasHeaderRow:~\x92A{\n" +
	"y*\x15ImportSourceCSVConfig2`ImportSourceCSVConfig represents the settings for parsing the CSV source data of an import task.\"\xe7\f\n" +
	"\fImportTarget\x12\x81\f\n" +
	"\x06tables\x18\x01 \x03(\v2\x1a.openapi.ImportTargetTableB\xcc\v\x92A\xc8\v2\xc5\vThe settings for each target table that is being imported for the import task. If you leave it empty, the system will scan all the files in the data source using the default file patterns and collect all the tables to import. The files include data files, table schema files, and DB schema files. If you provide a list of tables, only those tables will be imported. For more information about the default file pattern, see [Import CSV Files from Amazon S3 or GCS into TiDB Cloud](https://docs.pingcap.com/tidbcloud/import-csv-files).\n" +
	"\n" +
	"**Limitations:**\n" +
	"* Currently, if you want to use a custom filename pattern, you can only specify one table. If all the tables use the default filename pattern, you can specify more than one target table in `tables`.\n" +
	"* It is recommended that you pre-create the target tables before creating an import task. You can do this either by executing the `CREATE TABLE` statement in the cluster or by specifying the table definition in the table creation options.\n" +
	"* If a target table is not created, the import module tries to find a **TABLE SCHEMA FILE** containing the `CREATE TABLE` statement of the table in the data source folder with the name `${db_name}.${table_name}-schema.sql` (for example, `db01.tbl01-schema.sql`). If this file is found, the `CREATE TABLE` statement is automatically executed if the table doesn't exist before the actual import process starts. If the table is still missing after this pre-create step, an error will occur.R\x06tables:S\x92AP\n" +
	"N*\fImportTarget2>ImportTarget represents the target settings of an import task.\"\xd5\f\n" +
	"\x11ImportTargetTable\x12K\n" +
	"\rdatabase_name\x18\x01 \x01(\tB&\x92A#2\x19The target database name.J\x06\"db01\"R\fdatabaseName\x12E\n" +
	"\n" +
	"table_name\x18\x02 \x01(\tB&\x92A#2\x16The target table name.J\t\"table01\"R\ttableName\x12\xfe\t\n" +
	"\x11file_name_pattern\x18\x03 \x01(\tB\xd1\t\x92A\xcd\t2\xaf\tThe filename pattern used to map the files in the data source to this target table. The pattern should be a simple glob pattern. Here are some examples:\n" +
	"* `my-data?.csv`: all CSV files starting with `my-data` and one character (such as `my-data1.csv` and `my-data2.csv`) will be imported into the same target table.\n" +
	"* `my-data*.csv`: all CSV files starting with `my-data` will be imported into the same target table.\n" +
	"\n" +
	"If no pattern is specified, a default pattern is used. The default pattern will try to find files with this naming convention as the data files for this table: `${db_name}.${table_name}.[numeric_index].${format_suffix}`.\n" +
	"\n" +
	"Here are some examples of filenames that can be matched as data files for the table `db01.table01`: `db01.table01.csv`, `db01.table01.00001.csv`.\n" +
	"\n" +
	"For more information about the custom file pattern and the default pattern, refer to [Import CSV Files from Amazon S3 or GCS into TiDB Cloud](https://docs.pingcap.com/tidbcloud/import-csv-files).\n" +
	"\n" +
	"**Note:** For `LOCAL_FILE` import tasks, use the local file name for this field. The local file name must match the local file name in [Upload a local file for an import task](#tag/Import/operation/UploadLocalFile).J\x19\"data/db01/table01.*.csv\"R\x0ffileNamePattern:\xaa\x01\x92A\xa6\x01\n" +
	"\xa3\x01*\x11ImportTargetTable2qImportTargetTable represents the settings for importing source data into a single target table of an import task.\xd2\x01\rdatabase_name\xd2\x01\n" +
	"table_name\"\xa0\b\n" +
	"\fImportStatus\x12|\n" +
	"\x05phase\x18\x01 \x01(\x0e2%.openapi.ImportStatus.ImportTaskPhaseB?\x92A<2-The current phase that the import task is in.J\v\"IMPORTING\"R\x05phase\x12d\n" +
	"\rerror_message\x18\x02 \x01(\tB?\x92A<2%The error message of the import task.J\x13\"some error occurs\"R\ferrorMessage\x12\xb9\x01\n" +
	"\x0fstart_timestamp\x18\x03 \x01(\x03B\x8f\x01\x92A\x8b\x012oThe start timestamp of the import task. The format is Unix timestamp (the seconds elapsed since the Unix epoch)J\f\"1676450597\"\xa2\x02\ttimestampR\x0estartTimestamp\x12\xb4\x01\n" +
	"\rend_timestamp\x18\x04 \x01(\x03B\x8e\x01\x92A\x8a\x012nThe end timestamp of the import task. The format is Unix timestamp (the seconds elapsed since the Unix epoch).J\f\"1676450897\"\xa2\x02\ttimestampR\fendTimestamp\x12Z\n" +
	"\bprogress\x18\x05 \x01(\v2\x17.openapi.ImportProgressB%\x92A\"2 The progress of the import task.R\bprogress\x12\x8e\x01\n" +
	"\x17source_total_size_bytes\x18\x06 \x01(\x04BW\x92AT2CThe total size of the import task's data source. The unit is bytes.J\r\"10737418240\"R\x14sourceTotalSizeBytes\"x\n" +
	"\x0fImportTaskPhase\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:R\x92AO\n" +
	"M*\fImportStatus25ImportStatus represents the status of an import task.\xd2\x01\x05phase\"\xbe\x03\n" +
	"\x0eImportProgress\x12o\n" +
	"\x0fimport_progress\x18\x01 \x01(\x01BF\x92AC22The overall importing progress of the import task.J\x0459.0Y\x00\x00\x00\x00\x00\x00Y@R\x0eimportProgress\x12\xb2\x01\n" +
	"\x13validation_progress\x18\x02 \x01(\x01B\x80\x01\x92A}2lThe overall validation progress of the import task after the data has been imported into the target cluster.J\x0459.0Y\x00\x00\x00\x00\x00\x00Y@R\x12validationProgress:\x85\x01\x92A\x81\x01\n" +
	"\x7f*\x0eImportProgress2EImportProgress represents the progress information of an import task.\xd2\x01\x0fimport_progress\xd2\x01\x13validation_progress\"\xa3\x05\n" +
	"\x12ListImportTasksReq\x12<\n" +
	"\x04page\x18d \x01(\rB(\x92A%2\x14The number of pages.:\x011J\x011i\x00\x00\x00\x00\x00\x00\xf0?R\x04page\x12O\n" +
	"\tpage_size\x18e \x01(\rB2\x92A/2\x13The size of a page.:\x0210J\x0210Y\x00\x00\x00\x00\x00\x00Y@i\x00\x00\x00\x00\x00\x00\xf0?R\bpageSize\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xc3\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\xa3\x01\x92A\x9f\x012\x97\x01The ID of your cluster. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).J\x03\"1\"R\tclusterId:}\x92Az\n" +
	"x*\x12ListImportTasksReq2HListImportTasksReq is the request to list the import tasks of a cluster.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\"\xcd\x02\n" +
	"\x13ListImportTasksResp\x12i\n" +
	"\x05items\x18\x01 \x03(\v2\x13.openapi.ImportItemB>\x92A;29The import tasks in the cluster in the request page area.R\x05items\x12O\n" +
	"\x05total\x18\x02 \x01(\rB9\x92A620The total number of import tasks in the cluster.J\x0220R\x05total:z\x92Aw\n" +
	"u*\x13ListImportTasksResp2NListImportTasksResp is the response for listing the import tasks of a cluster.\xd2\x01\x05items\xd2\x01\x05total\"\xe3\x05\n" +
	"\x10GetImportTaskReq\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xc3\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\xa3\x01\x92A\x9f\x012\x97\x01The ID of your cluster. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).J\x03\"2\"R\tclusterId\x12\xbf\x01\n" +
	"\timport_id\x18\x03 \x01(\x04B\xa1\x01\x92A\x9d\x012\x95\x01The ID of your import task. You can get the import ID from the response of [List import tasks for a cluster](#tag/Project/operation/ListImportTasks).J\x03\"3\"R\bimportId:\x8b\x01\x92A\x87\x01\n" +
	"\x84\x01*\x10GetImportTaskReq2JGetImportTaskReq is the request to retrieve an import task from a cluster.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\xd2\x01\timport_id\"\xe9\t\n" +
	"\x13CreateImportTaskReq\x12\xd3\x03\n" +
	"\x04name\x18\x01 \x01(\tB\xbe\x03\x92A\xba\x032\x96\x03The name of an import task. The maximum length of the name is 64 characters.\n" +
	"\n" +
	"It is recommended that you use a unique name, so that you can easily identify the import task when you list all import tasks. If the name is not provided, a default name is generated with an `import_` prefix followed by a time string representing the creation time of the import task. For example, `import_2023-01-01T00:00:30Z`.J\x1d\"import_2023-01-01T00:00:30Z\"x@R\x04name\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x02 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xe8\x01\n" +
	"\n" +
	"cluster_id\x18\x03 \x01(\x04B\xc8\x01\x92A\xc4\x012\xbc\x01The ID of your cluster that you want to start an import job. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).J\x03\"1\"R\tclusterId\x12T\n" +
	"\x04spec\x18\x04 \x01(\v2\x13.openapi.ImportSpecB+\x92A(2&The specifications of the import task.R\x04spec\x12t\n" +
	"\aoptions\x18\x05 \x01(\v2 .openapi.CreateImportTaskOptionsB8\x92A523The additional options for creating an import task.R\aoptions:\x89\x01\x92A\x85\x01\n" +
	"\x82\x01*\x13CreateImportTaskReq2JCreateImportTaskReq is the request to create an import task for a cluster.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\xd2\x01\x04spec\"\x98\x03\n" +
	"\x17CreateImportTaskOptions\x12\x88\x02\n" +
	"\x11pre_create_tables\x18\x01 \x03(\v2\x18.openapi.TableDefinitionB\xc1\x01\x92A\xbd\x012\xba\x01The table definition of pre-created tables.\n" +
	"\n" +
	"**Note**: The name of the pre-created tables should match one of the target tables. Otherwise, the table will be ignored and won't be createdR\x0fpreCreateTables:r\x92Ao\n" +
	"m*\x17CreateImportTaskOptions2RCreateImportTaskOptions is the optional configuration for creating an import task.\"\xa6\x03\n" +
	"\x0fTableDefinition\x12Q\n" +
	"\rdatabase_name\x18\x01 \x01(\tB,\x92A)2\x1fThe database name of the table.J\x06\"db01\"R\fdatabaseName\x12K\n" +
	"\n" +
	"table_name\x18\x02 \x01(\tB,\x92A)2\x1cThe table name of the table.J\t\"table01\"R\ttableName\x12L\n" +
	"\x06schema\x18\x03 \x01(\v2\x14.openapi.TableSchemaB\x1e\x92A\x1b2\x19The schema for the table.R\x06schema:\xa4\x01\x92A\xa0\x01\n" +
	"\x9d\x01*\x0fTableDefinition2dTableDefinition is the definition of a table so that the table can be created with this information.\xd2\x01\rdatabase_name\xd2\x01\n" +
	"table_name\xd2\x01\x06schema\"\xbb\x01\n" +
	"\x14CreateImportTaskResp\x128\n" +
	"\x02id\x18\x01 \x01(\x04B(\x92A%2\x1aThe ID of the import task.J\a\"12345\"R\x02id:i\x92Af\n" +
	"d*\x14CreateImportTaskResp2GCreateImportTaskResp is the response to the creation of an import task.\xd2\x01\x02id\"\xa3\x05\n" +
	"\x18GetImportTaskRoleInfoReq\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xc3\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\xa3\x01\x92A\x9f\x012\x97\x01The ID of your cluster. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).J\x03\"1\"R\tclusterId:\x85\x02\x92A\x81\x02\n" +
	"\xfe\x01*\x18GetImportTaskRoleInfoReq2\xc7\x01GetImportTaskRoleInfoReq is the request to get the role information for import tasks on a cluster, so that you can configure the access for the import tasks to retrieve the data from the data source.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\"\xf5\x05\n" +
	"\x12ImportTaskRoleInfo\x12\xf8\x01\n" +
	"\x0faws_import_role\x18\x01 \x01(\v2\x1e.openapi.AwsImportTaskRoleInfoB\xad\x01\x92A\xa9\x012\xa6\x01The import role information for an AWS cluster. Only TiDB clusters on AWS return this information. If the TiDB cluster is deployed on GCP, this field is not returned.H\x00R\rawsImportRole\x12\xf7\x01\n" +
	"\x0fgcp_import_role\x18\x02 \x01(\v2\x1e.openapi.GcpImportTaskRoleInfoB\xac\x01\x92A\xa8\x012\xa5\x01The import role information for a GCP cluster. Only TiDB clusters on GCP return this information. If the TiDB cluster is deployed on AWS, this field is not returned.H\x00R\rgcpImportRole:\xdc\x01\x92A\xd8\x01\n" +
	"\xd5\x01*\x12ImportTaskRoleInfo2\xbe\x01ImportTaskRoleInfo is the role information for import tasks on a cluster. You can use this information to configure the access for the import tasks to retrieve the data from the data source.B\v\n" +
	"\trole_info\"\xa4\x06\n" +
	"\x15AwsImportTaskRoleInfo\x12}\n" +
	"\n" +
	"account_id\x18\x01 \x01(\tB^\x92A[2IThe account ID under which the import tasks for this cluster are running.J\x0e\"999999999999\"R\taccountId\x12\xfc\x03\n" +
	"\vexternal_id\x18\x02 \x01(\tB\xda\x03\x92A\xd6\x032\x9d\x03The unique external ID that binds to the cluster, which is a long string. When an import task starts and attempts to assume a specified role, it automatically attaches this external ID. This means that you can configure this external ID in the assumed role's trust relationship, so that only the import task of that specified cluster can access the data by assuming the role. This can provide additional security.J4\"abcdefghijklmnopqrstuvwxyz0123456789xxxxxxxxxxxxxx\"R\n" +
	"externalId:\x8c\x01\x92A\x88\x01\n" +
	"\x85\x01*\x15AwsImportTaskRoleInfo2QAwsImportTaskRoleInfo is the role information for import tasks on an AWS cluster.\xd2\x01\n" +
	"account_id\xd2\x01\vexternal_id\"\xa3\x02\n" +
	"\x15GcpImportTaskRoleInfo\x12\x8c\x01\n" +
	"\n" +
	"account_id\x18\x01 \x01(\tBm\x92Aj2IThe account ID under which the import tasks for this cluster are running.J\x1d\"example-account@example.com\"R\taccountId:{\x92Ax\n" +
	"v*\x15GcpImportTaskRoleInfo2PGcpImportTaskRoleInfo is the role information for import tasks on a GCP cluster.\xd2\x01\n" +
	"account_id\"\xb5\b\n" +
	"\x13UpdateImportTaskReq\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xbe\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\x9e\x01\x92A\x9a\x012\x97\x01The ID of your cluster. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).R\tclusterId\x12\xb9\x01\n" +
	"\timport_id\x18\x03 \x01(\x04B\x9b\x01\x92A\x97\x012\x94\x01The ID of the import task. You can get the import ID from the response of [List import tasks for a cluster](#tag/Project/operation/ListImportTasks).R\bimportId\x12\xa8\x02\n" +
	"\x06action\x18\x04 \x01(\x0e2-.openapi.UpdateImportTaskReq.ImportTaskActionB\xe0\x01\x92A\xdc\x012\xcf\x01The action to apply to the import task.\n" +
	"\n" +
	"**Limitation:**\n" +
	"Currently, only `CANCEL` is supported when the import task is in the `PREPARING` or `IMPORTING` phase, meaning that the import task will be cancelled.J\b\"CANCEL\"R\x06action\"/\n" +
	"\x10ImportTaskAction\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\n" +
	"\n" +
	"\x06CANCEL\x10\x01:\x89\x01\x92A\x85\x01\n" +
	"\x82\x01*\x13UpdateImportTaskReq2<UpdateImportTaskReq is the request to update an import task.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\xd2\x01\timport_id\xd2\x01\x06action\"\x96\t\n" +
	"\x12UploadLocalFileReq\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xbe\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\x9e\x01\x92A\x9a\x012\x97\x01The ID of your cluster. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).R\tclusterId\x12\xf6\x03\n" +
	"\x0flocal_file_name\x18\x03 \x01(\tB\xcd\x03\x92A\xc9\x032\xb7\x03The local file name to be uploaded. Only CSV files are supported. The maximum length of the file name is 255 characters.\n" +
	"\n" +
	"**Note:**\n" +
	"* Provide only the basename of the file. For example, instead of specifying `/foo/bar/example_file.csv`, specify only `example_file.csv`. If you do specify a full file path, this endpoint will only use the basename as the file name.\n" +
	"* The directory name is not supported. For example: `/foobar/` is invalid.J\n" +
	"\"test.csv\"x\xff\x01R\rlocalFileName\x12z\n" +
	"\apayload\x18\x04 \x01(\v2\x19.openapi.LocalFilePayloadBE\x92AB2@The payload to upload the local file content for an import task.R\apayload:\x8e\x01\x92A\x8a\x01\n" +
	"\x87\x01*\x12UploadLocalFileReq2;UploadLocalFileReq is the request to upload an import task.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\xd2\x01\x0flocal_file_name\xd2\x01\apayload\"\xb8\a\n" +
	"\x10LocalFilePayload\x12\xc1\x02\n" +
	"\x10total_size_bytes\x18\x01 \x01(\x04B\x96\x02\x92A\x92\x022\x80\x02The total size of the **ACTUAL** local file contents, not the total size of the `content` field.\n" +
	"\n" +
	"The unit is byte, and the maximum value is `52428800` (50 MiB). If the given value of `total_size_bytes` exceeds the maximum value, an error will be reported.J\x04\"83\"Y\x00\x00\x00\x00\x00\x00\x89AR\x0etotalSizeBytes\x12\xcf\x03\n" +
	"\acontent\x18\x02 \x01(\fB\xb4\x03\x92A\xb0\x032\xc0\x02The base64-encoded content of the local file to be imported. The maximum size of the file should be 52428800 (50 MiB).\n" +
	"\n" +
	"**Note:** Before providing the content, process the file by taking the following steps:\n" +
	"1. Compress the file using the **gzip** algorithm.\n" +
	"2. Encode the compressed data using the **base64** algorithm.Jf\"H4sIABbP9mMAAyXHOwoAIQwFwN5jvPoh5neggI2w9Z7fSJqBOZt/fvLQIURmLgFlrqE9BbVmPQOt5j0HvRa9AKN2AUwss6dTAAAA\"x\x80\x80\x80\x19R\acontent:\x8d\x01\x92A\x89\x01\n" +
	"\x86\x01*\x10LocalFilePayload2ULocalFilePayload represents the payload to upload a local file content for importing.\xd2\x01\x10total_size_bytes\xd2\x01\acontent\"\xb7\x02\n" +
	"\x13UploadLocalFileResp\x12\xb3\x01\n" +
	"\x0eupload_stub_id\x18\x01 \x01(\x04B\x8c\x01\x92A\x88\x012\x7fThe stub ID for the uploaded file. You can use this stub ID to [create an import task](#tag/Import/operation/CreateImportTask).J\x05\"123\"R\fuploadStubId:j\x92Ag\n" +
	"e*\x13UploadLocalFileResp2=UploadLocalFileResp is the response to upload an import task.\xd2\x01\x0eupload_stub_id\"\xc0\b\n" +
	"\x14PreviewImportDataReq\x12\xb8\x01\n" +
	"\n" +
	"project_id\x18\x01 \x01(\x04B\x98\x01\x92A\x94\x012\x8c\x01The ID of your project. You can get the project ID from the response of [List all accessible projects](#tag/Project/operation/ListProjects).J\x03\"1\"R\tprojectId\x12\xe9\x01\n" +
	"\n" +
	"cluster_id\x18\x02 \x01(\x04B\xc9\x01\x92A\xc5\x012\xbd\x01The ID of your cluster that you want to start an import task. You can get the cluster ID from the response of [List all clusters in a project](#tag/Cluster/operation/ListClustersOfProject).J\x03\"1\"R\tclusterId\x12\xb6\x02\n" +
	"\x04spec\x18\x03 \x01(\v2\x13.openapi.ImportSpecB\x8c\x02\x92A\x88\x022\x85\x02The specifications of the import task.\n" +
	"\n" +
	"**Note:** Currently, you can only preview locally uploaded files. This means that only data sources with the `LOCAL_FILE` source type are supported. If you specify a data source other than `LOCAL_FILE`, errors will occur.R\x04spec\x12\x83\x01\n" +
	"\x10limit_rows_count\x18\x04 \x01(\rBT\x92AQ25The maximum number of rows to preview for each table.:\x0210J\x0210Y\x00\x00\x00\x00\x00\x004@i\x00\x00\x00\x00\x00\x00\xf0?H\x00R\x0elimitRowsCount\x88\x01\x01:\xac\x01\x92A\xa8\x01\n" +
	"\xa5\x01*\x14PreviewImportDataReq2lPreviewImportDataReq is the request to preview the source data before starting an import task for a cluster.\xd2\x01\n" +
	"project_id\xd2\x01\n" +
	"cluster_id\xd2\x01\x04specB\x13\n" +
	"\x11_limit_rows_count\"\xaa\x02\n" +
	"\x15PreviewImportDataResp\x12\x90\x01\n" +
	"\x0etable_previews\x18\x01 \x03(\v2\x15.openapi.TablePreviewBR\x92AO2MThe preview results for each target table from the import task specification.R\rtablePreviews:~\x92A{\n" +
	"y*\x15PreviewImportDataResp2`PreviewImportDataResp is the response of the source data preview before starting an import task.\"\x80\x04\n" +
	"\fTablePreview\x12Y\n" +
	"\rdatabase_name\x18\x01 \x01(\tB4\x92A12'The database name of the preview table.J\x06\"db01\"R\fdatabaseName\x12S\n" +
	"\n" +
	"table_name\x18\x02 \x01(\tB4\x92A12$The table name of the preview table.J\t\"table01\"R\ttableName\x12c\n" +
	"\x0eschema_preview\x18\x03 \x01(\v2\x14.openapi.TableSchemaB&\x92A#2!The schema for the preview table.R\rschemaPreview\x12b\n" +
	"\fdata_preview\x18\x04 \x01(\v2\x12.openapi.TableDataB+\x92A(2&The data sample for the preview table.R\vdataPreview:w\x92At\n" +
	"r*\fTablePreview26TablePreview is the preview result for a single table.\xd2\x01\rdatabase_name\xd2\x01\n" +
	"table_name\xd2\x01\fdata_preview\"\xcb\x04\n" +
	"\vTableSchema\x12\xf3\x01\n" +
	"\x12column_definitions\x18\x01 \x03(\v2\x19.openapi.ColumnDefinitionB\xa8\x01\x92A\xa4\x0123The column definition for each column in the table.Jm[{\"column_name\": \"id\", \"column_type\": \"INTEGER\"}, {\"column_name\": \"column01\", \"column_type\": \"VARCHAR(255)\"}]R\x11columnDefinitions\x12\xe3\x01\n" +
	"\x13primary_key_columns\x18\x02 \x03(\tB\xb2\x01\x92A\xae\x012\xa3\x01The primary key column names for the table. This is optional. The primary key is taken into account when the table is pre-created before an import task is started.J\x06[\"id\"]R\x11primaryKeyColumns:`\x92A]\n" +
	"[*\vTableSchema27TableSchema is the schema definition of a single table.\xd2\x01\x12column_definitions\"\x8f\x02\n" +
	"\x10ColumnDefinition\x12B\n" +
	"\vcolumn_name\x18\x01 \x01(\tB!\x92A\x1e2\x10The column name.J\n" +
	"\"column01\"R\n" +
	"columnName\x12F\n" +
	"\vcolumn_type\x18\x02 \x01(\tB%\x92A\"2\x10The column type.J\x0e\"VARCHAR(255)\"R\n" +
	"columnType:o\x92Al\n" +
	"j*\x10ColumnDefinition2:ColumnDefinition is the definition of a column in a table.\xd2\x01\vcolumn_name\xd2\x01\vcolumn_type\"\xa5\x02\n" +
	"\tTableData\x12y\n" +
	"\fcolumn_names\x18\x01 \x03(\tBV\x92AS2=The column names for the following data samples from a table.J\x12[\"id\", \"column01\"]R\vcolumnNames\x12N\n" +
	"\x04rows\x18\x02 \x03(\v2\x15.openapi.TableDataRowB#\x92A 2\x1eThe rows sampled from a table.R\x04rows:M\x92AJ\n" +
	"H*\tTableData24TableData represents some data samples from a table.\xd2\x01\x04rows\"\xad\x01\n" +
	"\fTableDataRow\x12T\n" +
	"\acolumns\x18\x01 \x03(\tB:\x92A72'The columns extracted from a table row.J\f[\"1\", \"abc\"]R\acolumns:G\x92AD\n" +
	"B*\fTableDataRow2(TableDataRow is a single row in a table.\xd2\x01\acolumns2\xff\x14\n" +
	"\x06Import\x12\xd0\x01\n" +
	"\x0fListImportTasks\x12\x1b.openapi.ListImportTasksReq\x1a\x1c.openapi.ListImportTasksResp\"\x81\x01\x92A7\x12$List all import tasks for a cluster.*\x0fListImportTasks\x82\xd3\xe4\x93\x02A\x12?/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports\x12\xbb\x01\n" +
	"\rGetImportTask\x12\x19.openapi.GetImportTaskReq\x1a\x13.openapi.ImportItem\"z\x92A$\x12\x13Get an import task.*\rGetImportTask\x82\xd3\xe4\x93\x02M\x12K/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports/{import_id}\x12\xe5\x04\n" +
	"\x15GetImportTaskRoleInfo\x12!.openapi.GetImportTaskRoleInfoReq\x1a\x1b.openapi.ImportTaskRoleInfo\"\x8b\x04\x92A\xb6\x03\x12<Retrieve the role information for import tasks on a cluster.\x1a\xde\x02Retrieve the role information for import tasks on a cluster, so that you can configure the access for the import tasks to retrieve the data from the data source. For more information on how to configure the access for the import tasks, refer to [Configure Amazon S3 Access and GCS Access](https://docs.pingcap.com/tidbcloud/config-s3-and-gcs-access).*\x15GetImportTaskRoleInfo\x82\xd3\xe4\x93\x02K\x12I/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports/role_info\x12\xc8\x01\n" +
	"\x10CreateImportTask\x12\x1c.openapi.CreateImportTaskReq\x1a\x1d.openapi.CreateImportTaskResp\"w\x92A*\x12\x16Create an import task.*\x10CreateImportTask\x82\xd3\xe4\x93\x02D:\x01*\"?/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports\x12\xff\x02\n" +
	"\x10UpdateImportTask\x12\x1c.openapi.UpdateImportTaskReq\x1a\x16.google.protobuf.Empty\"\xb4\x02\x92A\xda\x01\x12\x16Update an import task.\x1a\xad\x01Update an import task from a cluster. Currently, this endpoint only supports canceling the import task if the current phase of the import task is `PREPARING` or `IMPORTING`.*\x10UpdateImportTask\x82\xd3\xe4\x93\x02P:\x01*2K/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports/{import_id}\x12\x87\x04\n" +
	"\x0fUploadLocalFile\x12\x1b.openapi.UploadLocalFileReq\x1a\x1c.openapi.UploadLocalFileResp\"\xb8\x03\x92A\xde\x02\x12'Upload a local file for an import task.\x1a\xa1\x02If you need to import data from a local file, you must first upload the file using this endpoint before you create an import task using the [Create an import task](#tag/Import/operation/CreateImportTask) endpoint.\n" +
	"\n" +
	"Uploading a local file is only available for TiDB Cloud Starter instances.*\x0fUploadLocalFile\x82\xd3\xe4\x93\x02P:\x01*\"K/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports/upload_file\x12\xa6\x03\n" +
	"\x11PreviewImportData\x12\x1d.openapi.PreviewImportDataReq\x1a\x1e.openapi.PreviewImportDataResp\"\xd1\x02\x92A\xfb\x01\x12,Preview data before starting an import task.\x1a\xb7\x01Before you create an import task, you can preview the data using this endpoint and make sure that the import task is configured as intended. The preview result is organized by tables.*\x11PreviewImportData\x82\xd3\xe4\x93\x02L:\x01*\"G/api/v1beta/projects/{project_id}/clusters/{cluster_id}/imports/preview\x1a|\x92Ay\x12wCreate, get, update import tasks for TiDB clusters. **Warning:** The following import-related endpoints are deprecated.B1Z/github.com/tidbcloud/idl/pbgen/proto/openapi/dpb\x06proto3"

var (
	file_openapi_dp_import_proto_rawDescOnce sync.Once
	file_openapi_dp_import_proto_rawDescData []byte
)

func file_openapi_dp_import_proto_rawDescGZIP() []byte {
	file_openapi_dp_import_proto_rawDescOnce.Do(func() {
		file_openapi_dp_import_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_openapi_dp_import_proto_rawDesc), len(file_openapi_dp_import_proto_rawDesc)))
	})
	return file_openapi_dp_import_proto_rawDescData
}

var file_openapi_dp_import_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_openapi_dp_import_proto_msgTypes = make([]protoimpl.MessageInfo, 35)
var file_openapi_dp_import_proto_goTypes = []any{
	(ImportSource_ImportSourceType)(0),             // 0: openapi.ImportSource.ImportSourceType
	(ImportSourceFormat_ImportSourceFormatType)(0), // 1: openapi.ImportSourceFormat.ImportSourceFormatType
	(ImportStatus_ImportTaskPhase)(0),              // 2: openapi.ImportStatus.ImportTaskPhase
	(UpdateImportTaskReq_ImportTaskAction)(0),      // 3: openapi.UpdateImportTaskReq.ImportTaskAction
	(*ImportItem)(nil),                             // 4: openapi.ImportItem
	(*ImportMetadata)(nil),                         // 5: openapi.ImportMetadata
	(*ImportSpec)(nil),                             // 6: openapi.ImportSpec
	(*ImportSource)(nil),                           // 7: openapi.ImportSource
	(*AwsAssumeRoleAccess)(nil),                    // 8: openapi.AwsAssumeRoleAccess
	(*AwsKeyAccess)(nil),                           // 9: openapi.AwsKeyAccess
	(*AzureTokenAccess)(nil),                       // 10: openapi.AzureTokenAccess
	(*ImportSourceFormat)(nil),                     // 11: openapi.ImportSourceFormat
	(*ImportSourceCSVConfig)(nil),                  // 12: openapi.ImportSourceCSVConfig
	(*ImportTarget)(nil),                           // 13: openapi.ImportTarget
	(*ImportTargetTable)(nil),                      // 14: openapi.ImportTargetTable
	(*ImportStatus)(nil),                           // 15: openapi.ImportStatus
	(*ImportProgress)(nil),                         // 16: openapi.ImportProgress
	(*ListImportTasksReq)(nil),                     // 17: openapi.ListImportTasksReq
	(*ListImportTasksResp)(nil),                    // 18: openapi.ListImportTasksResp
	(*GetImportTaskReq)(nil),                       // 19: openapi.GetImportTaskReq
	(*CreateImportTaskReq)(nil),                    // 20: openapi.CreateImportTaskReq
	(*CreateImportTaskOptions)(nil),                // 21: openapi.CreateImportTaskOptions
	(*TableDefinition)(nil),                        // 22: openapi.TableDefinition
	(*CreateImportTaskResp)(nil),                   // 23: openapi.CreateImportTaskResp
	(*GetImportTaskRoleInfoReq)(nil),               // 24: openapi.GetImportTaskRoleInfoReq
	(*ImportTaskRoleInfo)(nil),                     // 25: openapi.ImportTaskRoleInfo
	(*AwsImportTaskRoleInfo)(nil),                  // 26: openapi.AwsImportTaskRoleInfo
	(*GcpImportTaskRoleInfo)(nil),                  // 27: openapi.GcpImportTaskRoleInfo
	(*UpdateImportTaskReq)(nil),                    // 28: openapi.UpdateImportTaskReq
	(*UploadLocalFileReq)(nil),                     // 29: openapi.UploadLocalFileReq
	(*LocalFilePayload)(nil),                       // 30: openapi.LocalFilePayload
	(*UploadLocalFileResp)(nil),                    // 31: openapi.UploadLocalFileResp
	(*PreviewImportDataReq)(nil),                   // 32: openapi.PreviewImportDataReq
	(*PreviewImportDataResp)(nil),                  // 33: openapi.PreviewImportDataResp
	(*TablePreview)(nil),                           // 34: openapi.TablePreview
	(*TableSchema)(nil),                            // 35: openapi.TableSchema
	(*ColumnDefinition)(nil),                       // 36: openapi.ColumnDefinition
	(*TableData)(nil),                              // 37: openapi.TableData
	(*TableDataRow)(nil),                           // 38: openapi.TableDataRow
	(*emptypb.Empty)(nil),                          // 39: google.protobuf.Empty
}
var file_openapi_dp_import_proto_depIdxs = []int32{
	5,  // 0: openapi.ImportItem.metadata:type_name -> openapi.ImportMetadata
	6,  // 1: openapi.ImportItem.spec:type_name -> openapi.ImportSpec
	15, // 2: openapi.ImportItem.status:type_name -> openapi.ImportStatus
	7,  // 3: openapi.ImportSpec.source:type_name -> openapi.ImportSource
	13, // 4: openapi.ImportSpec.target:type_name -> openapi.ImportTarget
	0,  // 5: openapi.ImportSource.type:type_name -> openapi.ImportSource.ImportSourceType
	8,  // 6: openapi.ImportSource.aws_assume_role_access:type_name -> openapi.AwsAssumeRoleAccess
	9,  // 7: openapi.ImportSource.aws_key_access:type_name -> openapi.AwsKeyAccess
	10, // 8: openapi.ImportSource.azure_token_access:type_name -> openapi.AzureTokenAccess
	11, // 9: openapi.ImportSource.format:type_name -> openapi.ImportSourceFormat
	1,  // 10: openapi.ImportSourceFormat.type:type_name -> openapi.ImportSourceFormat.ImportSourceFormatType
	12, // 11: openapi.ImportSourceFormat.csv_config:type_name -> openapi.ImportSourceCSVConfig
	14, // 12: openapi.ImportTarget.tables:type_name -> openapi.ImportTargetTable
	2,  // 13: openapi.ImportStatus.phase:type_name -> openapi.ImportStatus.ImportTaskPhase
	16, // 14: openapi.ImportStatus.progress:type_name -> openapi.ImportProgress
	4,  // 15: openapi.ListImportTasksResp.items:type_name -> openapi.ImportItem
	6,  // 16: openapi.CreateImportTaskReq.spec:type_name -> openapi.ImportSpec
	21, // 17: openapi.CreateImportTaskReq.options:type_name -> openapi.CreateImportTaskOptions
	22, // 18: openapi.CreateImportTaskOptions.pre_create_tables:type_name -> openapi.TableDefinition
	35, // 19: openapi.TableDefinition.schema:type_name -> openapi.TableSchema
	26, // 20: openapi.ImportTaskRoleInfo.aws_import_role:type_name -> openapi.AwsImportTaskRoleInfo
	27, // 21: openapi.ImportTaskRoleInfo.gcp_import_role:type_name -> openapi.GcpImportTaskRoleInfo
	3,  // 22: openapi.UpdateImportTaskReq.action:type_name -> openapi.UpdateImportTaskReq.ImportTaskAction
	30, // 23: openapi.UploadLocalFileReq.payload:type_name -> openapi.LocalFilePayload
	6,  // 24: openapi.PreviewImportDataReq.spec:type_name -> openapi.ImportSpec
	34, // 25: openapi.PreviewImportDataResp.table_previews:type_name -> openapi.TablePreview
	35, // 26: openapi.TablePreview.schema_preview:type_name -> openapi.TableSchema
	37, // 27: openapi.TablePreview.data_preview:type_name -> openapi.TableData
	36, // 28: openapi.TableSchema.column_definitions:type_name -> openapi.ColumnDefinition
	38, // 29: openapi.TableData.rows:type_name -> openapi.TableDataRow
	17, // 30: openapi.Import.ListImportTasks:input_type -> openapi.ListImportTasksReq
	19, // 31: openapi.Import.GetImportTask:input_type -> openapi.GetImportTaskReq
	24, // 32: openapi.Import.GetImportTaskRoleInfo:input_type -> openapi.GetImportTaskRoleInfoReq
	20, // 33: openapi.Import.CreateImportTask:input_type -> openapi.CreateImportTaskReq
	28, // 34: openapi.Import.UpdateImportTask:input_type -> openapi.UpdateImportTaskReq
	29, // 35: openapi.Import.UploadLocalFile:input_type -> openapi.UploadLocalFileReq
	32, // 36: openapi.Import.PreviewImportData:input_type -> openapi.PreviewImportDataReq
	18, // 37: openapi.Import.ListImportTasks:output_type -> openapi.ListImportTasksResp
	4,  // 38: openapi.Import.GetImportTask:output_type -> openapi.ImportItem
	25, // 39: openapi.Import.GetImportTaskRoleInfo:output_type -> openapi.ImportTaskRoleInfo
	23, // 40: openapi.Import.CreateImportTask:output_type -> openapi.CreateImportTaskResp
	39, // 41: openapi.Import.UpdateImportTask:output_type -> google.protobuf.Empty
	31, // 42: openapi.Import.UploadLocalFile:output_type -> openapi.UploadLocalFileResp
	33, // 43: openapi.Import.PreviewImportData:output_type -> openapi.PreviewImportDataResp
	37, // [37:44] is the sub-list for method output_type
	30, // [30:37] is the sub-list for method input_type
	30, // [30:30] is the sub-list for extension type_name
	30, // [30:30] is the sub-list for extension extendee
	0,  // [0:30] is the sub-list for field type_name
}

func init() { file_openapi_dp_import_proto_init() }
func file_openapi_dp_import_proto_init() {
	if File_openapi_dp_import_proto != nil {
		return
	}
	file_openapi_dp_import_proto_msgTypes[3].OneofWrappers = []any{
		(*ImportSource_AwsAssumeRoleAccess)(nil),
		(*ImportSource_AwsKeyAccess)(nil),
		(*ImportSource_AzureTokenAccess)(nil),
	}
	file_openapi_dp_import_proto_msgTypes[7].OneofWrappers = []any{
		(*ImportSourceFormat_CsvConfig)(nil),
	}
	file_openapi_dp_import_proto_msgTypes[21].OneofWrappers = []any{
		(*ImportTaskRoleInfo_AwsImportRole)(nil),
		(*ImportTaskRoleInfo_GcpImportRole)(nil),
	}
	file_openapi_dp_import_proto_msgTypes[28].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_openapi_dp_import_proto_rawDesc), len(file_openapi_dp_import_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   35,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_openapi_dp_import_proto_goTypes,
		DependencyIndexes: file_openapi_dp_import_proto_depIdxs,
		EnumInfos:         file_openapi_dp_import_proto_enumTypes,
		MessageInfos:      file_openapi_dp_import_proto_msgTypes,
	}.Build()
	File_openapi_dp_import_proto = out.File
	file_openapi_dp_import_proto_goTypes = nil
	file_openapi_dp_import_proto_depIdxs = nil
}