yt

type ACE struct {
	Action           SecurityAction `yson:"action,omitempty"`
	Subjects         []string       `yson:"subjects,omitempty"`
	Permissions      []Permission   `yson:"permissions,omitempty"`
	InheritanceMode  string         `yson:"inheritance_mode,omitempty"`
	Columns          []string       `yson:"columns,omitempty"`
	Vital            *bool          `yson:"vital,omitempty"`
	SubjectTagFilter string         `yson:"subject_tag_filter,omitempty"`
}

type AbortOperationOptions struct {
	AbortMessage *string `http:"abort_message,omitnil"`
}

type AbortQueryOptions struct {
	AbortMessage *string `http:"abort_message,omitnil"`

	*QueryTrackerOptions
}

type AbortTxOptions struct {
	Sticky bool `http:"sticky"`

	*TransactionOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type AccessTrackingOptions struct {
	SuppressAccessTracking       bool `http:"suppress_access_tracking"`
	SuppressModificationTracking bool `http:"suppress_modification_tracking"`
}

type AddMaintenanceOptions struct {
}

type AddMaintenanceResponse struct {
	ID MaintenanceID `yson:"id"`
}

type AddMemberOptions struct {
	*MutatingOptions
	*PrerequisiteOptions
}

type AdminClient interface {
	// http:verb:"add_member"
	// http:params:"group","member"
	AddMember(
		ctx context.Context,
		group string,
		member string,
		options *AddMemberOptions,
	) (err error)

	// http:verb:"build_master_snapshots"
	BuildMasterSnapshots(
		ctx context.Context,
		options *BuildMasterSnapshotsOptions,
	) (result *BuildMasterSnapshotsResponse, err error)

	// http:verb:"build_snapshot"
	BuildSnapshot(
		ctx context.Context,
		options *BuildSnapshotOptions,
	) (result *BuildSnapshotResponse, err error)

	// http:verb:"remove_member"
	// http:params:"group","member"
	RemoveMember(
		ctx context.Context,
		group string,
		member string,
		options *RemoveMemberOptions,
	) (err error)

	// http:verb:"add_maintenance"
	// http:params:"component","address","type","comment"
	AddMaintenance(
		ctx context.Context,
		component MaintenanceComponent,
		address string,
		maintenanceType MaintenanceType,
		comment string,
		options *AddMaintenanceOptions,
	) (result *AddMaintenanceResponse, err error)

	// http:verb:"remove_maintenance"
	// http:params:"component","address"
	RemoveMaintenance(
		ctx context.Context,
		component MaintenanceComponent,
		address string,
		options *RemoveMaintenanceOptions,
	) (result *RemoveMaintenanceResponse, err error)

	// http:verb:"transfer_account_resources"
	// http:params:"source_account","destination_account","resource_delta"
	TransferAccountResources(
		ctx context.Context,
		srcAccount string,
		dstAccount string,
		resourceDelta any,
		options *TransferAccountResourcesOptions,
	) (err error)

	// http:verb:"transfer_pool_resources"
	// http:params:"source_pool","destination_pool","pool_tree","resource_delta"
	TransferPoolResources(
		ctx context.Context,
		srcPool string,
		dstPool string,
		poolTree string,
		resourceDelta any,
		options *TransferPoolResourcesOptions,
	) (err error)

	// http:verb:"check_permission"
	// http:params:"user","permission","path"
	CheckPermission(
		ctx context.Context,
		user string,
		permission Permission,
		path ypath.YPath,
		options *CheckPermissionOptions,
	) (result *CheckPermissionResponse, err error)

	// http:verb:"disable_chunk_locations"
	// http:params:"node_address","location_uuids"
	DisableChunkLocations(
		ctx context.Context,
		nodeAddress string,
		locationUUIDs []guid.GUID,
		options *DisableChunkLocationsOptions,
	) (result *DisableChunkLocationsResponse, err error)

	// http:verb:"destroy_chunk_locations"
	// http:params:"node_address","recover_unlinked_disks","location_uuids"
	DestroyChunkLocations(
		ctx context.Context,
		nodeAddress string,
		recoverUnlinkedDisks bool,
		locationUUIDs []guid.GUID,
		options *DestroyChunkLocationsOptions,
	) (result *DestroyChunkLocationsResponse, err error)

	// http:verb:"resurrect_chunk_locations"
	// http:params:"node_address","location_uuids"
	ResurrectChunkLocations(
		ctx context.Context,
		nodeAddress string,
		locationUUIDs []guid.GUID,
		options *ResurrectChunkLocationsOptions,
	) (result *ResurrectChunkLocationsResponse, err error)

	// http:verb:"request_restart"
	// http:params:"node_address"
	RequestRestart(
		ctx context.Context,
		nodeAddress string,
		options *RequestRestartOptions,
	) error
}

type AlterQueryOptions struct {
	Annotations         any     `http:"annotations,omitnil"`
	AccessControlObject *string `http:"access_control_object,omitnil"`

	*QueryTrackerOptions
}

type AlterTableOptions struct {
	*MutatingOptions

	Schema            *schema.Schema `http:"schema,omitnil"`
	Dynamic           *bool          `http:"dynamic,omitnil"`
	UpstreamReplicaID *guid.GUID     `http:"upstream_replica_id,omitnil"`
}

type AlterTableReplicaOptions struct {
	Enabled *bool             `http:"enabled,omitnil"`
	Mode    *TableReplicaMode `http:"mode,omitnil"`
}

type Atomicity string

type Attribute struct {
	Key   string
	Value []byte
}

type AuthClient interface {
	// http:verb:"set_user_password"
	// http:params:"user","new_password_sha256","current_password_sha256"
	SetUserPassword(
		ctx context.Context,
		user string,
		newPassword string,
		currentPassword string,
		options *SetUserPasswordOptions,
	) (err error)

	// http:verb:"issue_token"
	// http:params:"user","password_sha256"
	IssueToken(
		ctx context.Context,
		user string,
		password string,
		options *IssueTokenOptions,
	) (token string, err error)

	// http:verb:"revoke_token"
	// http:params:"user","password_sha256","token_sha256"
	RevokeToken(
		ctx context.Context,
		user string,
		password string,
		token string,
		options *RevokeTokenOptions,
	) error

	// http:verb:"list_user_tokens"
	// http:params:"user","password_sha256"
	ListUserTokens(
		ctx context.Context,
		user string,
		password string,
		options *ListUserTokensOptions,
	) (tokens []string, err error)
}

type BackupManifest struct {
	Clusters map[string][]TableBackupManifest `yson:"clusters"`
}

type BuildMasterSnapshot struct {
	CellID     guid.GUID `yson:"cell_id"`
	SnapshotID int       `yson:"snapshot_id"`
}

type BuildMasterSnapshotsOptions struct {
	SetReadOnly               *bool `http:"set_read_only,omitnil"`
	WaitForSnapshotCompletion *bool `http:"wait_for_snapshot_completion,omitnil"`
	Retry                     *bool `http:"retry,omitnil"`
}

type BuildMasterSnapshotsResponse = []BuildMasterSnapshot

type BuildSnapshotOptions struct {
	CellID                    *guid.GUID `http:"cell_id,omitnil"`
	SetReadOnly               *bool      `http:"set_read_only,omitnil"`
	WaitForSnapshotCompletion *bool      `http:"wait_for_snapshot_completion,omitnil"`
}

type BuildSnapshotResponse struct {
	SnapshotID int `yson:"snapshot_id"`
}

type CheckPermissionOptions struct {
	*TransactionOptions
	*PrerequisiteOptions
	*MasterReadOptions

	Columns []string `http:"columns,omitnil"`
}

type CheckPermissionResponse struct {
	CheckPermissionResult

	Columns []CheckPermissionResult `yson:"columns,omitempty"`
}

type CheckPermissionResult struct {
	Action      SecurityAction `yson:"action"`
	ObjectID    NodeID         `yson:"object_id,omitempty"`
	ObjectName  *string        `yson:"object_name,omitempty"`
	SubjectID   NodeID         `yson:"subject_id,omitempty"`
	SubjectName *string        `yson:"subject_name,omitempty"`
}

type ChunkSpec struct {
	ChunkID    guid.GUID        `yson:"chunk_id"`
	RangeIndex int              `yson:"range_index"`
	RowIndex   int              `yson:"row_index"`
	RowCount   int              `yson:"row_count"`
	LowerLimit *ypath.ReadLimit `yson:"lower_limit"`
	UpperLimit *ypath.ReadLimit `yson:"upper_limit"`
	Replicas   []int            `yson:"replicas"`
}

type Client interface {
	CypressClient
	FileClient
	TableClient

	// BeginTx creates new tx.
	//
	// Tx lifetime is bound to ctx. Tx is automatically aborted when ctx is canceled.
	//
	// Active transaction consumes resources, client must finish transaction by calling Commit(), Abort()
	// or canceling ctx passed to BeginTx.
	BeginTx(ctx context.Context, options *StartTxOptions) (tx Tx, err error)

	// BeginTabletTx creates new tablet transaction.
	//
	// Tx lifetime is bound to ctx. Tx is automatically aborted when ctx is canceled.
	//
	// Active transaction consumes resources, client must finish transaction by calling Commit(), Abort()
	// or canceling ctx passed to BeginTabletTx.
	BeginTabletTx(ctx context.Context, options *StartTabletTxOptions) (tx TabletTx, err error)

	TabletClient
	MountClient
	TableBackupClient

	// http:verb:"generate_timestamp"
	GenerateTimestamp(ctx context.Context, options *GenerateTimestampOptions) (ts Timestamp, err error)

	LowLevelTxClient
	LowLevelSchedulerClient

	AdminClient
	AuthClient

	QueryTrackerClient

	// http:verb:"locate_skynet_share"
	// http:params:"path"
	LocateSkynetShare(
		ctx context.Context,
		path ypath.YPath,
		options *LocateSkynetShareOptions,
	) (l ShareLocation, err error)

	// http:verb:"get_in_sync_replicas"
	// http:params:"path","timestamp"
	// http:extra
	GetInSyncReplicas(
		ctx context.Context,
		path ypath.Path,
		ts Timestamp,
		keys []any,
		options *GetInSyncReplicasOptions,
	) (ids []NodeID, err error)

	NewRowBatchWriter() RowBatchWriter

	// Stop() cancels and waits for completion of all background activity associated with this client.
	//
	// All transactions tracked by this client are aborted.
	Stop()
}

type ClientCompressionCodec int

type ClusterURL struct {
	Address          string
	DisableDiscovery bool
}

type CommitTxOptions struct {
	Sticky bool `http:"sticky"`

	*MutatingOptions
	*PrerequisiteOptions
	*TransactionOptions
}

type CompleteOperationOptions struct {
}

type Config struct {
	// Proxy configures address of YT HTTP proxy.
	//
	// If Proxy is not set, value of YT_PROXY environment variable is used instead.
	//
	// Might be equal to cluster name. E.g. hahn or markov.
	//
	// Might be equal to hostname with optional port. E.g. localhost:12345 or sas5-1547-proxy-hahn.sas.yp-c.yandex.net.
	// In that case, provided host is used for all requests and proxy discovery is disabled.
	Proxy string

	// RPCProxy pins address of YT RPC proxy.
	//
	// If set, proxy discovery is disabled and provided value is used for all requests.
	//
	// If left empty, RPC proxies are discovered via HTTP using Proxy setting.
	//
	// Only relevant for RPC client.
	RPCProxy string

	// ProxyRole configures desired proxy role used by the client.
	//
	// If not set, default role is used.
	ProxyRole string

	// UseTLS enables TLS for all connections to cluster.
	//
	// This option is supported only in HTTP client.
	//
	// By default, client will not use TLS.
	//
	// TLS is not supported in local mode.
	UseTLS bool

	// CertificateAuthorityData contains PEM-encoded certificate authority certificates.
	//
	// Client appends this certificates to the system cert pool.
	//
	// This option is relevant for HTTP client with enabled TLS.
	CertificateAuthorityData []byte

	// Token configures OAuth token used by the client.
	//
	// If Token is not set, value of YT_TOKEN environment variable is used instead.
	Token string

	// ReadTokenFromFile
	//
	// When this variable is set, client tries reading token from ~/.yt/token file.
	ReadTokenFromFile bool

	// Credentials can be used for authentication.
	//
	// If Credentials are not set, OAuth token is used.
	Credentials Credentials

	// TVMFn is used to issue service tickets for YT API requests.
	//
	// TVM is a preferred way of service authentication.
	//
	// If TVMFn is not set, Credentials or OAuth token are used.
	//
	// Assign yttvm.TVMFn(tvm.Client) to this field, if you wish to enable tvm authentication.
	TVMFn TVMFn

	// UseTVMOnlyEndpoint configures client to use tvm-only endpoints in cluster connection.
	UseTVMOnlyEndpoint bool

	// DisableProxyDiscovery configures whether proxy discovery is enabled.
	//
	// Typically proxy discovery should be enabled, but in case if there is no
	// network connectivity from the client to the proxy instances and balancer
	// is used instead, proxy discovery should be disabled.
	DisableProxyDiscovery bool

	// Logger overrides default logger, used by the client.
	//
	// When Logger is not set, logging behaviour is configured by YT_LOG_LEVEL environment variable.
	//
	// If YT_LOG_LEVEL is not set, no logging is performed. Otherwise logs are written to stderr,
	// with log level derived from value of YT_LOG_LEVEL variable.
	//
	// WARNING: Running YT client in production without debug logs is highly discouraged.
	Logger log.Structured

	// Tracer overrides default tracer, used by the client
	//
	// When Tracer is not set opentracing.GlobalTracer is used.
	//
	// If opentracing.GlobalTracer is not set, no tracing is performed.
	Tracer opentracing.Tracer

	// TraceFn extracts trace parent from request context.
	//
	// This function is extracted into config in order to avoid direct dependency on jaeger client.
	//
	// Assign ytjaeger.TraceFn to this field, if you wish to enable tracing.
	TraceFn TraceFn

	// LightRequestTimeout specifies default timeout for light requests. Timeout includes all retries and backoffs.
	// Timeout for single request is not configurable right now.
	//
	// A Timeout of zero means no timeout (retries never stop).
	// Client can still specify timeout on per-request basis using context.
	//
	// nil value means default timeout of 5 minutes.
	LightRequestTimeout *time.Duration

	// TxTimeout specifies timeout of YT transaction (both master and tablet).
	//
	// YT transaction is aborted by server after not receiving pings from client for TxTimeout seconds.
	//
	// TxTimeout of zero means default timeout of 15 seconds.
	TxTimeout time.Duration

	// TxPingPeriod specifies period of pings for YT transactions.
	//
	// TxPingPeriod of zero means default value of 3 seconds.
	TxPingPeriod time.Duration

	// AllowRequestsFromJob explicitly allows creating client inside YT job.
	//
	// WARNING: This option can be enabled ONLY after explicit approval from YT team. If you enable this option
	// without approval, your might be BANNED.
	//
	// If you need to read tables, or access cypress from YT job, use API provided by mapreduce package, or
	// redesign your application.
	//
	// Typical mapreduce operation can launch hundred of thousands concurrent jobs. If each job makes even a single request,
	// that could easily lead to master/proxy overload.
	AllowRequestsFromJob bool

	// CompressionCodec specifies codec used for compression of client requests and server responses.
	//
	// NOTE: this codec has nothing to do with codec used for storing table chunks.
	CompressionCodec ClientCompressionCodec
}

type CookieCredentials struct {
	Cookie    *http.Cookie
	CSRFToken string
}

type CopyNodeOptions struct {
	Recursive      bool `http:"recursive"`
	IgnoreExisting bool `http:"ignore_existing"`
	Force          bool `http:"force"`

	PreserveAccount           *bool `http:"preserve_account,omitnil"`
	PreserveExpirationTime    *bool `http:"preserve_expiration_time,omitnil"`
	PreserveExpirationTimeout *bool `http:"preserve_expiration_timeout,omitnil"`
	PreserveCreationTime      *bool `http:"preserve_creation_time,omitnil"`
	PessimisticQuotaCheck     *bool `http:"pessimistic_quota_check,omitnil"`

	*TransactionOptions
	// *AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type CreateNodeOptions struct {
	Recursive      bool `http:"recursive"`
	IgnoreExisting bool `http:"ignore_existing"`
	Force          bool `http:"force"`

	Attributes map[string]any `http:"attributes,omitnil"`

	*TransactionOptions
	*AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type CreateObjectOptions struct {
	Recursive      bool `http:"recursive"`
	IgnoreExisting bool `http:"ignore_existing"`
	Force          bool `http:"force"`

	Attributes map[string]any `http:"attributes,omitnil"`

	*PrerequisiteOptions
	*AccessTrackingOptions
	*MutatingOptions
}

type CreateTableBackupOptions struct {
	CheckpointTimestampDelay *yson.Duration `http:"checkpoint_timestamp_delay,omitnil"`
	CheckpointCheckPeriod    *yson.Duration `http:"checkpoint_check_period,omitnil"`
	CheckpointCheckTimeout   *yson.Duration `http:"checkpoint_check_timeout,omitnil"`

	Force bool `http:"force"`

	*TimeoutOptions
}

type CreateTableOption func(options *CreateNodeOptions)

type Credentials interface {
	Set(r *http.Request)
	SetExtension(req *rpc.TRequestHeader)
}

type CypressClient interface {
	// http:verb:"create"
	// http:params:"path","type"
	CreateNode(
		ctx context.Context,
		path ypath.YPath,
		typ NodeType,
		options *CreateNodeOptions,
	) (id NodeID, err error)

	// http:verb:"create"
	// http:params:"type"
	CreateObject(
		ctx context.Context,
		typ NodeType,
		options *CreateObjectOptions,
	) (id NodeID, err error)

	// http:verb:"exists"
	// http:params:"path"
	NodeExists(
		ctx context.Context,
		path ypath.YPath,
		options *NodeExistsOptions,
	) (ok bool, err error)

	// http:verb:"remove"
	// http:params:"path"
	RemoveNode(
		ctx context.Context,
		path ypath.YPath,
		options *RemoveNodeOptions,
	) (err error)

	// http:verb:"get"
	// http:params:"path"
	// http:extra
	GetNode(
		ctx context.Context,
		path ypath.YPath,
		result any,
		options *GetNodeOptions,
	) (err error)

	// http:verb:"set"
	// http:params:"path"
	// http:extra
	SetNode(
		ctx context.Context,
		path ypath.YPath,
		value any,
		options *SetNodeOptions,
	) (err error)

	// http:verb:"multiset_attributes"
	// http:params:"path"
	// http:extra
	MultisetAttributes(
		ctx context.Context,
		path ypath.YPath,
		attributes map[string]any,
		options *MultisetAttributesOptions,
	) (err error)

	// http:verb:"list"
	// http:params:"path"
	// http:extra
	ListNode(
		ctx context.Context,
		path ypath.YPath,
		result any,
		options *ListNodeOptions,
	) (err error)

	// http:verb:"copy"
	// http:params:"source_path","destination_path"
	CopyNode(
		ctx context.Context,
		src ypath.YPath,
		dst ypath.YPath,
		options *CopyNodeOptions,
	) (id NodeID, err error)

	// http:verb:"move"
	// http:params:"source_path","destination_path"
	MoveNode(
		ctx context.Context,
		src ypath.YPath,
		dst ypath.YPath,
		options *MoveNodeOptions,
	) (id NodeID, err error)

	// http:verb:"link"
	// http:params:"target_path","link_path"
	LinkNode(
		ctx context.Context,
		target ypath.YPath,
		link ypath.YPath,
		options *LinkNodeOptions,
	) (id NodeID, err error)
}

type DataStatistics struct {
	UncompressedDataSize int64 `yson:"uncompressed_data_size"`
	CompressedDataSize   int64 `yson:"compressed_data_size"`
	RowCount             int64 `yson:"row_count"`
	ChunkCount           int64 `yson:"chunk_count"`
	RegularDiskSpace     int64 `yson:"regular_disk_space"`
	ErasureDiskSpace     int64 `yson:"erasure_disk_space"`

	// For backward compatibility this can be -1 which means "invalid value".
	DataWeight int64 `yson:"data_weight"`

	UnmergedRowCount   int64 `yson:"unmerged_row_count"`
	UnmergedDataWeight int64 `yson:"unmerged_data_weight"`
}

type DeleteRowsOptions struct {
	RequireSyncReplica *bool `http:"require_sync_replica,omitnil"`

	*TransactionOptions
}

type DestroyChunkLocationsOptions struct {
}

type DestroyChunkLocationsResponse struct {
	LocationUUIDs []guid.GUID
}

type DisableChunkLocationsOptions struct {
}

type DisableChunkLocationsResponse struct {
	LocationUUIDs []guid.GUID
}

type Discoverer interface {
	ListDiscoveryServers() ([]string, error)
	Stop()
}

type DiscoveryClient interface {
	// http:verb:"list_members"
	// http:params:"group_id"
	ListMembers(
		ctx context.Context,
		groupID string,
		options *ListMembersOptions,
	) (members []*MemberInfo, err error)

	// http:verb:"list_groups"
	// http:params:"prefix"
	ListGroups(
		ctx context.Context,
		prefix string,
		options *ListGroupsOptions,
	) (result *ListGroupsResponse, err error)

	// http:verb:"get_group_meta"
	// http:params:"group_id"
	GetGroupMeta(
		ctx context.Context,
		groupID string,
		options *GetGroupMetaOptions,
	) (meta *GroupMeta, err error)

	// http:verb:"heartbeat"
	// http:params:"group_id","member_info","lease_timeout"
	Heartbeat(
		ctx context.Context,
		groupID string,
		memberInfo MemberInfo,
		leaseTimeout int64,
		opts *HeartbeatOptions,
	) (err error)

	// Stop() cancels and waits for completion of all background activity associated with this client.
	Stop()
}

type DiscoveryConfig struct {
	// DiscoveryServers is list of servers on which discovery client can send requests.
	DiscoveryServers []string

	// EndpointSet is id of endpoint set of discovery servers.
	//
	// If this field is set, then YPClusters must be set too.
	EndpointSet string

	// YPClusters is list of yp clusters where discovery servers are located.
	YPClusters []string

	// Token configures OAuth token used by the client.
	//
	// If Token is not set, value of YT_TOKEN environment variable is used instead.
	Token string

	// RequestTimeout specifies default timeout for requests. Timeout includes all retries and backoffs.
	// Timeout for single request is not configurable right now.
	//
	// A Timeout of zero means no timeout. Client can still specify timeout on per-request basis using context.
	//
	// nil value means default timeout of 5 minutes.
	RequestTimeout *time.Duration

	// Logger overrides default logger, used by the client.
	//
	// When Logger is not set, logging behaviour is configured by YT_LOG_LEVEL environment variable.
	//
	// If YT_LOG_LEVEL is not set, no logging is performed. Otherwise logs are written to stderr,
	// with log level derived from value of YT_LOG_LEVEL variable.
	//
	// WARNING: Running YT client in production without debug logs is highly discouraged.
	Logger log.Structured

	// AllowRequestsFromJob explicitly allows creating client inside YT job.
	//
	// WARNING: This option can be enabled ONLY after explicit approval from YT team. If you enable this option
	// without approval, your might be BANNED.
	//
	// If you need to read tables, or access cypress from YT job, use API provided by mapreduce package, or
	// redesign your application.
	//
	// Typical mapreduce operation can launch hundred of thousands concurrent jobs. If each job makes even a single request,
	// that could easily lead to master/proxy overload.
	AllowRequestsFromJob bool
}

type ExecTabletTxOptions struct {
	RetryOptions ExecTxRetryOptions
	*StartTabletTxOptions
}

type ExecTxOptions struct {
	RetryOptions ExecTxRetryOptions
	*StartTxOptions
}

type ExecTxRetryOptions backoff.BackOff

type ExecTxRetryOptionsNone = backoff.StopBackOff

type FileClient interface {
	// http:verb:"write_file"
	// http:params:"path"
	WriteFile(
		ctx context.Context,
		path ypath.YPath,
		options *WriteFileOptions,
	) (w io.WriteCloser, err error)

	// http:verb:"read_file"
	// http:params:"path"
	ReadFile(
		ctx context.Context,
		path ypath.YPath,
		options *ReadFileOptions,
	) (r io.ReadCloser, err error)

	// http:verb:"put_file_to_cache"
	// http:params:"path","md5"
	PutFileToCache(
		ctx context.Context,
		path ypath.YPath,
		md5 string,
		options *PutFileToCacheOptions,
	) (cachedPath ypath.YPath, err error)

	// http:verb:"get_file_from_cache"
	// http:params:"md5"
	GetFileFromCache(
		ctx context.Context,
		md5 string,
		options *GetFileFromCacheOptions,
	) (path ypath.YPath, err error)
}

type FreezeTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions
}

type GenerateTimestampOptions struct{}

type GetFileFromCacheOptions struct {
	CachePath ypath.YPath `http:"cache_path"`

	*MasterReadOptions
	*ReadRetryOptions
}

type GetGroupMetaOptions struct {
}

type GetInSyncReplicasOptions struct{}

type GetJobStderrOptions struct {
}

type GetNodeOptions struct {
	Attributes []string `http:"attributes,omitnil"`
	MaxSize    *int64   `http:"max_size,omitnil"`

	*TransactionOptions
	*AccessTrackingOptions
	*PrerequisiteOptions
	*MasterReadOptions

	*ReadRetryOptions
}

type GetOperationOptions struct {
	Attributes     []string `http:"attributes,omitnil"`
	IncludeRuntime *bool    `http:"include_runtime,omitnil"`

	*MasterReadOptions

	*ReadRetryOptions
}

type GetQueryOptions struct {
	Attributes []string `http:"attributes,omitnil"`
	Timestamp  *uint64  `http:"timestamp,omitnil"`

	*QueryTrackerOptions
}

type GetQueryResultOptions struct {
	*QueryTrackerOptions
}

type GroupMeta struct {
	MemberCount int32
}

type HeartbeatOptions struct {
}

type InsertRowsOptions struct {
	Atomicity          *Atomicity `http:"atomicity,omitnil"`
	RequireSyncReplica *bool      `http:"require_sync_replica,omitnil"`
	Update             *bool      `http:"update,omitnil"`

	*TransactionOptions
}

type IssueTokenOptions struct{}

type JobDataSource string

type JobExecAttributes struct {
	MediumName  string   `yson:"medium_name"`
	IPAddresses []string `yson:"ip_addresses"`
	SandboxPath string   `yson:"sandbox_path"`
	SlotIndex   int      `yson:"slot_index"`
}

type JobID guid.GUID

type JobSortField string

type JobSortOrder string

type JobState string

type JobStatus struct {
	ID              JobID              `yson:"id"`
	Type            string             `yson:"type"`
	State           string             `yson:"state"`
	Address         string             `yson:"address"`
	StartTime       yson.Time          `yson:"start_time"`
	FinishTime      yson.Time          `yson:"finish_time,omitempty"`
	FailContextSize int                `yson:"fail_context_size,omitempty"`
	Error           yterrors.Error     `yson:"error,omitempty"`
	Progress        float64            `yson:"progress,omitempty"`
	ExecAttributes  *JobExecAttributes `yson:"exec_attributes,omitempty"`
}

type JobType string

type LinkNodeOptions struct {
	Recursive      bool `http:"recursive"`
	IgnoreExisting bool `http:"ignore_existing"`
	Force          bool `http:"force"`

	Attributes map[string]any `http:"attributes,omitnil"`

	*TransactionOptions
	// *AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type ListGroupsOptions struct {
	Limit *int32
}

type ListGroupsResponse struct {
	GroupIDs   []string
	Incomplete bool
}

type ListJobsOptions struct {
	JobType                  *JobType       `http:"job_type,omitnil"`
	JobState                 *JobState      `http:"job_state,omitnil"`
	Address                  *string        `http:"address,omitnil"`
	WithStderr               *bool          `http:"with_stderr,omitnil"`
	WithFailContext          *bool          `http:"with_fail_context,omitnil"`
	WithMonitoringDescriptor *bool          `http:"with_monitoring_descriptor,omitnil"`
	SortField                *JobSortField  `http:"sort_field,omitnil"`
	SortOrder                *JobSortOrder  `http:"sort_order,omitnil"`
	Limit                    *int           `http:"limit,omitnil"`
	Offset                   *int           `http:"offset,omitnil"`
	DataSource               *JobDataSource `http:"data_source,omitnil"`
}

type ListJobsResult struct {
	Jobs []JobStatus `yson:"jobs"`
}

type ListMembersOptions struct {
	Limit         *int32
	AttributeKeys []string
}

type ListNodeOptions struct {
	Attributes []string `http:"attributes,omitnil"`
	MaxSize    *int64   `http:"max_size,omitnil"`

	*TransactionOptions
	*MasterReadOptions
	*AccessTrackingOptions
	*PrerequisiteOptions

	*ReadRetryOptions
}

type ListOperationsOptions struct {
	*MasterReadOptions

	*ReadRetryOptions

	FromTime *yson.Time      `http:"from_time,omitnil"`
	ToTime   *yson.Time      `http:"to_time,omitnil"`
	Cursor   *yson.Time      `http:"cursor_time,omitnil"`
	User     *string         `http:"user,omitnil"`
	State    *OperationState `http:"state,omitnil"`
	Type     *OperationType  `http:"type,omitnil"`
	Filter   *string         `http:"filter,omitnil"`
	Limit    *int            `http:"limit,omitnil"`
}

type ListOperationsResult struct {
	Operations      []OperationStatus `yson:"operations"`
	Incomplete      bool              `yson:"incomplete"`
	PoolCounts      map[string]int    `yson:"pool_counts"`
	UserCounts      map[string]int    `yson:"user_counts"`
	StateCounts     map[string]int    `yson:"state_counts"`
	TypeCounts      map[string]int    `yson:"type_counts"`
	FailedJobsCount int               `yson:"failed_jobs_count"`
}

type ListQueriesOptions struct {
	FromTime        *yson.Time              `http:"from_time,omitnil"`
	ToTime          *yson.Time              `http:"to_time,omitnil"`
	CursorTime      *yson.Time              `http:"cursor_time,omitnil"`
	CursorDirection *OperationSortDirection `http:"cursor_direction,omitnil"`
	UserFilter      *string                 `http:"user_filter,omitnil"`

	StateFilter  *QueryState  `http:"state_filter,omitnil"`
	EngineFilter *QueryEngine `http:"engine_filter,omitnil"`
	SubstrFilter *string      `http:"substr_filter,omitnil"`
	Limit        *int64       `http:"limit,omitnil"`

	Attributes []string `http:"attributes,omitnil"`

	*QueryTrackerOptions
}

type ListQueriesResult struct {
	Queries    []Query `yson:"queries"`
	Incomplete bool    `yson:"incomplete"`
	Timestamp  uint64  `yson:"timestamp"`
}

type ListUserTokensOptions struct{}

type LocateSkynetShareOptions struct{}

type LockClient interface {
	// http:verb:"lock"
	// http:params:"path","mode"
	LockNode(
		ctx context.Context,
		path ypath.YPath,
		mode LockMode,
		options *LockNodeOptions,
	) (res LockResult, err error)

	// http:verb:"unlock"
	// http:params:"path"
	UnlockNode(
		ctx context.Context,
		path ypath.YPath,
		options *UnlockNodeOptions,
	) (err error)
}

type LockMode string

type LockNodeOptions struct {
	Waitable     bool    `http:"waitable"`
	ChildKey     *string `http:"child_key,omitnil"`
	AttributeKey *string `http:"attribute_key,omitnil"`

	*TransactionOptions
	*MutatingOptions
}

type LockResult struct {
	NodeID NodeID    `yson:"node_id"`
	LockID guid.GUID `yson:"lock_id"`
}

type LockRowsOptions struct {
	*TransactionOptions
}

type LockState string

type LockType string

type LookupRowsOptions struct {
	// KeepMissingRows changes handling of missing rows.
	//
	// When this flag is not set, missing rows are skipped.
	// When flag is set, nil values are returned for missing rows.
	KeepMissingRows bool `http:"keep_missing_rows"`

	// Timestamp overrides timestamp for lookup.
	//
	// By default, lookup returns data from the point in time when
	// transaction was started.
	Timestamp *Timestamp `http:"timestamp,omitnil"`

	// Columns filters columns in lookup result.
	Columns []string `http:"column_names,omitnil"`

	*TransactionOptions
}

type LowLevelSchedulerClient interface {
	OperationStartClient

	// http:verb:"abort_operation"
	// http:params:"operation_id"
	AbortOperation(
		ctx context.Context,
		opID OperationID,
		options *AbortOperationOptions,
	) (err error)

	// http:verb:"suspend_operation"
	// http:params:"operation_id"
	SuspendOperation(
		ctx context.Context,
		opID OperationID,
		options *SuspendOperationOptions,
	) (err error)

	// http:verb:"resume_operation"
	// http:params:"operation_id"
	ResumeOperation(
		ctx context.Context,
		opID OperationID,
		options *ResumeOperationOptions,
	) (err error)

	// http:verb:"complete_operation"
	// http:params:"operation_id"
	CompleteOperation(
		ctx context.Context,
		opID OperationID,
		options *CompleteOperationOptions,
	) (err error)

	// http:verb:"update_operation_parameters"
	// http:params:"operation_id","parameters"
	UpdateOperationParameters(
		ctx context.Context,
		opID OperationID,
		params any,
		options *UpdateOperationParametersOptions,
	) (err error)

	// http:verb:"get_operation"
	// http:params:"operation_id"
	GetOperation(
		ctx context.Context,
		opID OperationID,
		options *GetOperationOptions,
	) (status *OperationStatus, err error)

	// http:verb:"get_operation"
	// http:params:"operation_alias"
	GetOperationByAlias(
		ctx context.Context,
		alias string,
		options *GetOperationOptions,
	) (status *OperationStatus, err error)

	// http:verb:"list_operations"
	ListOperations(
		ctx context.Context,
		options *ListOperationsOptions,
	) (operations *ListOperationsResult, err error)

	// http:verb:"list_jobs"
	// http:params:"operation_id"
	ListJobs(
		ctx context.Context,
		opID OperationID,
		options *ListJobsOptions,
	) (r *ListJobsResult, err error)

	// http:verb:"get_job_stderr"
	// http:params:"operation_id","job_id"
	GetJobStderr(
		ctx context.Context,
		opID OperationID,
		jobID JobID,
		options *GetJobStderrOptions,
	) (r []byte, err error)
}

type LowLevelTxClient interface {
	// http:verb:"start_transaction"
	StartTx(
		ctx context.Context,
		options *StartTxOptions,
	) (id TxID, err error)

	// http:verb:"start_transaction"
	StartTabletTx(
		ctx context.Context,
		options *StartTabletTxOptions,
	) (id TxID, err error)

	// http:verb:"ping_transaction"
	// http:params:"transaction_id"
	PingTx(
		ctx context.Context,
		id TxID,
		options *PingTxOptions,
	) (err error)

	// http:verb:"abort_transaction"
	// http:params:"transaction_id"
	AbortTx(
		ctx context.Context,
		id TxID,
		options *AbortTxOptions,
	) (err error)

	// http:verb:"commit_transaction"
	// http:params:"transaction_id"
	CommitTx(
		ctx context.Context,
		id TxID,
		options *CommitTxOptions,
	) (err error)
}

type MaintenanceComponent string

type MaintenanceID guid.GUID

type MaintenanceType string

type MasterReadOptions struct {
	ReadFrom                        ReadKind       `http:"read_from"`
	DisablePerUserCache             *bool          `http:"disable_per_user_cache,omitnil"`
	ExpireAfterSuccessfulUpdateTime *yson.Duration `http:"expire_after_successful_update_time,omitnil"`
	ExpireAfterFailedUpdateTime     *yson.Duration `http:"expire_after_failed_update_time,omitnil"`
	CacheStickyGroupSize            *int32         `http:"cache_sticky_group_size,omitnil"`
	SuccessStalenessBound           *yson.Duration `http:"success_staleness_bound,omitnil"`
}

type MemberInfo struct {
	ID         string
	Priority   int64
	Revision   int64
	Attributes []*Attribute
}

type MountClient interface {
	// http:verb:"mount_table"
	// http:params:"path"
	MountTable(
		ctx context.Context,
		path ypath.Path,
		options *MountTableOptions,
	) (err error)

	// http:verb:"unmount_table"
	// http:params:"path"
	UnmountTable(
		ctx context.Context,
		path ypath.Path,
		options *UnmountTableOptions,
	) (err error)

	// http:verb:"remount_table"
	// http:params:"path"
	RemountTable(
		ctx context.Context,
		path ypath.Path,
		options *RemountTableOptions,
	) (err error)

	// http:verb:"reshard_table"
	// http:params:"path"
	ReshardTable(
		ctx context.Context,
		path ypath.Path,
		options *ReshardTableOptions,
	) (err error)

	// http:verb:"alter_table"
	// http:params:"path"
	AlterTable(
		ctx context.Context,
		path ypath.Path,
		options *AlterTableOptions,
	) (err error)

	// http:verb:"freeze_table"
	// http:params:"path"
	FreezeTable(
		ctx context.Context,
		path ypath.Path,
		options *FreezeTableOptions,
	) (err error)

	// http:verb:"unfreeze_table"
	// http:params:"path"
	UnfreezeTable(
		ctx context.Context,
		path ypath.Path,
		options *UnfreezeTableOptions,
	) (err error)

	// http:verb:"alter_table_replica"
	// http:params:"replica_id"
	AlterTableReplica(
		ctx context.Context,
		id NodeID,
		options *AlterTableReplicaOptions,
	) (err error)
}

type MountTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions

	CellID        *guid.GUID  `http:"cell_id,omitnil"`
	TargetCellIDs []guid.GUID `http:"target_cell_ids,omitnil"`
	Freeze        bool        `http:"freeze"`
}

type MoveNodeOptions struct {
	Recursive bool `http:"recursive"`
	Force     bool `http:"force"`

	PreserveAccount           *bool `http:"preserve_account,omitnil"`
	PreserveExpirationTime    *bool `http:"preserve_expiration_time,omitnil"`
	PreserveExpirationTimeout *bool `http:"preserve_expiration_timeout,omitnil"`
	PessimisticQuotaCheck     *bool `http:"pessimistic_quota_check,omitnil"`

	*TransactionOptions
	// *AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type MultisetAttributesOptions struct {
	*TransactionOptions
	*AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type MutatingOptions struct {
	MutationID MutationID `http:"mutation_id"`
	Retry      bool       `http:"retry"`
}

type MutationID guid.GUID

type NodeAddress struct {
	NodeID    uint              `yson:"node_id"`
	Addresses map[string]string `yson:"addresses"`
}

type NodeExistsOptions struct {
	*MasterReadOptions
	*TransactionOptions
	*AccessTrackingOptions
	*ReadRetryOptions
}

type NodeID guid.GUID

type NodeType string

type OperationID guid.GUID

type OperationResult struct {
	Error *yterrors.Error `yson:"error"`
}

type OperationRuntimeParameters struct {
	ACL                          []ACE          `yson:"acl"`
	SchedulingOptionsPerPoolTree map[string]any `yson:"scheduling_options_per_pool_tree"`
	Annotations                  map[string]any `yson:"annotations"`
	ErasedTrees                  []string       `yson:"erased_trees"`
}

type OperationSortDirection string

type OperationStartClient interface {
	// http:verb:"start_operation"
	// http:params:"operation_type","spec"
	StartOperation(
		ctx context.Context,
		opType OperationType,
		spec any,
		options *StartOperationOptions,
	) (opID OperationID, err error)
}

type OperationState string

type OperationStatus struct {
	ID                OperationID                `yson:"id"`
	State             OperationState             `yson:"state"`
	Result            *OperationResult           `yson:"result"`
	Type              OperationType              `yson:"type"`
	BriefSpec         map[string]any             `yson:"brief_spec"`
	FullSpec          yson.RawValue              `yson:"full_spec"`
	StartTime         yson.Time                  `yson:"start_time"`
	FinishTime        yson.Time                  `yson:"finish_time"`
	Suspend           bool                       `yson:"suspend"`
	AuthenticatedUser string                     `yson:"authenticated_user"`
	RuntimeParameters OperationRuntimeParameters `yson:"runtime_parameters"`
}

type OperationType string

type OrderedTableBackupMode string

type Permission = string

type PingTxOptions struct {
	*TransactionOptions
}

type PrerequisiteOptions struct {
	TransactionIDs []TxID                 `http:"prerequisite_transaction_ids,omitnil"`
	Revisions      []PrerequisiteRevision `http:"prerequisite_revisions,omitnil"`
}

type PrerequisiteRevision struct {
	Path          ypath.Path `yson:"path"`
	TransactionID TxID       `yson:"transaction_id"`
	Revision      Revision   `yson:"revision"`
}

type PutFileToCacheOptions struct {
	CachePath ypath.YPath `http:"cache_path"`

	*MasterReadOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type Query struct {
	ID              QueryID        `yson:"id"`
	Engine          *QueryEngine   `yson:"engine"`
	Query           *string        `yson:"query"`
	StartTime       *yson.Time     `yson:"start_time"`
	FinishTime      *yson.Time     `yson:"finish_time"`
	Settings        any            `yson:"settings"`
	User            *string        `yson:"user"`
	State           *QueryState    `yson:"state"`
	ResultCount     *int64         `yson:"result_count"`
	Progress        any            `yson:"progress"`
	Err             yterrors.Error `yson:"error"`
	Annotations     any            `yson:"annotations"`
	OtherAttributes any            `yson:"other_attributes"`
}

type QueryEngine string

type QueryID guid.GUID

type QueryResult struct {
	ID             QueryID          `yson:"id"`
	ResultIndex    int64            `yson:"result_index"`
	Err            yterrors.Error   `yson:"error"`
	Schema         []map[string]any `yson:"schema"`
	DataStatistics DataStatistics   `yson:"data_statistics"`
}

type QueryState string

type QueryTrackerClient interface {
	// http:verb:"start_query"
	// http:params:"engine","query"
	StartQuery(
		ctx context.Context,
		engine QueryEngine,
		query string,
		options *StartQueryOptions,
	) (id QueryID, err error)

	// http:verb:"abort_query"
	// http:params:"query_id"
	AbortQuery(
		ctx context.Context,
		id QueryID,
		options *AbortQueryOptions,
	) (err error)

	// http:verb:"get_query"
	// http:params:"query_id"
	GetQuery(
		ctx context.Context,
		id QueryID,
		options *GetQueryOptions,
	) (query *Query, err error)

	// http:verb:"list_queries"
	ListQueries(
		ctx context.Context,
		options *ListQueriesOptions,
	) (result *ListQueriesResult, err error)

	// http:verb:"get_query_result"
	// http:params:"query_id","result_index"
	GetQueryResult(
		ctx context.Context,
		id QueryID,
		resultIndex int64,
		options *GetQueryResultOptions,
	) (result *QueryResult, err error)

	// http:verb:"read_query_result"
	// http:params:"query_id","result_index"
	ReadQueryResult(
		ctx context.Context,
		id QueryID,
		resultIndex int64,
		options *ReadQueryResultOptions,
	) (r TableReader, err error)

	// http:verb:"alter_query"
	// http:params:"query_id"
	AlterQuery(
		ctx context.Context,
		id QueryID,
		options *AlterQueryOptions,
	) (err error)
}

type QueryTrackerOptions struct {
	Stage *string `http:"stage,omitnil"`
}

type RangeJobsCallback func(job JobStatus)

type RangeOperationsCallback func(op OperationStatus)

type ReadFileOptions struct {
	Offset     *int64 `http:"offset,omitnil"`
	Length     *int64 `http:"length,omitnil"`
	FileReader any    `http:"file_reader"`

	*TransactionOptions
	*AccessTrackingOptions
}

type ReadKind string

type ReadQueryResultOptions struct {
	Columns       []string `http:"columns,omitnil"`
	LowerRowIndex *int64   `http:"lower_row_index,omitnil"`
	UpperRowIndex *int64   `http:"upper_row_index,omitnil"`

	*QueryTrackerOptions
}

type ReadRetryOptions struct {
}

type ReadTableOptions struct {
	Unordered   bool `http:"unordered"`
	TableReader any  `http:"table_reader"`

	ControlAttributes any   `http:"control_attributes,omitnil"`
	StartRowIndexOnly *bool `http:"start_row_index_only,omitnil"`

	// Smart flag enables client side retries.
	//
	// When used outside of transaction, ReadTable automatically creates new transaction and
	// acquires table snapshot lock.
	//
	// When used inside of transaction, ReadTable does not create any additional transactions.
	//
	// Internal retries continue indefinitely. User must set appropriate timeout on request context.
	//
	// This is experimental option, that is currently off by default.
	Smart *bool

	*TransactionOptions
	*AccessTrackingOptions
}

type RemountTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions
}

type RemoveMaintenanceOptions struct {
	Mine *bool            `http:"mine,omitnil"`
	All  *bool            `http:"all,omitnil"`
	User *string          `http:"user,omitnil"`
	IDs  []MaintenanceID  `http:"ids,omitnil"`
	Type *MaintenanceType `http:"type,omitnil"`
}

type RemoveMaintenanceResponse struct {
	BanCounts                  int `yson:"ban"`
	DecommissionCounts         int `yson:"decommission"`
	DisableSchedulerJobsCounts int `yson:"disable_scheduler_jobs"`
	DisableWriteSessionsCounts int `yson:"disable_write_sessions"`
	DisableTabletCellsCounts   int `yson:"disable_tablet_cells"`
	PendingRestartCounts       int `yson:"pending_restart"`
}

type RemoveMemberOptions struct {
	*MutatingOptions
	*PrerequisiteOptions
}

type RemoveNodeOptions struct {
	Recursive bool `http:"recursive"`
	Force     bool `http:"force"`

	*TransactionOptions
	*AccessTrackingOptions
	*PrerequisiteOptions
	*MutatingOptions
}

type RequestRestartOptions struct {
}

type ReshardTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions

	PivotKeys   any  `http:"pivot_keys,omitnil"`
	TabletCount *int `http:"tablet_count,omitnil"`
}

type RestoreTableBackupOptions struct {
	Force          bool `http:"force"`
	Mount          bool `http:"mount"`
	EnableReplicas bool `http:"enable_replicas"`

	*TimeoutOptions
}

type ResumeOperationOptions struct {
}

type ResurrectChunkLocationsOptions struct {
}

type ResurrectChunkLocationsResponse struct {
	LocationUUIDs []guid.GUID
}

type Revision uint64

type RevokeTokenOptions struct{}

type RowBatch interface {
	// Len returns estimated memory consumption by this object.
	Len() int
}

type RowBatchWriter interface {
	TableWriter

	Batch() RowBatch
}

type SecurityAction string

type SelectRowsOptions struct {
	FailOnIncompleteResult    *bool `http:"fail_on_incomplete_result,omitnil"`
	InputRowLimit             *int  `http:"input_row_limit,omitnil"`
	OutputRowLimit            *int  `http:"output_row_limit,omitnil"`
	UseCanonicalNullRelations *bool `http:"use_canonical_null_relations,omitnil"`

	Timestamp *Timestamp `http:"timestamp,omitnil"`

	PlaceholderValues any `http:"placeholder_values,omitnil"`

	*TransactionOptions
	*TimeoutOptions
}

type ServiceTicketCredentials struct {
	Ticket string
}

type SetNodeOptions struct {
	Recursive bool `http:"recursive"`
	Force     bool `http:"force"`

	*TransactionOptions
	*AccessTrackingOptions
	*MutatingOptions
	*PrerequisiteOptions
}

type SetUserPasswordOptions struct{}

type ShareLocation struct {
	Nodes      []NodeAddress `yson:"nodes"`
	ChunkSpecs []ChunkSpec   `yson:"chunk_specs"`
}

type StartOperationOptions struct {
	*TransactionOptions
	*MutatingOptions
}

type StartQueryOptions struct {
	Settings            any     `http:"settings,omitnil"`
	Draft               *bool   `http:"draft,omitnil"`
	Annotations         any     `http:"annotations,omitnil"`
	AccessControlObject *string `http:"access_control_object,omitnil"`

	*QueryTrackerOptions
}

type StartTabletTxOptions struct {
	Atomicity *Atomicity     `http:"atomicity,omitnil"`
	Timeout   *yson.Duration `http:"timeout,omitnil"`

	Type   TxType `http:"type"`
	Sticky bool   `http:"sticky"`
}

type StartTxOptions struct {
	Timeout  *yson.Duration `http:"timeout,omitnil"`
	Deadline *yson.Time     `http:"deadline,omitnil"`

	Type   *TxType `http:"type,omitnil"`
	Sticky bool    `http:"sticky"`

	PrerequisiteTransactionIDs []TxID         `http:"prerequisite_transaction_ids,omitnil"`
	Attributes                 map[string]any `http:"attributes,omitnil"`

	*TransactionOptions
	*ReadRetryOptions
}

type SuspendOperationOptions struct {
	AbortRunningJobs bool `http:"abort_running_jobs"`
}

type TVMFn func(ctx context.Context) (string, error)

type TableBackupClient interface {
	// http:verb:"create_table_backup"
	// http:params:"manifest"
	CreateTableBackup(
		ctx context.Context,
		manifest BackupManifest,
		options *CreateTableBackupOptions,
	) error

	// http:verb:"restore_table_backup"
	// http:params:"manifest"
	RestoreTableBackup(
		ctx context.Context,
		manifest BackupManifest,
		options *RestoreTableBackupOptions,
	) error
}

type TableBackupManifest struct {
	SourcePath      ypath.Path             `yson:"source_path"`
	DestinationPath ypath.Path             `yson:"destination_path"`
	OrderedMode     OrderedTableBackupMode `yson:"ordered_mode,omitempty"`
}

type TableClient interface {
	// WriteTable opens low-level table writer. Use yt.WriteTable() function instead of calling this method directly.
	//
	// http:verb:"write_table"
	// http:params:"path"
	WriteTable(
		ctx context.Context,
		path ypath.YPath,
		options *WriteTableOptions,
	) (w TableWriter, err error)

	// http:verb:"read_table"
	// http:params:"path"
	ReadTable(
		ctx context.Context,
		path ypath.YPath,
		options *ReadTableOptions,
	) (r TableReader, err error)
}

type TableReader interface {
	// Scan unmarshals current row into value.
	//
	// It is safe to call Scan multiple times for a single row.
	Scan(value any) error

	// Next prepares the next result row for reading with the Scan method.
	//
	// It returns true on success, or false if there is no next result row or an error
	// happened while preparing it. Err should be consulted to distinguish between the two cases.
	Next() bool

	// Err returns error that occurred during read.
	Err() error

	// Close frees any associated resources.
	//
	// User MUST call Close(). Failure to do so will result in resource leak.
	//
	// Error returned from Close() may be safely ignored.
	Close() error
}

type TableReplicaMode string

type TableWriter interface {
	// Write writes single row.
	//
	// Error returned from write indicates that the whole write operation has failed.
	Write(value any) error

	// Commit closes table writer.
	Commit() error

	// Rollback aborts table upload and frees associated resources.
	//
	// It is safe to call Rollback() concurrently with Write or Commit.
	//
	// Rollback blocks until upload transaction is aborted.
	//
	// If you need to cancel table writer without blocking, use context cancelFunc.
	//
	// Error returned from Rollback() may be safely ignored.
	Rollback() error
}

type TabletClient interface {
	// SelectRows executes query.
	//
	// Use strconv.Quote or %q format to escape string literals inside query.
	//
	// http:verb:"select_rows"
	// http:params:"query"
	SelectRows(
		ctx context.Context,
		query string,
		options *SelectRowsOptions,
	) (r TableReader, err error)

	// LookupRows performs lookup by key.
	//
	// Rows are returned in the order of provided keys.
	//
	// By default, returns one row for each key that is present in the table.
	//
	// When KeepMissingRows option is set, returns exactly len(keys) number of rows. If key is missing
	// from the table, corresponding row will be nil.
	//
	// http:verb:"lookup_rows"
	// http:params:"path"
	// http:extra
	LookupRows(
		ctx context.Context,
		path ypath.Path,
		keys []any,
		options *LookupRowsOptions,
	) (r TableReader, err error)

	// LockRows acquires lock for given keys, without changing row values.
	//
	// http:verb:"lock_rows"
	// http:params:"path","locks","lock_type"
	// http:extra
	LockRows(
		ctx context.Context,
		path ypath.Path,
		locks []string,
		lockType LockType,
		keys []any,
		options *LockRowsOptions,
	) (err error)

	// http:verb:"insert_rows"
	// http:params:"path"
	// http:extra
	InsertRows(
		ctx context.Context,
		path ypath.Path,
		rows []any,
		options *InsertRowsOptions,
	) (err error)

	// InsertRowBatch is API optimized for performance.
	//
	// It works just like InsertRows, but allows serializing rows ahead of time.
	InsertRowBatch(
		ctx context.Context,
		path ypath.Path,
		rowBatch RowBatch,
		options *InsertRowsOptions,
	) (err error)

	// http:verb:"delete_rows"
	// http:params:"path"
	// http:extra
	DeleteRows(
		ctx context.Context,
		path ypath.Path,
		keys []any,
		options *DeleteRowsOptions,
	) (err error)
}

type TabletRangeOptions struct {
	FirstTabletIndex int `http:"first_tablet_index"`
	LastTabletIndex  int `http:"last_tablet_index"`
}

type TabletTx interface {
	TabletClient

	ID() TxID
	Commit() error
	Abort() error
}

type TabletTxFunc func(ctx context.Context, tx TabletTx) error

type TimeoutOptions struct {
	Timeout yson.Duration `http:"timeout"`
}

type Timestamp uint64

type TokenCredentials struct {
	Token string
}

type TraceFn func(ctx context.Context) (traceID guid.GUID, spanID uint64, flags byte, ok bool)

type TrackQueryOptions struct {
	Logger     log.Structured
	PollPeriod *time.Duration
	*QueryTrackerOptions
}

type TransactionOptions struct {
	TransactionID                      TxID `http:"transaction_id"`
	Ping                               bool `http:"ping"`
	PingAncestors                      bool `http:"ping_ancestor_transactions"`
	SuppressTransactionCoordinatorSync bool `http:"suppress_transaction_coordinator_sync"`
	SuppressUpstreamSync               bool `http:"suppress_upstream_sync"`
}

type TransferAccountResourcesOptions struct {
	*MutatingOptions
}

type TransferPoolResourcesOptions struct {
	*MutatingOptions
}

type Tx interface {
	CypressClient
	FileClient
	TableClient
	LockClient

	OperationStartClient

	ID() TxID
	Commit() error
	Abort() error

	// Finished returns a channel that is closed when transaction finishes, either because it was committed or aborted.
	Finished() <-chan struct{}

	// BeginTx creates nested transaction.
	BeginTx(ctx context.Context, options *StartTxOptions) (tx Tx, err error)
}

type TxFunc func(ctx context.Context, tx Tx) error

type TxID guid.GUID

type TxType string

type UnfreezeTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions
}

type UnlockNodeOptions struct {
	*TransactionOptions
	*MutatingOptions
}

type UnmountTableOptions struct {
	*TabletRangeOptions
	*MutatingOptions

	Force bool `http:"force"`
}

type UpdateOperationParametersOptions struct {
}

type UserTicketCredentials struct {
	Ticket string
}

type WriteFileOptions struct {
	ComputeMD5 bool `http:"compute_md5"`
	FileWriter any  `http:"file_writer"`

	*TransactionOptions
	*PrerequisiteOptions
}

type WriteTableOption func(*tableWriter)

type WriteTableOptions struct {
	TableWriter any `http:"table_writer"`

	*TransactionOptions
	*AccessTrackingOptions
}