Update ytyndexer to sbr:5704224018

11 files changed, 698 insertions, 1034 deletions

diff --git a/yt/yt/client/api/delegating_client.cpp b/yt/yt/client/api/delegating_client.cpp
index 81405fbfbe..d71befc402 100644
--- a/yt/yt/client/api/delegating_client.cpp
+++ b/yt/yt/client/api/delegating_client.cpp
@@ -8,758 +8,6 @@ TDelegatingClient::TDelegatingClient(IClientPtr underlying)
     : Underlying_(std::move(underlying))
 { }
 
-#define DELEGATE_METHOD(returnType, method, signature, args) \
-    returnType TDelegatingClient::method signature \
-    { \
-        return Underlying_->method args; \
-    }
-
-DELEGATE_METHOD(IConnectionPtr, GetConnection, (), ())
-
-DELEGATE_METHOD(std::optional<TStringBuf>, GetClusterName,
-    (bool fetchIfNull),
-    (fetchIfNull))
-
-DELEGATE_METHOD(TFuture<ITransactionPtr>, StartTransaction, (
-    NTransactionClient::ETransactionType type,
-    const TTransactionStartOptions& options),
-    (type, options))
-
-DELEGATE_METHOD(TFuture<TUnversionedLookupRowsResult>, LookupRows, (
-    const NYPath::TYPath& path,
-    NTableClient::TNameTablePtr nameTable,
-    const TSharedRange<NTableClient::TLegacyKey>& keys,
-    const TLookupRowsOptions& options),
-    (path, nameTable, keys, options))
-
-DELEGATE_METHOD(TFuture<TVersionedLookupRowsResult>, VersionedLookupRows, (
-    const NYPath::TYPath& path,
-    NTableClient::TNameTablePtr nameTable,
-    const TSharedRange<NTableClient::TLegacyKey>& keys,
-    const TVersionedLookupRowsOptions& options),
-    (path, nameTable, keys, options))
-
-DELEGATE_METHOD(TFuture<std::vector<TUnversionedLookupRowsResult>>, MultiLookupRows, (
-    const std::vector<TMultiLookupSubrequest>& subrequests,
-    const TMultiLookupOptions& options),
-    (subrequests, options))
-
-DELEGATE_METHOD(TFuture<TSelectRowsResult>, SelectRows, (
-    const TString& query,
-    const TSelectRowsOptions& options),
-    (query, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, ExplainQuery, (
-    const TString& query,
-    const TExplainQueryOptions& options),
-    (query, options))
-
-DELEGATE_METHOD(TFuture<TPullRowsResult>, PullRows, (
-    const NYPath::TYPath& path,
-    const TPullRowsOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<ITableReaderPtr>, CreateTableReader, (
-    const NYPath::TRichYPath& path,
-    const TTableReaderOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<ITableWriterPtr>, CreateTableWriter, (
-    const NYPath::TRichYPath& path,
-    const TTableWriterOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<NQueueClient::IQueueRowsetPtr>, PullQueue, (
-    const NYPath::TRichYPath& queuePath,
-    i64 offset,
-    int partitionIndex,
-    const NQueueClient::TQueueRowBatchReadOptions& rowBatchReadOptions,
-    const TPullQueueOptions& options),
-    (queuePath, offset, partitionIndex, rowBatchReadOptions, options))
-
-DELEGATE_METHOD(TFuture<NQueueClient::IQueueRowsetPtr>, PullConsumer, (
-    const NYPath::TRichYPath& consumerPath,
-    const NYPath::TRichYPath& queuePath,
-    std::optional<i64> offset,
-    int partitionIndex,
-    const NQueueClient::TQueueRowBatchReadOptions& rowBatchReadOptions,
-    const TPullConsumerOptions& options),
-    (consumerPath, queuePath, offset, partitionIndex, rowBatchReadOptions, options))
-
-DELEGATE_METHOD(TFuture<void>, RegisterQueueConsumer, (
-    const NYPath::TRichYPath& queuePath,
-    const NYPath::TRichYPath& consumerPath,
-    bool vital,
-    const TRegisterQueueConsumerOptions& options),
-    (queuePath, consumerPath, vital, options))
-
-DELEGATE_METHOD(TFuture<void>, UnregisterQueueConsumer, (
-    const NYPath::TRichYPath& queuePath,
-    const NYPath::TRichYPath& consumerPath,
-    const TUnregisterQueueConsumerOptions& options),
-    (queuePath, consumerPath, options))
-
-DELEGATE_METHOD(TFuture<std::vector<TListQueueConsumerRegistrationsResult>>, ListQueueConsumerRegistrations, (
-    const std::optional<NYPath::TRichYPath>& queuePath,
-    const std::optional<NYPath::TRichYPath>& consumerPath,
-    const TListQueueConsumerRegistrationsOptions& options),
-    (queuePath, consumerPath, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetNode, (
-    const NYPath::TYPath& path,
-    const TGetNodeOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, SetNode, (
-    const NYPath::TYPath& path,
-    const NYson::TYsonString& value,
-    const TSetNodeOptions& options),
-    (path, value, options))
-
-DELEGATE_METHOD(TFuture<void>, MultisetAttributesNode, (
-    const NYPath::TYPath& path,
-    const NYTree::IMapNodePtr& attributes,
-    const TMultisetAttributesNodeOptions& options),
-    (path, attributes, options))
-
-DELEGATE_METHOD(TFuture<void>, RemoveNode, (
-    const NYPath::TYPath& path,
-    const TRemoveNodeOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, ListNode, (
-    const NYPath::TYPath& path,
-    const TListNodeOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, CreateNode, (
-    const NYPath::TYPath& path,
-    NObjectClient::EObjectType type,
-    const TCreateNodeOptions& options),
-    (path, type, options))
-
-DELEGATE_METHOD(TFuture<TLockNodeResult>, LockNode, (
-    const NYPath::TYPath& path,
-    NCypressClient::ELockMode mode,
-    const TLockNodeOptions& options),
-    (path, mode, options))
-
-DELEGATE_METHOD(TFuture<void>, UnlockNode, (
-    const NYPath::TYPath& path,
-    const TUnlockNodeOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, CopyNode, (
-    const NYPath::TYPath& srcPath,
-    const NYPath::TYPath& dstPath,
-    const TCopyNodeOptions& options),
-    (srcPath, dstPath, options))
-
-DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, MoveNode, (
-    const NYPath::TYPath& srcPath,
-    const NYPath::TYPath& dstPath,
-    const TMoveNodeOptions& options),
-    (srcPath, dstPath, options))
-
-DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, LinkNode, (
-    const NYPath::TYPath& srcPath,
-    const NYPath::TYPath& dstPath,
-    const TLinkNodeOptions& options),
-    (srcPath, dstPath, options))
-
-DELEGATE_METHOD(TFuture<void>, ConcatenateNodes, (
-    const std::vector<NYPath::TRichYPath>& srcPaths,
-    const NYPath::TRichYPath& dstPath,
-    const TConcatenateNodesOptions& options),
-    (srcPaths, dstPath, options))
-
-DELEGATE_METHOD(TFuture<bool>, NodeExists, (
-    const NYPath::TYPath& path,
-    const TNodeExistsOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, ExternalizeNode, (
-    const NYPath::TYPath& path,
-    NObjectClient::TCellTag cellTag,
-    const TExternalizeNodeOptions& options),
-    (path, cellTag, options))
-
-DELEGATE_METHOD(TFuture<void>, InternalizeNode, (
-    const NYPath::TYPath& path,
-    const TInternalizeNodeOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<NObjectClient::TObjectId>, CreateObject, (
-    NObjectClient::EObjectType type,
-    const TCreateObjectOptions& options),
-    (type, options))
-
-DELEGATE_METHOD(TFuture<IFileReaderPtr>, CreateFileReader, (
-    const NYPath::TYPath& path,
-    const TFileReaderOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(IFileWriterPtr, CreateFileWriter, (
-    const NYPath::TRichYPath& path,
-    const TFileWriterOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(IJournalReaderPtr, CreateJournalReader, (
-    const NYPath::TYPath& path,
-    const TJournalReaderOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(IJournalWriterPtr, CreateJournalWriter, (
-    const NYPath::TYPath& path,
-    const TJournalWriterOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(void, Terminate, (), ())
-
-DELEGATE_METHOD(const NTabletClient::ITableMountCachePtr&, GetTableMountCache, (), ())
-
-DELEGATE_METHOD(const NChaosClient::IReplicationCardCachePtr&, GetReplicationCardCache, (), ())
-
-DELEGATE_METHOD(const NTransactionClient::ITimestampProviderPtr&, GetTimestampProvider, (), ())
-
-DELEGATE_METHOD(ITransactionPtr, AttachTransaction, (
-    NTransactionClient::TTransactionId transactionId,
-    const TTransactionAttachOptions& options),
-    (transactionId, options))
-
-DELEGATE_METHOD(TFuture<void>, MountTable, (
-    const NYPath::TYPath& path,
-    const TMountTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, UnmountTable, (
-    const NYPath::TYPath& path,
-    const TUnmountTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, RemountTable, (
-    const NYPath::TYPath& path,
-    const TRemountTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, FreezeTable, (
-    const NYPath::TYPath& path,
-    const TFreezeTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, UnfreezeTable, (
-    const NYPath::TYPath& path,
-    const TUnfreezeTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, ReshardTable, (
-    const NYPath::TYPath& path,
-    const std::vector<NTableClient::TLegacyOwningKey>& pivotKeys,
-    const TReshardTableOptions& options),
-    (path, pivotKeys, options))
-
-DELEGATE_METHOD(TFuture<void>, ReshardTable, (
-    const NYPath::TYPath& path,
-    int tabletCount,
-    const TReshardTableOptions& options),
-    (path, tabletCount, options))
-
-DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTabletActionId>>, ReshardTableAutomatic, (
-    const NYPath::TYPath& path,
-    const TReshardTableAutomaticOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, TrimTable, (
-    const NYPath::TYPath& path,
-    int tabletIndex,
-    i64 trimmedRowCount,
-    const TTrimTableOptions& options),
-    (path, tabletIndex, trimmedRowCount, options))
-
-DELEGATE_METHOD(TFuture<void>, AlterTable, (
-    const NYPath::TYPath& path,
-    const TAlterTableOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, AlterTableReplica, (
-    NTabletClient::TTableReplicaId replicaId,
-    const TAlterTableReplicaOptions& options),
-    (replicaId, options))
-
-DELEGATE_METHOD(TFuture<void>, AlterReplicationCard, (
-    NChaosClient::TReplicationCardId replicationCardId,
-    const TAlterReplicationCardOptions& options),
-    (replicationCardId, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetTablePivotKeys, (
-    const NYPath::TYPath& path,
-    const TGetTablePivotKeysOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<void>, CreateTableBackup, (
-    const TBackupManifestPtr& manifest,
-    const TCreateTableBackupOptions& options),
-    (manifest, options))
-
-DELEGATE_METHOD(TFuture<void>, RestoreTableBackup, (
-    const TBackupManifestPtr& manifest,
-    const TRestoreTableBackupOptions& options),
-    (manifest, options))
-
-DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTableReplicaId>>, GetInSyncReplicas, (
-    const NYPath::TYPath& path,
-    const NTableClient::TNameTablePtr& nameTable,
-    const TSharedRange<NTableClient::TLegacyKey>& keys,
-    const TGetInSyncReplicasOptions& options),
-    (path, nameTable, keys, options))
-
-DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTableReplicaId>>, GetInSyncReplicas, (
-    const NYPath::TYPath& path,
-    const TGetInSyncReplicasOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<std::vector<TTabletInfo>>, GetTabletInfos, (
-    const NYPath::TYPath& path,
-    const std::vector<int>& tabletIndexes,
-    const TGetTabletInfosOptions& options),
-    (path, tabletIndexes, options))
-
-DELEGATE_METHOD(TFuture<TGetTabletErrorsResult>, GetTabletErrors, (
-    const NYPath::TYPath& path,
-    const TGetTabletErrorsOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTabletActionId>>, BalanceTabletCells, (
-    const TString& tabletCellBundle,
-    const std::vector<NYPath::TYPath>& movableTables,
-    const TBalanceTabletCellsOptions& options),
-    (tabletCellBundle, movableTables, options))
-
-DELEGATE_METHOD(TFuture<NChaosClient::TReplicationCardPtr>, GetReplicationCard, (
-    NChaosClient::TReplicationCardId replicationCardId,
-    const TGetReplicationCardOptions& options),
-    (replicationCardId, options))
-
-DELEGATE_METHOD(TFuture<void>, UpdateChaosTableReplicaProgress, (
-    NChaosClient::TReplicaId replicaId,
-    const TUpdateChaosTableReplicaProgressOptions& options),
-    (replicaId, options))
-
-DELEGATE_METHOD(TFuture<TSkynetSharePartsLocationsPtr>, LocateSkynetShare, (
-    const NYPath::TRichYPath& path,
-    const TLocateSkynetShareOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<std::vector<NTableClient::TColumnarStatistics>>, GetColumnarStatistics, (
-    const std::vector<NYPath::TRichYPath>& path,
-    const TGetColumnarStatisticsOptions& options),
-    (path, options))
-
-DELEGATE_METHOD(TFuture<TMultiTablePartitions>, PartitionTables, (
-    const std::vector<NYPath::TRichYPath>& paths,
-    const TPartitionTablesOptions& options),
-    (paths, options))
-
-DELEGATE_METHOD(TFuture<void>, TruncateJournal, (
-    const NYPath::TYPath& path,
-    i64 rowCount,
-    const TTruncateJournalOptions& options),
-    (path, rowCount, options))
-
-DELEGATE_METHOD(TFuture<TGetFileFromCacheResult>, GetFileFromCache, (
-    const TString& md5,
-    const TGetFileFromCacheOptions& options),
-    (md5, options))
-
-DELEGATE_METHOD(TFuture<TPutFileToCacheResult>, PutFileToCache, (
-    const NYPath::TYPath& path,
-    const TString& expectedMD5,
-    const TPutFileToCacheOptions& options),
-    (path, expectedMD5, options))
-
-DELEGATE_METHOD(TFuture<void>, AddMember, (
-    const TString& group,
-    const TString& member,
-    const TAddMemberOptions& options),
-    (group, member, options))
-
-DELEGATE_METHOD(TFuture<void>, RemoveMember, (
-    const TString& group,
-    const TString& member,
-    const TRemoveMemberOptions& options),
-    (group, member, options))
-
-DELEGATE_METHOD(TFuture<TCheckPermissionResponse>, CheckPermission, (
-    const TString& user,
-    const NYPath::TYPath& path,
-    NYTree::EPermission permission,
-    const TCheckPermissionOptions& options),
-    (user, path, permission, options))
-
-DELEGATE_METHOD(TFuture<TCheckPermissionByAclResult>, CheckPermissionByAcl, (
-    const std::optional<TString>& user,
-    NYTree::EPermission permission,
-    NYTree::INodePtr acl,
-    const TCheckPermissionByAclOptions& options),
-    (user, permission, acl, options))
-
-DELEGATE_METHOD(TFuture<void>, TransferAccountResources, (
-    const TString& srcAccount,
-    const TString& dstAccount,
-    NYTree::INodePtr resourceDelta,
-    const TTransferAccountResourcesOptions& options),
-    (srcAccount, dstAccount, resourceDelta, options))
-
-DELEGATE_METHOD(TFuture<void>, TransferPoolResources, (
-    const TString& srcPool,
-    const TString& dstPool,
-    const TString& poolTree,
-    NYTree::INodePtr resourceDelta,
-    const TTransferPoolResourcesOptions& options),
-    (srcPool, dstPool, poolTree, resourceDelta, options))
-
-DELEGATE_METHOD(TFuture<NScheduler::TOperationId>, StartOperation, (
-    NScheduler::EOperationType type,
-    const NYson::TYsonString& spec,
-    const TStartOperationOptions& options),
-    (type, spec, options))
-
-DELEGATE_METHOD(TFuture<void>, AbortOperation, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TAbortOperationOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<void>, SuspendOperation, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TSuspendOperationOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<void>, ResumeOperation, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TResumeOperationOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<void>, CompleteOperation, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TCompleteOperationOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<void>, UpdateOperationParameters, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const NYson::TYsonString& parameters,
-    const TUpdateOperationParametersOptions& options),
-    (operationIdOrAlias, parameters, options))
-
-DELEGATE_METHOD(TFuture<TOperation>, GetOperation, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TGetOperationOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<void>, DumpJobContext, (
-    NJobTrackerClient::TJobId jobId,
-    const NYPath::TYPath& path,
-    const TDumpJobContextOptions& options),
-    (jobId, path, options))
-
-DELEGATE_METHOD(TFuture<NConcurrency::IAsyncZeroCopyInputStreamPtr>, GetJobInput, (
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobInputOptions& options),
-    (jobId, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJobInputPaths, (
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobInputPathsOptions& options),
-    (jobId, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJobSpec, (
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobSpecOptions& options),
-    (jobId, options))
-
-DELEGATE_METHOD(TFuture<TSharedRef>, GetJobStderr, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobStderrOptions& options),
-    (operationIdOrAlias, jobId, options))
-
-DELEGATE_METHOD(TFuture<TSharedRef>, GetJobFailContext, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobFailContextOptions& options),
-    (operationIdOrAlias, jobId, options))
-
-DELEGATE_METHOD(TFuture<TListOperationsResult>, ListOperations, (
-    const TListOperationsOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<TListJobsResult>, ListJobs, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    const TListJobsOptions& options),
-    (operationIdOrAlias, options))
-
-DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJob, (
-    const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-    NJobTrackerClient::TJobId jobId,
-    const TGetJobOptions& options),
-    (operationIdOrAlias, jobId, options))
-
-DELEGATE_METHOD(TFuture<void>, AbandonJob, (
-    NJobTrackerClient::TJobId jobId,
-    const TAbandonJobOptions& options),
-    (jobId, options))
-
-DELEGATE_METHOD(TFuture<TPollJobShellResponse>, PollJobShell, (
-    NJobTrackerClient::TJobId jobId,
-    const std::optional<TString>& shellName,
-    const NYson::TYsonString& parameters,
-    const TPollJobShellOptions& options),
-    (jobId, shellName, parameters, options))
-
-DELEGATE_METHOD(TFuture<void>, AbortJob, (
-    NJobTrackerClient::TJobId jobId,
-    const TAbortJobOptions& options),
-    (jobId, options))
-
-DELEGATE_METHOD(TFuture<TClusterMeta>, GetClusterMeta, (
-    const TGetClusterMetaOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<void>, CheckClusterLiveness, (
-    const TCheckClusterLivenessOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<int>, BuildSnapshot, (
-    const TBuildSnapshotOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<TCellIdToSnapshotIdMap>, BuildMasterSnapshots, (
-    const TBuildMasterSnapshotsOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<void>, ExitReadOnly, (
-    NHydra::TCellId cellId,
-    const TExitReadOnlyOptions& options),
-    (cellId, options))
-
-DELEGATE_METHOD(TFuture<void>, MasterExitReadOnly, (
-    const TMasterExitReadOnlyOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<void>, DiscombobulateNonvotingPeers, (
-    NHydra::TCellId cellId,
-    const TDiscombobulateNonvotingPeersOptions& options),
-    (cellId, options))
-
-DELEGATE_METHOD(TFuture<void>, SwitchLeader, (
-    NHydra::TCellId cellId,
-    const TString& newLeaderAddress,
-    const TSwitchLeaderOptions& options),
-    (cellId, newLeaderAddress, options))
-
-DELEGATE_METHOD(TFuture<void>, ResetStateHash, (
-    NHydra::TCellId cellId,
-    const TResetStateHashOptions& options),
-    (cellId, options))
-
-DELEGATE_METHOD(TFuture<void>, GCCollect, (
-    const TGCCollectOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<void>, KillProcess, (
-    const TString& address,
-    const TKillProcessOptions& options),
-    (address, options))
-
-DELEGATE_METHOD(TFuture<TString>, WriteCoreDump, (
-    const TString& address,
-    const TWriteCoreDumpOptions& options),
-    (address, options))
-
-DELEGATE_METHOD(TFuture<TGuid>, WriteLogBarrier, (
-    const TString& address,
-    const TWriteLogBarrierOptions& options),
-    (address, options))
-
-DELEGATE_METHOD(TFuture<TString>, WriteOperationControllerCoreDump, (
-    NJobTrackerClient::TOperationId operationId,
-    const TWriteOperationControllerCoreDumpOptions& options),
-    (operationId, options))
-
-DELEGATE_METHOD(TFuture<void>, HealExecNode, (
-    const TString& address,
-    const THealExecNodeOptions& options),
-    (address, options))
-
-DELEGATE_METHOD(TFuture<void>, SuspendCoordinator, (
-    NObjectClient::TCellId coordinatorCellId,
-    const TSuspendCoordinatorOptions& options),
-    (coordinatorCellId, options))
-
-DELEGATE_METHOD(TFuture<void>, ResumeCoordinator, (
-    NObjectClient::TCellId coordinatorCellId,
-    const TResumeCoordinatorOptions& options),
-    (coordinatorCellId, options))
-
-DELEGATE_METHOD(TFuture<void>, MigrateReplicationCards, (
-    NObjectClient::TCellId chaosCellId,
-    const TMigrateReplicationCardsOptions& options),
-    (chaosCellId, options))
-
-DELEGATE_METHOD(TFuture<void>, SuspendChaosCells, (
-    const std::vector<NObjectClient::TCellId>& cellIds,
-    const TSuspendChaosCellsOptions& options),
-    (cellIds, options))
-
-DELEGATE_METHOD(TFuture<void>, ResumeChaosCells, (
-    const std::vector<NObjectClient::TCellId>& cellIds,
-    const TResumeChaosCellsOptions& options),
-    (cellIds, options))
-
-DELEGATE_METHOD(TFuture<void>, SuspendTabletCells, (
-    const std::vector<NObjectClient::TCellId>& cellIds,
-    const TSuspendTabletCellsOptions& options),
-    (cellIds, options))
-
-DELEGATE_METHOD(TFuture<void>, ResumeTabletCells, (
-    const std::vector<NObjectClient::TCellId>& cellIds,
-    const TResumeTabletCellsOptions& options),
-    (cellIds, options))
-
-DELEGATE_METHOD(TFuture<TMaintenanceId>, AddMaintenance, (
-    EMaintenanceComponent component,
-    const TString& address,
-    EMaintenanceType type,
-    const TString& comment,
-    const TAddMaintenanceOptions& options),
-    (component, address, type, comment, options))
-
-DELEGATE_METHOD(TFuture<TMaintenanceCounts>, RemoveMaintenance, (
-    EMaintenanceComponent component,
-    const TString& address,
-    const TMaintenanceFilter& filter,
-    const TRemoveMaintenanceOptions& options),
-    (component, address, filter, options))
-
-DELEGATE_METHOD(TFuture<TDisableChunkLocationsResult>, DisableChunkLocations, (
-    const TString& nodeAddress,
-    const std::vector<TGuid>& locationUuids,
-    const TDisableChunkLocationsOptions& options),
-    (nodeAddress, locationUuids, options))
-
-DELEGATE_METHOD(TFuture<TDestroyChunkLocationsResult>, DestroyChunkLocations, (
-    const TString& nodeAddress,
-    bool recoverUnlinkedDisks,
-    const std::vector<TGuid>& locationUuids,
-    const TDestroyChunkLocationsOptions& options),
-    (nodeAddress, recoverUnlinkedDisks, locationUuids, options))
-
-DELEGATE_METHOD(TFuture<TResurrectChunkLocationsResult>, ResurrectChunkLocations, (
-    const TString& nodeAddress,
-    const std::vector<TGuid>& locationUuids,
-    const TResurrectChunkLocationsOptions& options),
-    (nodeAddress, locationUuids, options))
-
-DELEGATE_METHOD(TFuture<TRequestRestartResult>, RequestRestart, (
-    const TString& nodeAddress,
-    const TRequestRestartOptions& options),
-    (nodeAddress, options))
-
-DELEGATE_METHOD(TFuture<void>, SetUserPassword, (
-    const TString& user,
-    const TString& currentPasswordSha256,
-    const TString& newPasswordSha256,
-    const TSetUserPasswordOptions& options),
-    (user, currentPasswordSha256, newPasswordSha256, options))
-
-DELEGATE_METHOD(TFuture<TIssueTokenResult>, IssueToken, (
-    const TString& user,
-    const TString& passwordSha256,
-    const TIssueTokenOptions& options),
-    (user, passwordSha256, options))
-
-DELEGATE_METHOD(TFuture<void>, RevokeToken, (
-    const TString& user,
-    const TString& passwordSha256,
-    const TString& tokenSha256,
-    const TRevokeTokenOptions& options),
-    (user, passwordSha256, tokenSha256, options))
-
-DELEGATE_METHOD(TFuture<TListUserTokensResult>, ListUserTokens, (
-    const TString& user,
-    const TString& passwordSha256,
-    const TListUserTokensOptions& options),
-    (user, passwordSha256, options))
-
-DELEGATE_METHOD(TFuture<NQueryTrackerClient::TQueryId>, StartQuery, (
-    NQueryTrackerClient::EQueryEngine engine,
-    const TString& query,
-    const TStartQueryOptions& options),
-    (engine, query, options))
-
-DELEGATE_METHOD(TFuture<void>, AbortQuery, (
-    NQueryTrackerClient::TQueryId queryId,
-    const TAbortQueryOptions& options),
-    (queryId, options))
-
-DELEGATE_METHOD(TFuture<TQueryResult>, GetQueryResult, (
-    NQueryTrackerClient::TQueryId queryId,
-    i64 resultIndex,
-    const TGetQueryResultOptions& options),
-    (queryId, resultIndex, options))
-
-DELEGATE_METHOD(TFuture<IUnversionedRowsetPtr>, ReadQueryResult, (
-    NQueryTrackerClient::TQueryId queryId,
-    i64 resultIndex,
-    const TReadQueryResultOptions& options),
-    (queryId, resultIndex, options))
-
-DELEGATE_METHOD(TFuture<TQuery>, GetQuery, (
-    NQueryTrackerClient::TQueryId queryId,
-    const TGetQueryOptions& options),
-    (queryId, options))
-
-DELEGATE_METHOD(TFuture<TListQueriesResult>, ListQueries, (
-    const TListQueriesOptions& options),
-    (options))
-
-DELEGATE_METHOD(TFuture<void>, AlterQuery, (
-    NQueryTrackerClient::TQueryId queryId,
-    const TAlterQueryOptions& options),
-    (queryId, options))
-
-DELEGATE_METHOD(TFuture<NBundleControllerClient::TBundleConfigDescriptorPtr>, GetBundleConfig, (
-    const TString& bundleName,
-    const NBundleControllerClient::TGetBundleConfigOptions& options),
-    (bundleName, options))
-
-DELEGATE_METHOD(TFuture<void>, SetBundleConfig, (
-    const TString& bundleName,
-    const NBundleControllerClient::TBundleTargetConfigPtr& bundleConfig,
-    const NBundleControllerClient::TSetBundleConfigOptions& options),
-    (bundleName, bundleConfig, options))
-
-DELEGATE_METHOD(TFuture<void>, StartPipeline, (
-    const NYPath::TYPath& pipelinePath,
-    const TStartPipelineOptions& options),
-    (pipelinePath, options))
-
-DELEGATE_METHOD(TFuture<void>, StopPipeline, (
-    const NYPath::TYPath& pipelinePath,
-    const TStopPipelineOptions& options),
-    (pipelinePath, options))
-
-DELEGATE_METHOD(TFuture<void>, PausePipeline, (
-    const NYPath::TYPath& pipelinePath,
-    const TPausePipelineOptions& options),
-    (pipelinePath, options))
-
-DELEGATE_METHOD(TFuture<TPipelineStatus>, GetPipelineStatus, (
-    const NYPath::TYPath& pipelinePath,
-    const TGetPipelineStatusOptions& options),
-    (pipelinePath, options))
-
-#undef DELEGATE_METHOD
-
 ////////////////////////////////////////////////////////////////////////////////
 
 // Ensure that delegating client contains implementations for all
diff --git a/yt/yt/client/api/delegating_client.h b/yt/yt/client/api/delegating_client.h
index 92920239d2..b201ae594d 100644
--- a/yt/yt/client/api/delegating_client.h
+++ b/yt/yt/client/api/delegating_client.h
@@ -14,639 +14,798 @@ class TDelegatingClient
 public:
     explicit TDelegatingClient(IClientPtr underlying);
 
+    #define DELEGATE_METHOD(returnType, method, signature, args) \
+        returnType method signature override \
+        { \
+            return Underlying_->method args; \
+        }
+
     // IClientBase methods
+    DELEGATE_METHOD(IConnectionPtr, GetConnection, (), ())
+
+    DELEGATE_METHOD(std::optional<TStringBuf>, GetClusterName,
+        (bool fetchIfNull),
+        (fetchIfNull))
+
+    // IClient methods
+    DELEGATE_METHOD(void, Terminate, (), ())
 
-    IConnectionPtr GetConnection() override;
-    std::optional<TStringBuf> GetClusterName(bool fetchIfNull = true) override;
+    DELEGATE_METHOD(const NTabletClient::ITableMountCachePtr&, GetTableMountCache, (), ())
+
+    DELEGATE_METHOD(const NChaosClient::IReplicationCardCachePtr&, GetReplicationCardCache, (), ())
+
+    DELEGATE_METHOD(const NTransactionClient::ITimestampProviderPtr&, GetTimestampProvider, (), ())
 
     // Transactions
-    TFuture<ITransactionPtr> StartTransaction(
+    DELEGATE_METHOD(TFuture<ITransactionPtr>, StartTransaction, (
         NTransactionClient::ETransactionType type,
-        const TTransactionStartOptions& options = {}) override;
+        const TTransactionStartOptions& options),
+        (type, options))
 
     // Tables
-    TFuture<TUnversionedLookupRowsResult> LookupRows(
+    DELEGATE_METHOD(TFuture<TUnversionedLookupRowsResult>, LookupRows, (
         const NYPath::TYPath& path,
         NTableClient::TNameTablePtr nameTable,
         const TSharedRange<NTableClient::TLegacyKey>& keys,
-        const TLookupRowsOptions& options = {}) override;
+        const TLookupRowsOptions& options),
+        (path, nameTable, keys, options))
 
-    TFuture<TVersionedLookupRowsResult> VersionedLookupRows(
+    DELEGATE_METHOD(TFuture<TVersionedLookupRowsResult>, VersionedLookupRows, (
         const NYPath::TYPath& path,
         NTableClient::TNameTablePtr nameTable,
         const TSharedRange<NTableClient::TLegacyKey>& keys,
-        const TVersionedLookupRowsOptions& options = {}) override;
+        const TVersionedLookupRowsOptions& options),
+        (path, nameTable, keys, options))
 
-    TFuture<std::vector<TUnversionedLookupRowsResult>> MultiLookupRows(
+    DELEGATE_METHOD(TFuture<std::vector<TUnversionedLookupRowsResult>>, MultiLookupRows, (
         const std::vector<TMultiLookupSubrequest>& subrequests,
-        const TMultiLookupOptions& options = {}) override;
+        const TMultiLookupOptions& options),
+        (subrequests, options))
 
-    TFuture<TSelectRowsResult> SelectRows(
+    DELEGATE_METHOD(TFuture<TSelectRowsResult>, SelectRows, (
         const TString& query,
-        const TSelectRowsOptions& options = {}) override;
+        const TSelectRowsOptions& options),
+        (query, options))
 
-    TFuture<NYson::TYsonString> ExplainQuery(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, ExplainQuery, (
         const TString& query,
-        const TExplainQueryOptions& options = {}) override;
+        const TExplainQueryOptions& options),
+        (query, options))
 
-    TFuture<TPullRowsResult> PullRows(
+    DELEGATE_METHOD(TFuture<TPullRowsResult>, PullRows, (
         const NYPath::TYPath& path,
-        const TPullRowsOptions& options = {}) override;
+        const TPullRowsOptions& options),
+        (path, options))
 
-    TFuture<ITableReaderPtr> CreateTableReader(
+    DELEGATE_METHOD(TFuture<ITableReaderPtr>, CreateTableReader, (
         const NYPath::TRichYPath& path,
-        const TTableReaderOptions& options = {}) override;
+        const TTableReaderOptions& options),
+        (path, options))
 
-    TFuture<ITableWriterPtr> CreateTableWriter(
+    DELEGATE_METHOD(TFuture<ITableWriterPtr>, CreateTableWriter, (
         const NYPath::TRichYPath& path,
-        const TTableWriterOptions& options = {}) override;
+        const TTableWriterOptions& options),
+        (path, options))
 
     // Queues
-    TFuture<NQueueClient::IQueueRowsetPtr> PullQueue(
+    DELEGATE_METHOD(TFuture<NQueueClient::IQueueRowsetPtr>, PullQueue, (
         const NYPath::TRichYPath& queuePath,
         i64 offset,
         int partitionIndex,
         const NQueueClient::TQueueRowBatchReadOptions& rowBatchReadOptions,
-        const TPullQueueOptions& options = {}) override;
+        const TPullQueueOptions& options),
+        (queuePath, offset, partitionIndex, rowBatchReadOptions, options))
 
-    TFuture<NQueueClient::IQueueRowsetPtr> PullConsumer(
+    DELEGATE_METHOD(TFuture<NQueueClient::IQueueRowsetPtr>, PullConsumer, (
         const NYPath::TRichYPath& consumerPath,
         const NYPath::TRichYPath& queuePath,
         std::optional<i64> offset,
         int partitionIndex,
         const NQueueClient::TQueueRowBatchReadOptions& rowBatchReadOptions,
-        const TPullConsumerOptions& options = {}) override;
+        const TPullConsumerOptions& options),
+        (consumerPath, queuePath, offset, partitionIndex, rowBatchReadOptions, options))
 
-    TFuture<void> RegisterQueueConsumer(
+    DELEGATE_METHOD(TFuture<void>, RegisterQueueConsumer, (
         const NYPath::TRichYPath& queuePath,
         const NYPath::TRichYPath& consumerPath,
         bool vital,
-        const TRegisterQueueConsumerOptions& options = {}) override;
+        const TRegisterQueueConsumerOptions& options),
+        (queuePath, consumerPath, vital, options))
 
-    TFuture<void> UnregisterQueueConsumer(
+    DELEGATE_METHOD(TFuture<void>, UnregisterQueueConsumer, (
         const NYPath::TRichYPath& queuePath,
         const NYPath::TRichYPath& consumerPath,
-        const TUnregisterQueueConsumerOptions& options = {}) override;
+        const TUnregisterQueueConsumerOptions& options),
+        (queuePath, consumerPath, options))
 
-    TFuture<std::vector<TListQueueConsumerRegistrationsResult>> ListQueueConsumerRegistrations(
+    DELEGATE_METHOD(TFuture<std::vector<TListQueueConsumerRegistrationsResult>>, ListQueueConsumerRegistrations, (
         const std::optional<NYPath::TRichYPath>& queuePath,
         const std::optional<NYPath::TRichYPath>& consumerPath,
-        const TListQueueConsumerRegistrationsOptions& options = {}) override;
+        const TListQueueConsumerRegistrationsOptions& options),
+        (queuePath, consumerPath, options))
 
     // Cypress
-    TFuture<NYson::TYsonString> GetNode(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetNode, (
         const NYPath::TYPath& path,
-        const TGetNodeOptions& options = {}) override;
+        const TGetNodeOptions& options),
+        (path, options))
 
-    TFuture<void> SetNode(
+    DELEGATE_METHOD(TFuture<void>, SetNode, (
         const NYPath::TYPath& path,
         const NYson::TYsonString& value,
-        const TSetNodeOptions& options = {}) override;
+        const TSetNodeOptions& options),
+        (path, value, options))
 
-    TFuture<void> MultisetAttributesNode(
+    DELEGATE_METHOD(TFuture<void>, MultisetAttributesNode, (
         const NYPath::TYPath& path,
         const NYTree::IMapNodePtr& attributes,
-        const TMultisetAttributesNodeOptions& options = {}) override;
+        const TMultisetAttributesNodeOptions& options),
+        (path, attributes, options))
 
-    TFuture<void> RemoveNode(
+    DELEGATE_METHOD(TFuture<void>, RemoveNode, (
         const NYPath::TYPath& path,
-        const TRemoveNodeOptions& options = {}) override;
+        const TRemoveNodeOptions& options),
+        (path, options))
 
-    TFuture<NYson::TYsonString> ListNode(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, ListNode, (
         const NYPath::TYPath& path,
-        const TListNodeOptions& options = {}) override;
+        const TListNodeOptions& options),
+        (path, options))
 
-    TFuture<NCypressClient::TNodeId> CreateNode(
+    DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, CreateNode, (
         const NYPath::TYPath& path,
         NObjectClient::EObjectType type,
-        const TCreateNodeOptions& options = {}) override;
+        const TCreateNodeOptions& options),
+        (path, type, options))
 
-    TFuture<TLockNodeResult> LockNode(
+    DELEGATE_METHOD(TFuture<TLockNodeResult>, LockNode, (
         const NYPath::TYPath& path,
         NCypressClient::ELockMode mode,
-        const TLockNodeOptions& options = {}) override;
+        const TLockNodeOptions& options),
+        (path, mode, options))
 
-    TFuture<void> UnlockNode(
+    DELEGATE_METHOD(TFuture<void>, UnlockNode, (
         const NYPath::TYPath& path,
-        const TUnlockNodeOptions& options = {}) override;
+        const TUnlockNodeOptions& options),
+        (path, options))
 
-    TFuture<NCypressClient::TNodeId> CopyNode(
+    DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, CopyNode, (
         const NYPath::TYPath& srcPath,
         const NYPath::TYPath& dstPath,
-        const TCopyNodeOptions& options = {}) override;
+        const TCopyNodeOptions& options),
+        (srcPath, dstPath, options))
 
-    TFuture<NCypressClient::TNodeId> MoveNode(
+    DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, MoveNode, (
         const NYPath::TYPath& srcPath,
         const NYPath::TYPath& dstPath,
-        const TMoveNodeOptions& options = {}) override;
+        const TMoveNodeOptions& options),
+        (srcPath, dstPath, options))
 
-    TFuture<NCypressClient::TNodeId> LinkNode(
+    DELEGATE_METHOD(TFuture<NCypressClient::TNodeId>, LinkNode, (
         const NYPath::TYPath& srcPath,
         const NYPath::TYPath& dstPath,
-        const TLinkNodeOptions& options = {}) override;
+        const TLinkNodeOptions& options),
+        (srcPath, dstPath, options))
 
-    TFuture<void> ConcatenateNodes(
+    DELEGATE_METHOD(TFuture<void>, ConcatenateNodes, (
         const std::vector<NYPath::TRichYPath>& srcPaths,
         const NYPath::TRichYPath& dstPath,
-        const TConcatenateNodesOptions& options = {}) override;
+        const TConcatenateNodesOptions& options),
+        (srcPaths, dstPath, options))
 
-    TFuture<bool> NodeExists(
+    DELEGATE_METHOD(TFuture<bool>, NodeExists, (
         const NYPath::TYPath& path,
-        const TNodeExistsOptions& options = {}) override;
+        const TNodeExistsOptions& options),
+        (path, options))
 
-    TFuture<void> ExternalizeNode(
+    DELEGATE_METHOD(TFuture<void>, ExternalizeNode, (
         const NYPath::TYPath& path,
         NObjectClient::TCellTag cellTag,
-        const TExternalizeNodeOptions& options = {}) override;
+        const TExternalizeNodeOptions& options),
+        (path, cellTag, options))
 
-    TFuture<void> InternalizeNode(
+    DELEGATE_METHOD(TFuture<void>, InternalizeNode, (
         const NYPath::TYPath& path,
-        const TInternalizeNodeOptions& options = {}) override;
+        const TInternalizeNodeOptions& options),
+        (path, options))
 
     // Objects
-    TFuture<NObjectClient::TObjectId> CreateObject(
+    DELEGATE_METHOD(TFuture<NObjectClient::TObjectId>, CreateObject, (
         NObjectClient::EObjectType type,
-        const TCreateObjectOptions& options = {}) override;
-
+        const TCreateObjectOptions& options),
+        (type, options))
 
     // Files
-    TFuture<IFileReaderPtr> CreateFileReader(
+    DELEGATE_METHOD(TFuture<IFileReaderPtr>, CreateFileReader, (
         const NYPath::TYPath& path,
-        const TFileReaderOptions& options = {}) override;
+        const TFileReaderOptions& options),
+        (path, options))
 
-    IFileWriterPtr CreateFileWriter(
+    DELEGATE_METHOD(IFileWriterPtr, CreateFileWriter, (
         const NYPath::TRichYPath& path,
-        const TFileWriterOptions& options = {}) override;
+        const TFileWriterOptions& options),
+        (path, options))
 
-    // Journals
-    IJournalReaderPtr CreateJournalReader(
+    DELEGATE_METHOD(IJournalReaderPtr, CreateJournalReader, (
         const NYPath::TYPath& path,
-        const TJournalReaderOptions& options = {}) override;
+        const TJournalReaderOptions& options),
+        (path, options))
 
-    IJournalWriterPtr CreateJournalWriter(
+    DELEGATE_METHOD(IJournalWriterPtr, CreateJournalWriter, (
         const NYPath::TYPath& path,
-        const TJournalWriterOptions& options = {}) override;
-
-    // IClient methods
-
-    void Terminate() override;
-
-    const NTabletClient::ITableMountCachePtr& GetTableMountCache() override;
-
-    const NChaosClient::IReplicationCardCachePtr& GetReplicationCardCache() override;
-
-    const NTransactionClient::ITimestampProviderPtr& GetTimestampProvider() override;
+        const TJournalWriterOptions& options),
+        (path, options))
 
     // Transactions
-    ITransactionPtr AttachTransaction(
+    DELEGATE_METHOD(ITransactionPtr, AttachTransaction, (
         NTransactionClient::TTransactionId transactionId,
-        const TTransactionAttachOptions& options = {}) override;
+        const TTransactionAttachOptions& options),
+        (transactionId, options))
 
     // Tables
-    TFuture<void> MountTable(
+    DELEGATE_METHOD(TFuture<void>, MountTable, (
         const NYPath::TYPath& path,
-        const TMountTableOptions& options = {}) override;
+        const TMountTableOptions& options),
+        (path, options))
 
-    TFuture<void> UnmountTable(
+    DELEGATE_METHOD(TFuture<void>, UnmountTable, (
         const NYPath::TYPath& path,
-        const TUnmountTableOptions& options = {}) override;
+        const TUnmountTableOptions& options),
+        (path, options))
 
-    TFuture<void> RemountTable(
+    DELEGATE_METHOD(TFuture<void>, RemountTable, (
         const NYPath::TYPath& path,
-        const TRemountTableOptions& options = {}) override;
+        const TRemountTableOptions& options),
+        (path, options))
 
-    TFuture<void> FreezeTable(
+    DELEGATE_METHOD(TFuture<void>, FreezeTable, (
         const NYPath::TYPath& path,
-        const TFreezeTableOptions& options = {}) override;
+        const TFreezeTableOptions& options),
+        (path, options))
 
-    TFuture<void> UnfreezeTable(
+    DELEGATE_METHOD(TFuture<void>, UnfreezeTable, (
         const NYPath::TYPath& path,
-        const TUnfreezeTableOptions& options = {}) override;
+        const TUnfreezeTableOptions& options),
+        (path, options))
 
-    TFuture<void> ReshardTable(
+    DELEGATE_METHOD(TFuture<void>, ReshardTable, (
         const NYPath::TYPath& path,
         const std::vector<NTableClient::TLegacyOwningKey>& pivotKeys,
-        const TReshardTableOptions& options = {}) override;
+        const TReshardTableOptions& options),
+        (path, pivotKeys, options))
 
-    TFuture<void> ReshardTable(
+    DELEGATE_METHOD(TFuture<void>, ReshardTable, (
         const NYPath::TYPath& path,
         int tabletCount,
-        const TReshardTableOptions& options = {}) override;
+        const TReshardTableOptions& options),
+        (path, tabletCount, options))
 
-    TFuture<std::vector<NTabletClient::TTabletActionId>> ReshardTableAutomatic(
+    DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTabletActionId>>, ReshardTableAutomatic, (
         const NYPath::TYPath& path,
-        const TReshardTableAutomaticOptions& options = {}) override;
+        const TReshardTableAutomaticOptions& options),
+        (path, options))
 
-    TFuture<void> TrimTable(
+    DELEGATE_METHOD(TFuture<void>, TrimTable, (
         const NYPath::TYPath& path,
         int tabletIndex,
         i64 trimmedRowCount,
-        const TTrimTableOptions& options = {}) override;
+        const TTrimTableOptions& options),
+        (path, tabletIndex, trimmedRowCount, options))
 
-    TFuture<void> AlterTable(
+    DELEGATE_METHOD(TFuture<void>, AlterTable, (
         const NYPath::TYPath& path,
-        const TAlterTableOptions& options = {}) override;
+        const TAlterTableOptions& options),
+        (path, options))
 
-    TFuture<void> AlterTableReplica(
+    DELEGATE_METHOD(TFuture<void>, AlterTableReplica, (
         NTabletClient::TTableReplicaId replicaId,
-        const TAlterTableReplicaOptions& options = {}) override;
+        const TAlterTableReplicaOptions& options),
+        (replicaId, options))
 
-    TFuture<void> AlterReplicationCard(
+    DELEGATE_METHOD(TFuture<void>, AlterReplicationCard, (
         NChaosClient::TReplicationCardId replicationCardId,
-        const TAlterReplicationCardOptions& options = {}) override;
+        const TAlterReplicationCardOptions& options),
+        (replicationCardId, options))
 
-    TFuture<NYson::TYsonString> GetTablePivotKeys(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetTablePivotKeys, (
         const NYPath::TYPath& path,
-        const TGetTablePivotKeysOptions& options = {}) override;
+        const TGetTablePivotKeysOptions& options),
+        (path, options))
 
-    TFuture<void> CreateTableBackup(
+    DELEGATE_METHOD(TFuture<void>, CreateTableBackup, (
         const TBackupManifestPtr& manifest,
-        const TCreateTableBackupOptions& options = {}) override;
+        const TCreateTableBackupOptions& options),
+        (manifest, options))
 
-    TFuture<void> RestoreTableBackup(
+    DELEGATE_METHOD(TFuture<void>, RestoreTableBackup, (
         const TBackupManifestPtr& manifest,
-        const TRestoreTableBackupOptions& options = {}) override;
+        const TRestoreTableBackupOptions& options),
+        (manifest, options))
 
-    TFuture<std::vector<NTabletClient::TTableReplicaId>> GetInSyncReplicas(
+    DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTableReplicaId>>, GetInSyncReplicas, (
         const NYPath::TYPath& path,
         const NTableClient::TNameTablePtr& nameTable,
         const TSharedRange<NTableClient::TLegacyKey>& keys,
-        const TGetInSyncReplicasOptions& options = {}) override;
+        const TGetInSyncReplicasOptions& options),
+        (path, nameTable, keys, options))
 
-    TFuture<std::vector<NTabletClient::TTableReplicaId>> GetInSyncReplicas(
+    DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTableReplicaId>>, GetInSyncReplicas, (
         const NYPath::TYPath& path,
-        const TGetInSyncReplicasOptions& options = {}) override;
+        const TGetInSyncReplicasOptions& options),
+        (path, options))
 
-    TFuture<std::vector<TTabletInfo>> GetTabletInfos(
+    DELEGATE_METHOD(TFuture<std::vector<TTabletInfo>>, GetTabletInfos, (
         const NYPath::TYPath& path,
         const std::vector<int>& tabletIndexes,
-        const TGetTabletInfosOptions& options = {}) override;
+        const TGetTabletInfosOptions& options),
+        (path, tabletIndexes, options))
 
-    TFuture<TGetTabletErrorsResult> GetTabletErrors(
+    DELEGATE_METHOD(TFuture<TGetTabletErrorsResult>, GetTabletErrors, (
         const NYPath::TYPath& path,
-        const TGetTabletErrorsOptions& options = {}) override;
+        const TGetTabletErrorsOptions& options),
+        (path, options))
 
-    TFuture<std::vector<NTabletClient::TTabletActionId>> BalanceTabletCells(
+    DELEGATE_METHOD(TFuture<std::vector<NTabletClient::TTabletActionId>>, BalanceTabletCells, (
         const TString& tabletCellBundle,
         const std::vector<NYPath::TYPath>& movableTables,
-        const TBalanceTabletCellsOptions& options = {}) override;
+        const TBalanceTabletCellsOptions& options),
+        (tabletCellBundle, movableTables, options))
 
-    TFuture<NChaosClient::TReplicationCardPtr> GetReplicationCard(
+    DELEGATE_METHOD(TFuture<NChaosClient::TReplicationCardPtr>, GetReplicationCard, (
         NChaosClient::TReplicationCardId replicationCardId,
-        const TGetReplicationCardOptions& options = {}) override;
+        const TGetReplicationCardOptions& options),
+        (replicationCardId, options))
 
-    TFuture<void> UpdateChaosTableReplicaProgress(
+    DELEGATE_METHOD(TFuture<void>, UpdateChaosTableReplicaProgress, (
         NChaosClient::TReplicaId replicaId,
-        const TUpdateChaosTableReplicaProgressOptions& options = {}) override;
+        const TUpdateChaosTableReplicaProgressOptions& options),
+        (replicaId, options))
 
-    TFuture<TSkynetSharePartsLocationsPtr> LocateSkynetShare(
+    DELEGATE_METHOD(TFuture<TSkynetSharePartsLocationsPtr>, LocateSkynetShare, (
         const NYPath::TRichYPath& path,
-        const TLocateSkynetShareOptions& options = {}) override;
+        const TLocateSkynetShareOptions& options),
+        (path, options))
 
-    TFuture<std::vector<NTableClient::TColumnarStatistics>> GetColumnarStatistics(
+    DELEGATE_METHOD(TFuture<std::vector<NTableClient::TColumnarStatistics>>, GetColumnarStatistics, (
         const std::vector<NYPath::TRichYPath>& path,
-        const TGetColumnarStatisticsOptions& options = {}) override;
+        const TGetColumnarStatisticsOptions& options),
+        (path, options))
 
-    TFuture<TMultiTablePartitions> PartitionTables(
+    DELEGATE_METHOD(TFuture<TMultiTablePartitions>, PartitionTables, (
         const std::vector<NYPath::TRichYPath>& paths,
-        const TPartitionTablesOptions& options) override;
+        const TPartitionTablesOptions& options),
+        (paths, options))
 
     // Journals
-    TFuture<void> TruncateJournal(
+    DELEGATE_METHOD(TFuture<void>, TruncateJournal, (
         const NYPath::TYPath& path,
         i64 rowCount,
-        const TTruncateJournalOptions& options = {}) override;
+        const TTruncateJournalOptions& options),
+        (path, rowCount, options))
 
     // Files
-    TFuture<TGetFileFromCacheResult> GetFileFromCache(
+    DELEGATE_METHOD(TFuture<TGetFileFromCacheResult>, GetFileFromCache, (
         const TString& md5,
-        const TGetFileFromCacheOptions& options = {}) override;
+        const TGetFileFromCacheOptions& options),
+        (md5, options))
 
-    TFuture<TPutFileToCacheResult> PutFileToCache(
+    DELEGATE_METHOD(TFuture<TPutFileToCacheResult>, PutFileToCache, (
         const NYPath::TYPath& path,
         const TString& expectedMD5,
-        const TPutFileToCacheOptions& options = {}) override;
+        const TPutFileToCacheOptions& options),
+        (path, expectedMD5, options))
 
     // Security
-    TFuture<void> AddMember(
+    DELEGATE_METHOD(TFuture<void>, AddMember, (
         const TString& group,
         const TString& member,
-        const TAddMemberOptions& options = {}) override;
+        const TAddMemberOptions& options),
+        (group, member, options))
 
-    TFuture<void> RemoveMember(
+    DELEGATE_METHOD(TFuture<void>, RemoveMember, (
         const TString& group,
         const TString& member,
-        const TRemoveMemberOptions& options = {}) override;
+        const TRemoveMemberOptions& options),
+        (group, member, options))
 
-    TFuture<TCheckPermissionResponse> CheckPermission(
+    DELEGATE_METHOD(TFuture<TCheckPermissionResponse>, CheckPermission, (
         const TString& user,
         const NYPath::TYPath& path,
         NYTree::EPermission permission,
-        const TCheckPermissionOptions& options = {}) override;
+        const TCheckPermissionOptions& options),
+        (user, path, permission, options))
 
-    TFuture<TCheckPermissionByAclResult> CheckPermissionByAcl(
+    DELEGATE_METHOD(TFuture<TCheckPermissionByAclResult>, CheckPermissionByAcl, (
         const std::optional<TString>& user,
         NYTree::EPermission permission,
         NYTree::INodePtr acl,
-        const TCheckPermissionByAclOptions& options = {}) override;
+        const TCheckPermissionByAclOptions& options),
+        (user, permission, acl, options))
 
-    TFuture<void> TransferAccountResources(
+    DELEGATE_METHOD(TFuture<void>, TransferAccountResources, (
         const TString& srcAccount,
         const TString& dstAccount,
         NYTree::INodePtr resourceDelta,
-        const TTransferAccountResourcesOptions& options = {}) override;
+        const TTransferAccountResourcesOptions& options),
+        (srcAccount, dstAccount, resourceDelta, options))
 
     // Scheduler
-    TFuture<void> TransferPoolResources(
+    DELEGATE_METHOD(TFuture<void>, TransferPoolResources, (
         const TString& srcPool,
         const TString& dstPool,
         const TString& poolTree,
         NYTree::INodePtr resourceDelta,
-        const TTransferPoolResourcesOptions& options = {}) override;
+        const TTransferPoolResourcesOptions& options),
+        (srcPool, dstPool, poolTree, resourceDelta, options))
 
-    TFuture<NScheduler::TOperationId> StartOperation(
+    DELEGATE_METHOD(TFuture<NScheduler::TOperationId>, StartOperation, (
         NScheduler::EOperationType type,
         const NYson::TYsonString& spec,
-        const TStartOperationOptions& options = {}) override;
+        const TStartOperationOptions& options),
+        (type, spec, options))
 
-    TFuture<void> AbortOperation(
+    DELEGATE_METHOD(TFuture<void>, AbortOperation, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TAbortOperationOptions& options = {}) override;
+        const TAbortOperationOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<void> SuspendOperation(
+    DELEGATE_METHOD(TFuture<void>, SuspendOperation, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TSuspendOperationOptions& options = {}) override;
+        const TSuspendOperationOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<void> ResumeOperation(
+    DELEGATE_METHOD(TFuture<void>, ResumeOperation, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TResumeOperationOptions& options = {}) override;
+        const TResumeOperationOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<void> CompleteOperation(
+    DELEGATE_METHOD(TFuture<void>, CompleteOperation, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TCompleteOperationOptions& options = {}) override;
+        const TCompleteOperationOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<void> UpdateOperationParameters(
+    DELEGATE_METHOD(TFuture<void>, UpdateOperationParameters, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
         const NYson::TYsonString& parameters,
-        const TUpdateOperationParametersOptions& options = {}) override;
+        const TUpdateOperationParametersOptions& options),
+        (operationIdOrAlias, parameters, options))
 
-    TFuture<TOperation> GetOperation(
+    DELEGATE_METHOD(TFuture<TOperation>, GetOperation, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TGetOperationOptions& options = {}) override;
+        const TGetOperationOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<void> DumpJobContext(
+    DELEGATE_METHOD(TFuture<void>, DumpJobContext, (
         NJobTrackerClient::TJobId jobId,
         const NYPath::TYPath& path,
-        const TDumpJobContextOptions& options = {}) override;
+        const TDumpJobContextOptions& options),
+        (jobId, path, options))
 
-    TFuture<NConcurrency::IAsyncZeroCopyInputStreamPtr> GetJobInput(
+    DELEGATE_METHOD(TFuture<NConcurrency::IAsyncZeroCopyInputStreamPtr>, GetJobInput, (
         NJobTrackerClient::TJobId jobId,
-        const TGetJobInputOptions& options = {}) override;
+        const TGetJobInputOptions& options),
+        (jobId, options))
 
-    TFuture<NYson::TYsonString> GetJobInputPaths(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJobInputPaths, (
         NJobTrackerClient::TJobId jobId,
-        const TGetJobInputPathsOptions& options = {}) override;
+        const TGetJobInputPathsOptions& options),
+        (jobId, options))
 
-    TFuture<NYson::TYsonString> GetJobSpec(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJobSpec, (
         NJobTrackerClient::TJobId jobId,
-        const TGetJobSpecOptions& options = {}) override;
+        const TGetJobSpecOptions& options),
+        (jobId, options))
 
-    TFuture<TSharedRef> GetJobStderr(
+    DELEGATE_METHOD(TFuture<TSharedRef>, GetJobStderr, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
         NJobTrackerClient::TJobId jobId,
-        const TGetJobStderrOptions& options = {}) override;
+        const TGetJobStderrOptions& options),
+        (operationIdOrAlias, jobId, options))
 
-    TFuture<TSharedRef> GetJobFailContext(
+    DELEGATE_METHOD(TFuture<TSharedRef>, GetJobFailContext, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
         NJobTrackerClient::TJobId jobId,
-        const TGetJobFailContextOptions& options = {}) override;
+        const TGetJobFailContextOptions& options),
+        (operationIdOrAlias, jobId, options))
 
-    TFuture<TListOperationsResult> ListOperations(
-        const TListOperationsOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<TListOperationsResult>, ListOperations, (
+        const TListOperationsOptions& options),
+        (options))
 
-    TFuture<TListJobsResult> ListJobs(
+    DELEGATE_METHOD(TFuture<TListJobsResult>, ListJobs, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
-        const TListJobsOptions& options = {}
-    ) override;
+        const TListJobsOptions& options),
+        (operationIdOrAlias, options))
 
-    TFuture<NYson::TYsonString> GetJob(
+    DELEGATE_METHOD(TFuture<NYson::TYsonString>, GetJob, (
         const NScheduler::TOperationIdOrAlias& operationIdOrAlias,
         NJobTrackerClient::TJobId jobId,
-        const TGetJobOptions& options = {}) override;
+        const TGetJobOptions& options),
+        (operationIdOrAlias, jobId, options))
 
-    TFuture<void> AbandonJob(
+    DELEGATE_METHOD(TFuture<void>, AbandonJob, (
         NJobTrackerClient::TJobId jobId,
-        const TAbandonJobOptions& options = {}) override;
+        const TAbandonJobOptions& options),
+        (jobId, options))
 
-    TFuture<TPollJobShellResponse> PollJobShell(
+    DELEGATE_METHOD(TFuture<TPollJobShellResponse>, PollJobShell, (
         NJobTrackerClient::TJobId jobId,
         const std::optional<TString>& shellName,
         const NYson::TYsonString& parameters,
-        const TPollJobShellOptions& options = {}) override;
+        const TPollJobShellOptions& options),
+        (jobId, shellName, parameters, options))
 
-    TFuture<void> AbortJob(
+    DELEGATE_METHOD(TFuture<void>, AbortJob, (
         NJobTrackerClient::TJobId jobId,
-        const TAbortJobOptions& options = {}) override;
+        const TAbortJobOptions& options),
+        (jobId, options))
 
     // Metadata
-    TFuture<TClusterMeta> GetClusterMeta(
-        const TGetClusterMetaOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<TClusterMeta>, GetClusterMeta, (
+        const TGetClusterMetaOptions& options),
+        (options))
 
-    TFuture<void> CheckClusterLiveness(
-        const TCheckClusterLivenessOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<void>, CheckClusterLiveness, (
+        const TCheckClusterLivenessOptions& options),
+        (options))
 
     // Administration
-    TFuture<int> BuildSnapshot(
-        const TBuildSnapshotOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<int>, BuildSnapshot, (
+        const TBuildSnapshotOptions& options),
+        (options))
 
-    TFuture<TCellIdToSnapshotIdMap> BuildMasterSnapshots(
-        const TBuildMasterSnapshotsOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<TCellIdToSnapshotIdMap>, BuildMasterSnapshots, (
+        const TBuildMasterSnapshotsOptions& options),
+        (options))
 
-    TFuture<void> ExitReadOnly(
+    DELEGATE_METHOD(TFuture<void>, ExitReadOnly, (
         NHydra::TCellId cellId,
-        const TExitReadOnlyOptions& options) override;
+        const TExitReadOnlyOptions& options),
+        (cellId, options))
 
-    TFuture<void> MasterExitReadOnly(
-        const TMasterExitReadOnlyOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<void>, MasterExitReadOnly, (
+        const TMasterExitReadOnlyOptions& options),
+        (options))
 
-    TFuture<void> DiscombobulateNonvotingPeers(
+    DELEGATE_METHOD(TFuture<void>, DiscombobulateNonvotingPeers, (
         NHydra::TCellId cellId,
-        const TDiscombobulateNonvotingPeersOptions& options) override;
+        const TDiscombobulateNonvotingPeersOptions& options),
+        (cellId, options))
 
-    TFuture<void> SwitchLeader(
+    DELEGATE_METHOD(TFuture<void>, SwitchLeader, (
         NHydra::TCellId cellId,
         const TString& newLeaderAddress,
-        const TSwitchLeaderOptions& options = {}) override;
+        const TSwitchLeaderOptions& options),
+        (cellId, newLeaderAddress, options))
 
-    TFuture<void> ResetStateHash(
+    DELEGATE_METHOD(TFuture<void>, ResetStateHash, (
         NHydra::TCellId cellId,
-        const TResetStateHashOptions& options = {}) override;
+        const TResetStateHashOptions& options),
+        (cellId, options))
 
-    TFuture<void> GCCollect(
-        const TGCCollectOptions& options = {}) override;
+    DELEGATE_METHOD(TFuture<void>, GCCollect, (
+        const TGCCollectOptions& options),
+        (options))
 
-    TFuture<void> KillProcess(
+    DELEGATE_METHOD(TFuture<void>, KillProcess, (
         const TString& address,
-        const TKillProcessOptions& options = {}) override;
+        const TKillProcessOptions& options),
+        (address, options))
 
-    TFuture<TString> WriteCoreDump(
+    DELEGATE_METHOD(TFuture<TString>, WriteCoreDump, (
         const TString& address,
-        const TWriteCoreDumpOptions& options = {}) override;
+        const TWriteCoreDumpOptions& options),
+        (address, options))
 
-    TFuture<TGuid> WriteLogBarrier(
+    DELEGATE_METHOD(TFuture<TGuid>, WriteLogBarrier, (
         const TString& address,
-        const TWriteLogBarrierOptions& options = {}) override;
+        const TWriteLogBarrierOptions& options),
+        (address, options))
 
-    TFuture<TString> WriteOperationControllerCoreDump(
+    DELEGATE_METHOD(TFuture<TString>, WriteOperationControllerCoreDump, (
         NJobTrackerClient::TOperationId operationId,
-        const TWriteOperationControllerCoreDumpOptions& options = {}) override;
+        const TWriteOperationControllerCoreDumpOptions& options),
+        (operationId, options))
 
-    TFuture<void> HealExecNode(
+    DELEGATE_METHOD(TFuture<void>, HealExecNode, (
         const TString& address,
-        const THealExecNodeOptions& options = {}) override;
+        const THealExecNodeOptions& options),
+        (address, options))
 
-    TFuture<void> SuspendCoordinator(
+    DELEGATE_METHOD(TFuture<void>, SuspendCoordinator, (
         NObjectClient::TCellId coordinatorCellId,
-        const TSuspendCoordinatorOptions& options = {}) override;
+        const TSuspendCoordinatorOptions& options),
+        (coordinatorCellId, options))
 
-    TFuture<void> ResumeCoordinator(
+    DELEGATE_METHOD(TFuture<void>, ResumeCoordinator, (
         NObjectClient::TCellId coordinatorCellId,
-        const TResumeCoordinatorOptions& options = {}) override;
+        const TResumeCoordinatorOptions& options),
+        (coordinatorCellId, options))
 
-    TFuture<void> MigrateReplicationCards(
+    DELEGATE_METHOD(TFuture<void>, MigrateReplicationCards, (
         NObjectClient::TCellId chaosCellId,
-        const TMigrateReplicationCardsOptions& options = {}) override;
+        const TMigrateReplicationCardsOptions& options),
+        (chaosCellId, options))
 
-    TFuture<void> SuspendChaosCells(
+    DELEGATE_METHOD(TFuture<void>, SuspendChaosCells, (
         const std::vector<NObjectClient::TCellId>& cellIds,
-        const TSuspendChaosCellsOptions& options = {}) override;
+        const TSuspendChaosCellsOptions& options),
+        (cellIds, options))
 
-    TFuture<void> ResumeChaosCells(
+    DELEGATE_METHOD(TFuture<void>, ResumeChaosCells, (
         const std::vector<NObjectClient::TCellId>& cellIds,
-        const TResumeChaosCellsOptions& options = {}) override;
+        const TResumeChaosCellsOptions& options),
+        (cellIds, options))
 
-    TFuture<void> SuspendTabletCells(
+    DELEGATE_METHOD(TFuture<void>, SuspendTabletCells, (
         const std::vector<NObjectClient::TCellId>& cellIds,
-        const TSuspendTabletCellsOptions& options = {}) override;
+        const TSuspendTabletCellsOptions& options),
+        (cellIds, options))
 
-    TFuture<void> ResumeTabletCells(
+    DELEGATE_METHOD(TFuture<void>, ResumeTabletCells, (
         const std::vector<NObjectClient::TCellId>& cellIds,
-        const TResumeTabletCellsOptions& options = {}) override;
+        const TResumeTabletCellsOptions& options),
+        (cellIds, options))
 
-    TFuture<TMaintenanceId> AddMaintenance(
+    DELEGATE_METHOD(TFuture<TMaintenanceId>, AddMaintenance, (
         EMaintenanceComponent component,
         const TString& address,
         EMaintenanceType type,
         const TString& comment,
-        const TAddMaintenanceOptions& options = {}) override;
+        const TAddMaintenanceOptions& options),
+        (component, address, type, comment, options))
 
-    TFuture<TMaintenanceCounts> RemoveMaintenance(
+    DELEGATE_METHOD(TFuture<TMaintenanceCounts>, RemoveMaintenance, (
         EMaintenanceComponent component,
         const TString& address,
         const TMaintenanceFilter& filter,
-        const TRemoveMaintenanceOptions& options = {}) override;
+        const TRemoveMaintenanceOptions& options),
+        (component, address, filter, options))
 
-    TFuture<TDisableChunkLocationsResult> DisableChunkLocations(
+    DELEGATE_METHOD(TFuture<TDisableChunkLocationsResult>, DisableChunkLocations, (
         const TString& nodeAddress,
         const std::vector<TGuid>& locationUuids,
-        const TDisableChunkLocationsOptions& options = {}) override;
+        const TDisableChunkLocationsOptions& options),
+        (nodeAddress, locationUuids, options))
 
-    TFuture<TDestroyChunkLocationsResult> DestroyChunkLocations(
+    DELEGATE_METHOD(TFuture<TDestroyChunkLocationsResult>, DestroyChunkLocations, (
         const TString& nodeAddress,
         bool recoverUnlinkedDisks,
         const std::vector<TGuid>& locationUuids,
-        const TDestroyChunkLocationsOptions& options = {}) override;
+        const TDestroyChunkLocationsOptions& options),
+        (nodeAddress, recoverUnlinkedDisks, locationUuids, options))
 
-    TFuture<TResurrectChunkLocationsResult> ResurrectChunkLocations(
+    DELEGATE_METHOD(TFuture<TResurrectChunkLocationsResult>, ResurrectChunkLocations, (
         const TString& nodeAddress,
         const std::vector<TGuid>& locationUuids,
-        const TResurrectChunkLocationsOptions& options = {}) override;
+        const TResurrectChunkLocationsOptions& options),
+        (nodeAddress, locationUuids, options))
 
-    TFuture<TRequestRestartResult> RequestRestart(
+    DELEGATE_METHOD(TFuture<TRequestRestartResult>, RequestRestart, (
         const TString& nodeAddress,
-        const TRequestRestartOptions& options = {}) override;
+        const TRequestRestartOptions& options),
+        (nodeAddress, options))
 
-    TFuture<void> SetUserPassword(
+    DELEGATE_METHOD(TFuture<void>, SetUserPassword, (
         const TString& user,
         const TString& currentPasswordSha256,
         const TString& newPasswordSha256,
-        const TSetUserPasswordOptions& options) override;
+        const TSetUserPasswordOptions& options),
+        (user, currentPasswordSha256, newPasswordSha256, options))
 
-    TFuture<TIssueTokenResult> IssueToken(
+    DELEGATE_METHOD(TFuture<TIssueTokenResult>, IssueToken, (
         const TString& user,
         const TString& passwordSha256,
-        const TIssueTokenOptions& options) override;
+        const TIssueTokenOptions& options),
+        (user, passwordSha256, options))
 
-    TFuture<void> RevokeToken(
+    DELEGATE_METHOD(TFuture<void>, RevokeToken, (
         const TString& user,
         const TString& passwordSha256,
         const TString& tokenSha256,
-        const TRevokeTokenOptions& options) override;
+        const TRevokeTokenOptions& options),
+        (user, passwordSha256, tokenSha256, options))
 
-    TFuture<TListUserTokensResult> ListUserTokens(
+    DELEGATE_METHOD(TFuture<TListUserTokensResult>, ListUserTokens, (
         const TString& user,
         const TString& passwordSha256,
-        const TListUserTokensOptions& options) override;
+        const TListUserTokensOptions& options),
+        (user, passwordSha256, options))
 
     // Query tracker
-
-    TFuture<NQueryTrackerClient::TQueryId> StartQuery(
+    DELEGATE_METHOD(TFuture<NQueryTrackerClient::TQueryId>, StartQuery, (
         NQueryTrackerClient::EQueryEngine engine,
         const TString& query,
-        const TStartQueryOptions& options) override;
+        const TStartQueryOptions& options),
+        (engine, query, options))
 
-    TFuture<void> AbortQuery(
+    DELEGATE_METHOD(TFuture<void>, AbortQuery, (
         NQueryTrackerClient::TQueryId queryId,
-        const TAbortQueryOptions& options) override;
+        const TAbortQueryOptions& options),
+        (queryId, options))
 
-    TFuture<TQueryResult> GetQueryResult(
+    DELEGATE_METHOD(TFuture<TQueryResult>, GetQueryResult, (
         NQueryTrackerClient::TQueryId queryId,
         i64 resultIndex,
-        const TGetQueryResultOptions& options) override;
+        const TGetQueryResultOptions& options),
+        (queryId, resultIndex, options))
 
-    TFuture<IUnversionedRowsetPtr> ReadQueryResult(
+    DELEGATE_METHOD(TFuture<IUnversionedRowsetPtr>, ReadQueryResult, (
         NQueryTrackerClient::TQueryId queryId,
         i64 resultIndex,
-        const TReadQueryResultOptions& options) override;
+        const TReadQueryResultOptions& options),
+        (queryId, resultIndex, options))
 
-    TFuture<TQuery> GetQuery(
+    DELEGATE_METHOD(TFuture<TQuery>, GetQuery, (
         NQueryTrackerClient::TQueryId queryId,
-        const TGetQueryOptions& options) override;
+        const TGetQueryOptions& options),
+        (queryId, options))
 
-    TFuture<TListQueriesResult> ListQueries(const TListQueriesOptions& options) override;
+    DELEGATE_METHOD(TFuture<TListQueriesResult>, ListQueries, (
+        const TListQueriesOptions& options),
+        (options))
 
-    TFuture<void> AlterQuery(
+    DELEGATE_METHOD(TFuture<void>, AlterQuery, (
         NQueryTrackerClient::TQueryId queryId,
-        const TAlterQueryOptions& options) override;
+        const TAlterQueryOptions& options),
+        (queryId, options))
 
     // Bundle Controller
-
-    virtual TFuture<NBundleControllerClient::TBundleConfigDescriptorPtr> GetBundleConfig(
+    DELEGATE_METHOD(TFuture<NBundleControllerClient::TBundleConfigDescriptorPtr>, GetBundleConfig, (
         const TString& bundleName,
-        const NBundleControllerClient::TGetBundleConfigOptions& options = {}) override;
+        const NBundleControllerClient::TGetBundleConfigOptions& options),
+        (bundleName, options))
 
-    virtual TFuture<void> SetBundleConfig(
+    DELEGATE_METHOD(TFuture<void>, SetBundleConfig, (
         const TString& bundleName,
         const NBundleControllerClient::TBundleTargetConfigPtr& bundleConfig,
-        const NBundleControllerClient::TSetBundleConfigOptions& options = {}) override;
+        const NBundleControllerClient::TSetBundleConfigOptions& options),
+        (bundleName, bundleConfig, options))
 
     // Flow
+    DELEGATE_METHOD(TFuture<TGetPipelineSpecResult>, GetPipelineSpec, (
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineSpecOptions& options),
+        (pipelinePath, options))
 
-    TFuture<void> StartPipeline(
+    DELEGATE_METHOD(TFuture<TSetPipelineSpecResult>, SetPipelineSpec, (
         const NYPath::TYPath& pipelinePath,
-        const TStartPipelineOptions& options) override;
+        const NYson::TYsonString& spec,
+        const TSetPipelineSpecOptions& options),
+        (pipelinePath, spec, options))
 
-    TFuture<void> StopPipeline(
+    DELEGATE_METHOD(TFuture<TGetPipelineDynamicSpecResult>, GetPipelineDynamicSpec, (
         const NYPath::TYPath& pipelinePath,
-        const TStopPipelineOptions& options) override;
+        const TGetPipelineDynamicSpecOptions& options),
+        (pipelinePath, options))
 
-    TFuture<void> PausePipeline(
+    DELEGATE_METHOD(TFuture<TSetPipelineDynamicSpecResult>, SetPipelineDynamicSpec, (
         const NYPath::TYPath& pipelinePath,
-        const TPausePipelineOptions& options) override;
+        const NYson::TYsonString& spec,
+        const TSetPipelineDynamicSpecOptions& options),
+        (pipelinePath, spec, options))
 
-    TFuture<TPipelineStatus> GetPipelineStatus(
+    DELEGATE_METHOD(TFuture<void>, StartPipeline, (
         const NYPath::TYPath& pipelinePath,
-        const TGetPipelineStatusOptions& options) override;
+        const TStartPipelineOptions& options),
+        (pipelinePath, options))
+
+    DELEGATE_METHOD(TFuture<void>, StopPipeline, (
+        const NYPath::TYPath& pipelinePath,
+        const TStopPipelineOptions& options),
+        (pipelinePath, options))
+
+    DELEGATE_METHOD(TFuture<void>, PausePipeline, (
+        const NYPath::TYPath& pipelinePath,
+        const TPausePipelineOptions& options),
+        (pipelinePath, options))
+
+    DELEGATE_METHOD(TFuture<TPipelineStatus>, GetPipelineStatus, (
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineStatusOptions& options),
+        (pipelinePath, options))
+
+    #undef DELEGATE_METHOD
 
 protected:
     const IClientPtr Underlying_;
diff --git a/yt/yt/client/api/flow_client.h b/yt/yt/client/api/flow_client.h
index 455dcd3ba5..74385cf984 100644
--- a/yt/yt/client/api/flow_client.h
+++ b/yt/yt/client/api/flow_client.h
@@ -29,10 +29,72 @@ struct TPipelineStatus
     NFlow::EPipelineState State;
 };
 
+struct TGetPipelineSpecOptions
+    : public TTimeoutOptions
+{ };
+
+struct TGetPipelineSpecResult
+{
+    NFlow::TVersion Version;
+    NYson::TYsonString Spec;
+};
+
+struct TSetPipelineSpecOptions
+    : public TTimeoutOptions
+{
+    // Update spec even if pipeline is not stopped, just paused.
+    bool Force = false;
+    std::optional<NFlow::TVersion> ExpectedVersion;
+};
+
+struct TSetPipelineSpecResult
+{
+    NFlow::TVersion Version;
+};
+
+struct TGetPipelineDynamicSpecOptions
+    : public TTimeoutOptions
+{ };
+
+struct TGetPipelineDynamicSpecResult
+{
+    NFlow::TVersion Version;
+    NYson::TYsonString Spec;
+};
+
+struct TSetPipelineDynamicSpecOptions
+    : public TTimeoutOptions
+{
+    std::optional<NFlow::TVersion> ExpectedVersion;
+};
+
+struct TSetPipelineDynamicSpecResult
+{
+    NFlow::TVersion Version;
+};
+
 struct IFlowClient
 {
     ~IFlowClient() = default;
 
+    virtual TFuture<TGetPipelineSpecResult> GetPipelineSpec(
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineSpecOptions& options = {}) = 0;
+
+    virtual TFuture<TSetPipelineSpecResult> SetPipelineSpec(
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineSpecOptions& options = {}) = 0;
+
+    virtual TFuture<TGetPipelineDynamicSpecResult> GetPipelineDynamicSpec(
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineDynamicSpecOptions& options = {}) = 0;
+
+    virtual TFuture<TSetPipelineDynamicSpecResult> SetPipelineDynamicSpec(
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineDynamicSpecOptions& options = {}) = 0;
+
     virtual TFuture<void> StartPipeline(
         const NYPath::TYPath& pipelinePath,
         const TStartPipelineOptions& options = {}) = 0;
diff --git a/yt/yt/client/api/rpc_proxy/api_service_proxy.h b/yt/yt/client/api/rpc_proxy/api_service_proxy.h
index 3effcb1320..6aaf2c1e36 100644
--- a/yt/yt/client/api/rpc_proxy/api_service_proxy.h
+++ b/yt/yt/client/api/rpc_proxy/api_service_proxy.h
@@ -174,6 +174,10 @@ public:
     DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, TransferAccountResources);
 
     // Flow
+    DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, GetPipelineSpec);
+    DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, SetPipelineSpec);
+    DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, GetPipelineDynamicSpec);
+    DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, SetPipelineDynamicSpec);
     DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, StartPipeline);
     DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, StopPipeline);
     DEFINE_RPC_PROXY_METHOD(NRpcProxy::NProto, PausePipeline);
diff --git a/yt/yt/client/api/rpc_proxy/client_impl.cpp b/yt/yt/client/api/rpc_proxy/client_impl.cpp
index b664035d57..fa94b5fb3f 100644
--- a/yt/yt/client/api/rpc_proxy/client_impl.cpp
+++ b/yt/yt/client/api/rpc_proxy/client_impl.cpp
@@ -2116,6 +2116,91 @@ TFuture<TListUserTokensResult> TClient::ListUserTokens(
     ThrowUnimplemented("ListUserTokens");
 }
 
+TFuture<TGetPipelineSpecResult> TClient::GetPipelineSpec(
+    const NYPath::TYPath& pipelinePath,
+    const TGetPipelineSpecOptions& options)
+{
+    auto proxy = CreateApiServiceProxy();
+
+    auto req = proxy.GetPipelineSpec();
+    SetTimeoutOptions(*req, options);
+
+    req->set_pipeline_path(pipelinePath);
+
+    return req->Invoke().Apply(BIND([] (const TApiServiceProxy::TRspGetPipelineSpecPtr& rsp) {
+        return TGetPipelineSpecResult{
+            .Version = FromProto<NFlow::TVersion>(rsp->version()),
+            .Spec = TYsonString(rsp->spec()),
+        };
+    }));
+}
+
+TFuture<TSetPipelineSpecResult> TClient::SetPipelineSpec(
+    const NYPath::TYPath& pipelinePath,
+    const NYson::TYsonString& spec,
+    const TSetPipelineSpecOptions& options)
+{
+    auto proxy = CreateApiServiceProxy();
+
+    auto req = proxy.SetPipelineSpec();
+    SetTimeoutOptions(*req, options);
+
+    req->set_pipeline_path(pipelinePath);
+    req->set_spec(spec.ToString());
+    req->set_force(options.Force);
+    if (options.ExpectedVersion) {
+        req->set_expected_version(ToProto<i64>(*options.ExpectedVersion));
+    }
+
+    return req->Invoke().Apply(BIND([] (const TApiServiceProxy::TRspSetPipelineSpecPtr& rsp) {
+        return TSetPipelineSpecResult{
+            .Version = FromProto<NFlow::TVersion>(rsp->version()),
+        };
+    }));
+}
+
+TFuture<TGetPipelineDynamicSpecResult> TClient::GetPipelineDynamicSpec(
+    const NYPath::TYPath& pipelinePath,
+    const TGetPipelineDynamicSpecOptions& options)
+{
+    auto proxy = CreateApiServiceProxy();
+
+    auto req = proxy.GetPipelineDynamicSpec();
+    SetTimeoutOptions(*req, options);
+
+    req->set_pipeline_path(pipelinePath);
+
+    return req->Invoke().Apply(BIND([] (const TApiServiceProxy::TRspGetPipelineDynamicSpecPtr& rsp) {
+        return TGetPipelineDynamicSpecResult{
+            .Version = FromProto<NFlow::TVersion>(rsp->version()),
+            .Spec = TYsonString(rsp->spec()),
+        };
+    }));
+}
+
+TFuture<TSetPipelineDynamicSpecResult> TClient::SetPipelineDynamicSpec(
+    const NYPath::TYPath& pipelinePath,
+    const NYson::TYsonString& spec,
+    const TSetPipelineDynamicSpecOptions& options)
+{
+    auto proxy = CreateApiServiceProxy();
+
+    auto req = proxy.SetPipelineDynamicSpec();
+    SetTimeoutOptions(*req, options);
+
+    req->set_pipeline_path(pipelinePath);
+    req->set_spec(spec.ToString());
+    if (options.ExpectedVersion) {
+        req->set_expected_version(ToProto<i64>(*options.ExpectedVersion));
+    }
+
+    return req->Invoke().Apply(BIND([] (const TApiServiceProxy::TRspSetPipelineDynamicSpecPtr& rsp) {
+        return TSetPipelineDynamicSpecResult{
+            .Version = FromProto<NFlow::TVersion>(rsp->version()),
+        };
+    }));
+}
+
 TFuture<void> TClient::StartPipeline(
     const NYPath::TYPath& pipelinePath,
     const TStartPipelineOptions& options)
diff --git a/yt/yt/client/api/rpc_proxy/client_impl.h b/yt/yt/client/api/rpc_proxy/client_impl.h
index 43003b5331..6e7ab7402e 100644
--- a/yt/yt/client/api/rpc_proxy/client_impl.h
+++ b/yt/yt/client/api/rpc_proxy/client_impl.h
@@ -496,6 +496,24 @@ public:
 
     // Flow
 
+    TFuture<TGetPipelineSpecResult> GetPipelineSpec(
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineSpecOptions& options = {}) override;
+
+    TFuture<TSetPipelineSpecResult> SetPipelineSpec(
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineSpecOptions& options = {}) override;
+
+    TFuture<TGetPipelineDynamicSpecResult> GetPipelineDynamicSpec(
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineDynamicSpecOptions& options = {}) override;
+
+    TFuture<TSetPipelineDynamicSpecResult> SetPipelineDynamicSpec(
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineDynamicSpecOptions& options = {}) override;
+
     TFuture<void> StartPipeline(
         const NYPath::TYPath& pipelinePath,
         const TStartPipelineOptions& options = {}) override;
diff --git a/yt/yt/client/federated/client.cpp b/yt/yt/client/federated/client.cpp
index 491fe228e7..cd3e0dd5c9 100644
--- a/yt/yt/client/federated/client.cpp
+++ b/yt/yt/client/federated/client.cpp
@@ -428,6 +428,10 @@ public:
     UNIMPLEMENTED_METHOD(IFileWriterPtr, CreateFileWriter, (const NYPath::TRichYPath&, const TFileWriterOptions&));
     UNIMPLEMENTED_METHOD(IJournalReaderPtr, CreateJournalReader, (const NYPath::TYPath&, const TJournalReaderOptions&));
     UNIMPLEMENTED_METHOD(IJournalWriterPtr, CreateJournalWriter, (const NYPath::TYPath&, const TJournalWriterOptions&));
+    UNIMPLEMENTED_METHOD(TFuture<TGetPipelineSpecResult>, GetPipelineSpec, (const NYPath::TYPath&, const TGetPipelineSpecOptions&));
+    UNIMPLEMENTED_METHOD(TFuture<TSetPipelineSpecResult>, SetPipelineSpec, (const NYPath::TYPath&, const NYson::TYsonString&, const TSetPipelineSpecOptions&));
+    UNIMPLEMENTED_METHOD(TFuture<TGetPipelineDynamicSpecResult>, GetPipelineDynamicSpec, (const NYPath::TYPath&, const TGetPipelineDynamicSpecOptions&));
+    UNIMPLEMENTED_METHOD(TFuture<TSetPipelineDynamicSpecResult>, SetPipelineDynamicSpec, (const NYPath::TYPath&, const NYson::TYsonString&, const TSetPipelineDynamicSpecOptions&));
     UNIMPLEMENTED_METHOD(TFuture<void>, StartPipeline, (const NYPath::TYPath&, const TStartPipelineOptions&));
     UNIMPLEMENTED_METHOD(TFuture<void>, StopPipeline, (const NYPath::TYPath&, const TStopPipelineOptions&));
     UNIMPLEMENTED_METHOD(TFuture<void>, PausePipeline, (const NYPath::TYPath&, const TPausePipelineOptions&));
diff --git a/yt/yt/client/hedging/hedging.cpp b/yt/yt/client/hedging/hedging.cpp
index a8f9b8c70d..4b4f1f8f0a 100644
--- a/yt/yt/client/hedging/hedging.cpp
+++ b/yt/yt/client/hedging/hedging.cpp
@@ -212,6 +212,10 @@ public:
     UNSUPPORTED_METHOD(TFuture<TListQueriesResult>, ListQueries, (const TListQueriesOptions&));
     UNSUPPORTED_METHOD(TFuture<void>, AlterQuery, (NQueryTrackerClient::TQueryId, const TAlterQueryOptions&));
     UNSUPPORTED_METHOD(TFuture<NBundleControllerClient::TBundleConfigDescriptorPtr>, GetBundleConfig, (const TString&, const NBundleControllerClient::TGetBundleConfigOptions&));
+    UNSUPPORTED_METHOD(TFuture<TGetPipelineSpecResult>, GetPipelineSpec, (const NYPath::TYPath&, const TGetPipelineSpecOptions&));
+    UNSUPPORTED_METHOD(TFuture<TSetPipelineSpecResult>, SetPipelineSpec, (const NYPath::TYPath&, const NYson::TYsonString&, const TSetPipelineSpecOptions&));
+    UNSUPPORTED_METHOD(TFuture<TGetPipelineDynamicSpecResult>, GetPipelineDynamicSpec, (const NYPath::TYPath&, const TGetPipelineDynamicSpecOptions&));
+    UNSUPPORTED_METHOD(TFuture<TSetPipelineDynamicSpecResult>, SetPipelineDynamicSpec, (const NYPath::TYPath&, const NYson::TYsonString&, const TSetPipelineDynamicSpecOptions&));
     UNSUPPORTED_METHOD(TFuture<void>, SetBundleConfig, (const TString&, const NBundleControllerClient::TBundleTargetConfigPtr&, const NBundleControllerClient::TSetBundleConfigOptions&));
     UNSUPPORTED_METHOD(TFuture<void>, StartPipeline, (const TYPath&, const TStartPipelineOptions&));
     UNSUPPORTED_METHOD(TFuture<void>, StopPipeline, (const TYPath&, const TStopPipelineOptions&));
diff --git a/yt/yt/client/unittests/mock/client.h b/yt/yt/client/unittests/mock/client.h
index e66776c119..4a762e9f84 100644
--- a/yt/yt/client/unittests/mock/client.h
+++ b/yt/yt/client/unittests/mock/client.h
@@ -748,6 +748,28 @@ public:
         const NBundleControllerClient::TBundleTargetConfigPtr& bundleConfig,
         const NBundleControllerClient::TSetBundleConfigOptions& options), (override));
 
+    MOCK_METHOD(TFuture<TGetPipelineSpecResult>, GetPipelineSpec, (
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineSpecOptions& options),
+        (override));
+
+    MOCK_METHOD(TFuture<TSetPipelineSpecResult>, SetPipelineSpec, (
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineSpecOptions& options),
+        (override));
+
+    MOCK_METHOD(TFuture<TGetPipelineDynamicSpecResult>, GetPipelineDynamicSpec, (
+        const NYPath::TYPath& pipelinePath,
+        const TGetPipelineDynamicSpecOptions& options),
+        (override));
+
+    MOCK_METHOD(TFuture<TSetPipelineDynamicSpecResult>, SetPipelineDynamicSpec, (
+        const NYPath::TYPath& pipelinePath,
+        const NYson::TYsonString& spec,
+        const TSetPipelineDynamicSpecOptions& options),
+        (override));
+
     MOCK_METHOD(TFuture<void>, StartPipeline, (
         const NYPath::TYPath& pipelinePath,
         const TStartPipelineOptions& options),
diff --git a/yt/yt/flow/lib/client/public.h b/yt/yt/flow/lib/client/public.h
index 2fb42f2f1b..c813f0d5f6 100644
--- a/yt/yt/flow/lib/client/public.h
+++ b/yt/yt/flow/lib/client/public.h
@@ -27,6 +27,8 @@ DEFINE_ENUM(EPipelineState,
     ((Completed)      (6))
 );
 
+YT_DEFINE_STRONG_TYPEDEF(TVersion, i64);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 inline const TString PipelineFormatVersionAttribute("flow_pipeline_format_version");
diff --git a/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto b/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
index c2a7c5b444..12fa0acd9a 100644
--- a/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
+++ b/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
@@ -2677,6 +2677,62 @@ message TRspCheckClusterLiveness
 // FLOW
 ////////////////////////////////////////////////////////////////////////////////
 
+message TReqGetPipelineSpec
+{
+    required string pipeline_path = 1;
+}
+
+message TRspGetPipelineSpec
+{
+    required int64 version = 1;
+    required bytes spec = 2; // YSON
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+message TReqSetPipelineSpec
+{
+    required string pipeline_path = 1;
+    optional int64 expected_version = 2;
+    required bytes spec = 3; // YSON
+    // Update spec even if pipeline is not stopped, just paused.
+    optional bool force = 4;
+}
+
+message TRspSetPipelineSpec
+{
+    required int64 version = 1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+message TReqGetPipelineDynamicSpec
+{
+    required string pipeline_path = 1;
+}
+
+message TRspGetPipelineDynamicSpec
+{
+    required int64 version = 1;
+    required bytes spec = 2; // YSON
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+message TReqSetPipelineDynamicSpec
+{
+    required string pipeline_path = 1;
+    optional int64 expected_version = 2;
+    required bytes spec = 3; // YSON
+}
+
+message TRspSetPipelineDynamicSpec
+{
+    required int64 version = 1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 message TReqStartPipeline
 {
     required string pipeline_path = 1;