@nebius/js-sdk 0.2.1 → 0.2.2

package/dist/cjs/api/nebius/storage/v1/index.d.ts

@@ -5,7 +5,7 @@ import { ChannelCredentials, Client, ClientUnaryCall, ClientOptions, CallOptions
 import type { SDKInterface } from "../../../../sdk.js";
 import { Request as SDKRequestClass, type RetryOptions } from "../../../../runtime/request.js";
 import { Operation as OperationWrapper } from "../../../../runtime/operation.js";
-import { GetOperationRequest, Operation, OperationService, ResourceMetadata } from "../../common/v1/index.js";
+import { GetByNameRequest, GetOperationRequest, Operation, OperationService, ResourceMetadata } from "../../common/v1/index.js";
 export type StorageClass = EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT" | "INTELLIGENT">;
 interface StorageClassValueMembers {
     readonly STORAGE_CLASS_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT" | "INTELLIGENT">;
@@ -871,5 +871,872 @@ export interface LifecycleNoncurrentVersionTransition {
     storageClass: StorageClass;
 }
 export declare const LifecycleNoncurrentVersionTransition: MessageFns<LifecycleNoncurrentVersionTransition, "nebius.storage.v1.LifecycleNoncurrentVersionTransition">;
+export interface GetTransferRequest {
+    $type: "nebius.storage.v1.GetTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const GetTransferRequest: MessageFns<GetTransferRequest, "nebius.storage.v1.GetTransferRequest">;
+export interface ListTransfersRequest {
+    $type: "nebius.storage.v1.ListTransfersRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Represents the container ID.
+     *
+     */
+    parentId: string;
+    /**
+     *  Specifies the maximum number of items to return in the response. Default: 10.
+     *
+     */
+    pageSize: Long;
+    /**
+     *  Token for pagination, allowing the retrieval of the next set of results.
+     *
+     */
+    pageToken: string;
+}
+export declare const ListTransfersRequest: MessageFns<ListTransfersRequest, "nebius.storage.v1.ListTransfersRequest">;
+export interface ListTransfersResponse {
+    $type: "nebius.storage.v1.ListTransfersResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  List of transfers returned in the response.
+     *
+     */
+    items: Transfer[];
+    /**
+     *  Token for pagination, indicating the next set of results can be retrieved using this token.
+     *
+     */
+    nextPageToken: string;
+}
+export declare const ListTransfersResponse: MessageFns<ListTransfersResponse, "nebius.storage.v1.ListTransfersResponse">;
+export interface CreateTransferRequest {
+    $type: "nebius.storage.v1.CreateTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: TransferSpec | undefined;
+}
+export declare const CreateTransferRequest: MessageFns<CreateTransferRequest, "nebius.storage.v1.CreateTransferRequest">;
+export interface UpdateTransferRequest {
+    $type: "nebius.storage.v1.UpdateTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: TransferSpec | undefined;
+}
+export declare const UpdateTransferRequest: MessageFns<UpdateTransferRequest, "nebius.storage.v1.UpdateTransferRequest">;
+export interface StopTransferRequest {
+    $type: "nebius.storage.v1.StopTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const StopTransferRequest: MessageFns<StopTransferRequest, "nebius.storage.v1.StopTransferRequest">;
+export interface ResumeTransferRequest {
+    $type: "nebius.storage.v1.ResumeTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const ResumeTransferRequest: MessageFns<ResumeTransferRequest, "nebius.storage.v1.ResumeTransferRequest">;
+export interface DeleteTransferRequest {
+    $type: "nebius.storage.v1.DeleteTransferRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+    /**
+     *  Optional: expected transfer version (`metadata.resource_version`)
+     *  - If specified, ensures that only the requested version is deleted (and a `FAILED_PRECONDITION` error is returned on version mismatch)
+     *  - If not specified or set to `0`, the latest version will be deleted
+     *
+     */
+    resourceVersion: Long;
+}
+export declare const DeleteTransferRequest: MessageFns<DeleteTransferRequest, "nebius.storage.v1.DeleteTransferRequest">;
+export interface GetIterationHistoryRequest {
+    $type: "nebius.storage.v1.GetIterationHistoryRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the transfer whose iteration history to return.
+     *
+     */
+    transferId: string;
+    /**
+     *  Specifies the maximum number of items to return in the response.
+     *
+     */
+    pageSize: Long;
+    /**
+     *  Token for pagination, allowing the retrieval of the next set of results.
+     *
+     */
+    pageToken: string;
+}
+export declare const GetIterationHistoryRequest: MessageFns<GetIterationHistoryRequest, "nebius.storage.v1.GetIterationHistoryRequest">;
+export interface GetIterationHistoryResponse {
+    $type: "nebius.storage.v1.GetIterationHistoryResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  List of transfer iterations sorted from newest to oldest.
+     *
+     */
+    iterations: TransferIteration[];
+    /**
+     *  Token for pagination, indicating the next set of results can be retrieved using this token.
+     *
+     */
+    nextPageToken: string;
+}
+export declare const GetIterationHistoryResponse: MessageFns<GetIterationHistoryResponse, "nebius.storage.v1.GetIterationHistoryResponse">;
+export type TransferServiceServiceDescription = typeof TransferServiceServiceDescription;
+export declare const TransferServiceServiceDescription: {
+    readonly get: {
+        readonly path: "/nebius.storage.v1.TransferService/Get";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => GetTransferRequest;
+        readonly responseSerialize: (value: Transfer) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Transfer;
+    };
+    readonly getByName: {
+        readonly path: "/nebius.storage.v1.TransferService/GetByName";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetByNameRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => GetByNameRequest;
+        readonly responseSerialize: (value: Transfer) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Transfer;
+    };
+    readonly list: {
+        readonly path: "/nebius.storage.v1.TransferService/List";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListTransfersRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => ListTransfersRequest;
+        readonly responseSerialize: (value: ListTransfersResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ListTransfersResponse;
+    };
+    readonly create: {
+        readonly path: "/nebius.storage.v1.TransferService/Create";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => CreateTransferRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly update: {
+        readonly path: "/nebius.storage.v1.TransferService/Update";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: true;
+        readonly requestDeserialize: (value: Buffer) => UpdateTransferRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly stop: {
+        readonly path: "/nebius.storage.v1.TransferService/Stop";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StopTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => StopTransferRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly resume: {
+        readonly path: "/nebius.storage.v1.TransferService/Resume";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ResumeTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => ResumeTransferRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly delete: {
+        readonly path: "/nebius.storage.v1.TransferService/Delete";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteTransferRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => DeleteTransferRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly getIterationHistory: {
+        readonly path: "/nebius.storage.v1.TransferService/GetIterationHistory";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetIterationHistoryRequest) => Buffer<ArrayBuffer>;
+        readonly sendResetMask: false;
+        readonly requestDeserialize: (value: Buffer) => GetIterationHistoryRequest;
+        readonly responseSerialize: (value: GetIterationHistoryResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GetIterationHistoryResponse;
+    };
+};
+export interface TransferServiceServer extends UntypedServiceImplementation {
+    get: handleUnaryCall<GetTransferRequest, Transfer>;
+    getByName: handleUnaryCall<GetByNameRequest, Transfer>;
+    list: handleUnaryCall<ListTransfersRequest, ListTransfersResponse>;
+    create: handleUnaryCall<CreateTransferRequest, Operation>;
+    update: handleUnaryCall<UpdateTransferRequest, Operation>;
+    stop: handleUnaryCall<StopTransferRequest, Operation>;
+    resume: handleUnaryCall<ResumeTransferRequest, Operation>;
+    delete: handleUnaryCall<DeleteTransferRequest, Operation>;
+    getIterationHistory: handleUnaryCall<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+}
+export interface TransferServiceBaseClient extends Client {
+    get(request: GetTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Transfer) => void): ClientUnaryCall;
+    getByName(request: GetByNameRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Transfer) => void): ClientUnaryCall;
+    list(request: ListTransfersRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: ListTransfersResponse) => void): ClientUnaryCall;
+    create(request: CreateTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    update(request: UpdateTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    stop(request: StopTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    resume(request: ResumeTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    delete(request: DeleteTransferRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    getIterationHistory(request: GetIterationHistoryRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: GetIterationHistoryResponse) => void): ClientUnaryCall;
+}
+export declare const TransferServiceBaseClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): TransferServiceBaseClient;
+    service: typeof TransferServiceServiceDescription;
+    serviceName: string;
+};
+/**
+ *  TransferService provides functionality for creating and managing transfers
+ *  that migrate data from other providers or across different regions of Nebius Object Storage.
+ *
+ */
+export interface TransferService {
+    $type: "nebius.storage.v1.TransferService";
+    get(request: GetTransferRequest): SDKRequestClass<GetTransferRequest, Transfer>;
+    get(request: GetTransferRequest, metadata: Metadata): SDKRequestClass<GetTransferRequest, Transfer>;
+    get(request: GetTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetTransferRequest, Transfer>;
+    getByName(request: GetByNameRequest): SDKRequestClass<GetByNameRequest, Transfer>;
+    getByName(request: GetByNameRequest, metadata: Metadata): SDKRequestClass<GetByNameRequest, Transfer>;
+    getByName(request: GetByNameRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetByNameRequest, Transfer>;
+    list(request: ListTransfersRequest): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    list(request: ListTransfersRequest, metadata: Metadata): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    list(request: ListTransfersRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    create(request: CreateTransferRequest): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateTransferRequest, metadata: Metadata): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest, metadata: Metadata): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Stop active transfer. If the transfer is currently moving data,
+     *  it will be transitioned to the Stopping state and will move to the Stopped state once all processes have been stopped.
+     *  If the transfer is waiting between iterations, it will stop immediately.
+     *  Only transfers in Active state can be stopped.
+     *
+     */
+    stop(request: StopTransferRequest): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    stop(request: StopTransferRequest, metadata: Metadata): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    stop(request: StopTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Resume stopped or failed transfer.
+     *
+     */
+    resume(request: ResumeTransferRequest): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    resume(request: ResumeTransferRequest, metadata: Metadata): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    resume(request: ResumeTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Fully delete a transfer along with its history. If the transfer is active, it will be stopped and then deleted.
+     *
+     */
+    delete(request: DeleteTransferRequest): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteTransferRequest, metadata: Metadata): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Get transfer iteration history.
+     *
+     */
+    getIterationHistory(request: GetIterationHistoryRequest): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+    getIterationHistory(request: GetIterationHistoryRequest, metadata: Metadata): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+    getIterationHistory(request: GetIterationHistoryRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+}
+export declare class TransferService implements TransferService {
+    private sdk;
+    $type: "nebius.storage.v1.TransferService";
+    private addr;
+    private spec;
+    private apiServiceName;
+    constructor(sdk: SDKInterface);
+    getOperationService(): OperationService;
+    get(request: GetTransferRequest): SDKRequestClass<GetTransferRequest, Transfer>;
+    get(request: GetTransferRequest, metadata: Metadata): SDKRequestClass<GetTransferRequest, Transfer>;
+    get(request: GetTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetTransferRequest, Transfer>;
+    getByName(request: GetByNameRequest): SDKRequestClass<GetByNameRequest, Transfer>;
+    getByName(request: GetByNameRequest, metadata: Metadata): SDKRequestClass<GetByNameRequest, Transfer>;
+    getByName(request: GetByNameRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetByNameRequest, Transfer>;
+    list(request: ListTransfersRequest): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    list(request: ListTransfersRequest, metadata: Metadata): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    list(request: ListTransfersRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListTransfersRequest, ListTransfersResponse>;
+    create(request: CreateTransferRequest): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateTransferRequest, metadata: Metadata): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<CreateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest, metadata: Metadata): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UpdateTransferRequest, OperationWrapper<GetOperationRequest>>;
+    stop(request: StopTransferRequest): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    stop(request: StopTransferRequest, metadata: Metadata): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    stop(request: StopTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<StopTransferRequest, OperationWrapper<GetOperationRequest>>;
+    resume(request: ResumeTransferRequest): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    resume(request: ResumeTransferRequest, metadata: Metadata): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    resume(request: ResumeTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ResumeTransferRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteTransferRequest): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteTransferRequest, metadata: Metadata): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteTransferRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<DeleteTransferRequest, OperationWrapper<GetOperationRequest>>;
+    getIterationHistory(request: GetIterationHistoryRequest): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+    getIterationHistory(request: GetIterationHistoryRequest, metadata: Metadata): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+    getIterationHistory(request: GetIterationHistoryRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetIterationHistoryRequest, GetIterationHistoryResponse>;
+}
+export type TransferSpec_OverwriteStrategy = EnumInstance<"UNRECOGNIZED" | "OVERWRITE_STRATEGY_UNSPECIFIED" | "NEVER" | "IF_NEWER">;
+interface TransferSpec_OverwriteStrategyValueMembers {
+    readonly OVERWRITE_STRATEGY_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "OVERWRITE_STRATEGY_UNSPECIFIED" | "NEVER" | "IF_NEWER">;
+    /**
+     *  Never overwrite objects that exist in the destination.
+     *  If object exists in destination bucket, skip it.
+     *  Safest option to prevent any data loss.
+     *
+     */
+    readonly NEVER: EnumInstance<"UNRECOGNIZED" | "OVERWRITE_STRATEGY_UNSPECIFIED" | "NEVER" | "IF_NEWER">;
+    /**
+     *  Overwrite only if source object is newer than destination.
+     *  Comparison based on Last-Modified timestamp.
+     *  Recommended for incremental sync scenarios.
+     *  If touch_unmanaged flag isn't set, we do not overwrite objects that haven't been created by Data Transfer service.
+     *
+     */
+    readonly IF_NEWER: EnumInstance<"UNRECOGNIZED" | "OVERWRITE_STRATEGY_UNSPECIFIED" | "NEVER" | "IF_NEWER">;
+}
+export type TransferSpec_OverwriteStrategyClass = EnumClass<"UNRECOGNIZED" | "OVERWRITE_STRATEGY_UNSPECIFIED" | "NEVER" | "IF_NEWER"> & TransferSpec_OverwriteStrategyValueMembers;
+export declare const TransferSpec_OverwriteStrategy: TransferSpec_OverwriteStrategyClass;
+/**
+ *  Transfer state.
+ *
+ */
+export type TransferStatus_State = EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+interface TransferStatus_StateValueMembers {
+    readonly STATE_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly ACTIVE: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly STOPPING: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly STOPPED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly FAILING: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly FAILED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+    readonly DELETING: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING">;
+}
+export type TransferStatus_StateClass = EnumClass<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "ACTIVE" | "STOPPING" | "STOPPED" | "FAILING" | "FAILED" | "DELETING"> & TransferStatus_StateValueMembers;
+export declare const TransferStatus_State: TransferStatus_StateClass;
+/**
+ *  Transfer suspension state.
+ *
+ */
+export type TransferStatus_SuspensionState = EnumInstance<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED">;
+interface TransferStatus_SuspensionStateValueMembers {
+    readonly SUSPENSION_STATE_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED">;
+    readonly NOT_SUSPENDED: EnumInstance<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED">;
+    readonly SUSPENDED: EnumInstance<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED">;
+}
+export type TransferStatus_SuspensionStateClass = EnumClass<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED"> & TransferStatus_SuspensionStateValueMembers;
+export declare const TransferStatus_SuspensionState: TransferStatus_SuspensionStateClass;
+/**
+ *  Iteration state.
+ *
+ */
+export type TransferIteration_State = EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+interface TransferIteration_StateValueMembers {
+    readonly STATE_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+    readonly IN_PROGRESS: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+    readonly COMPLETED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+    readonly INTERRUPTED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+    readonly FAILED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED">;
+}
+export type TransferIteration_StateClass = EnumClass<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "IN_PROGRESS" | "COMPLETED" | "INTERRUPTED" | "FAILED"> & TransferIteration_StateValueMembers;
+export declare const TransferIteration_State: TransferIteration_StateClass;
+export type TransferError_Origin = EnumInstance<"UNRECOGNIZED" | "ORIGIN_UNSPECIFIED" | "SOURCE" | "DESTINATION">;
+interface TransferError_OriginValueMembers {
+    readonly ORIGIN_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "ORIGIN_UNSPECIFIED" | "SOURCE" | "DESTINATION">;
+    /**
+     *  Error originated from the source.
+     *
+     */
+    readonly SOURCE: EnumInstance<"UNRECOGNIZED" | "ORIGIN_UNSPECIFIED" | "SOURCE" | "DESTINATION">;
+    /**
+     *  Error originated from the destination.
+     *
+     */
+    readonly DESTINATION: EnumInstance<"UNRECOGNIZED" | "ORIGIN_UNSPECIFIED" | "SOURCE" | "DESTINATION">;
+}
+export type TransferError_OriginClass = EnumClass<"UNRECOGNIZED" | "ORIGIN_UNSPECIFIED" | "SOURCE" | "DESTINATION"> & TransferError_OriginValueMembers;
+export declare const TransferError_Origin: TransferError_OriginClass;
+/**
+ *  Transfer that migrates data from other providers or across different regions of Nebius Object Storage.
+ *  Transfer consists of consecutive iterations where the service lists objects in the source bucket and
+ *  moves those that need to be transferred according to the specified overwrite strategy and touch unmanaged flag value.
+ *  After an iteration completes, the transfer will stop if its stop condition is met. Otherwise,
+ *  it will wait for the defined inter-iteration interval before starting the next iteration.
+ *
+ */
+export interface Transfer {
+    $type: "nebius.storage.v1.Transfer";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: TransferSpec | undefined;
+    status?: TransferStatus | undefined;
+}
+export declare const Transfer: MessageFns<Transfer, "nebius.storage.v1.Transfer">;
+export interface TransferSpec {
+    $type: "nebius.storage.v1.TransferSpec";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Source from which the transfer reads data.
+     *
+     */
+    source?: TransferSource | undefined;
+    /**
+     *  Destination to which the transfer writes data.
+     *
+     */
+    destination?: TransferDestination | undefined;
+    /**
+     *  Limiters applied to source bucket operations. These limits include all operations
+     *  required for transfer (HeadObject, GetObject, ListObjects). For details about
+     *  which operations are used, see public documentation: http://docs.nebius.com/object-storage/transfer/quickstart#background.
+     *
+     *  Note: Since the service performs comparable request volumes and data transfers
+     *  to both source and destination, these limits will indirectly constrain
+     *  destination operations as well.
+     *
+     */
+    limiters?: TransferSpec_Limiters | undefined;
+    /**
+     *  The time to wait since the previous iteration before starting the next one.
+     *  Default is 15 minutes if not specified.
+     *
+     */
+    interIterationInterval?: Duration | undefined;
+    /**
+     *  Overwrite strategy set logic of overwrite already existed objects in destination bucket.
+     *
+     */
+    overwriteStrategy: TransferSpec_OverwriteStrategy;
+    /**
+     *  If touch_unmanaged flag is set, service will be allowed to overwrite and delete from destination objects that were not
+     *  created by Data Transfer Service. If this flag is false, Data Transfer Service will never overwrite or delete objects
+     *  that haven't been created by Data Transfer service.
+     *
+     */
+    touchUnmanaged: boolean;
+    /**
+     *  The stop condition is checked after every iteration. If the condition is met, the transfer will stop.
+     *
+     */
+    stopCondition?: {
+        $case: "afterOneIteration";
+        afterOneIteration: TransferSpec_StopConditionAfterOneIteration;
+    } | {
+        $case: "afterNEmptyIterations";
+        afterNEmptyIterations: TransferSpec_StopConditionAfterNEmptyIterations;
+    } | {
+        $case: "infinite";
+        infinite: TransferSpec_StopConditionInfinite;
+    } | undefined;
+}
+export declare const TransferSpec: MessageFns<TransferSpec, "nebius.storage.v1.TransferSpec">;
+export interface TransferSpec_Limiters {
+    $type: "nebius.storage.v1.TransferSpec.Limiters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Maximum bandwidth in bytes per second. If set to zero, default limit will be applied.
+     *
+     */
+    bandwidthBytesPerSecond: Long;
+    /**
+     *  Maximum number of requests per second. If set to zero, default limit will be applied.
+     *
+     */
+    requestsPerSecond: Long;
+}
+export declare const TransferSpec_Limiters: MessageFns<TransferSpec_Limiters, "nebius.storage.v1.TransferSpec.Limiters">;
+export interface TransferSpec_StopConditionAfterOneIteration {
+    $type: "nebius.storage.v1.TransferSpec.StopConditionAfterOneIteration";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+}
+export declare const TransferSpec_StopConditionAfterOneIteration: MessageFns<TransferSpec_StopConditionAfterOneIteration, "nebius.storage.v1.TransferSpec.StopConditionAfterOneIteration">;
+export interface TransferSpec_StopConditionAfterNEmptyIterations {
+    $type: "nebius.storage.v1.TransferSpec.StopConditionAfterNEmptyIterations";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Number of consecutive iterations with zero transferred objects required to stop transfer.
+     *
+     */
+    emptyIterationsThreshold: number;
+}
+export declare const TransferSpec_StopConditionAfterNEmptyIterations: MessageFns<TransferSpec_StopConditionAfterNEmptyIterations, "nebius.storage.v1.TransferSpec.StopConditionAfterNEmptyIterations">;
+export interface TransferSpec_StopConditionInfinite {
+    $type: "nebius.storage.v1.TransferSpec.StopConditionInfinite";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+}
+export declare const TransferSpec_StopConditionInfinite: MessageFns<TransferSpec_StopConditionInfinite, "nebius.storage.v1.TransferSpec.StopConditionInfinite">;
+export interface TransferSource {
+    $type: "nebius.storage.v1.TransferSource";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Prefix to filter objects in the source. Only objects whose keys start with this prefix will be transferred.
+     *  During transfer, the resulting object key in the destination is computed
+     *  by removing source.prefix from the original key and then prepending destination.prefix (if provided).
+     *  Important: This transformation may result in an empty object key or one that exceeds allowed length limits.
+     *  Use prefixes that guarantee valid resulting object keys for your objects after transformation.
+     *
+     */
+    prefix: string;
+    /**
+     *  Source storage provider configuration.
+     *
+     */
+    provider?: {
+        $case: "nebius";
+        nebius: TransferSource_NebiusProvider;
+    } | {
+        $case: "s3Compatible";
+        s3Compatible: TransferSource_S3CompatibleProvider;
+    } | {
+        $case: "azureBlobStorage";
+        azureBlobStorage: TransferSource_AzureBlobStorageProvider;
+    } | undefined;
+}
+export declare const TransferSource: MessageFns<TransferSource, "nebius.storage.v1.TransferSource">;
+export interface TransferSource_NebiusProvider {
+    $type: "nebius.storage.v1.TransferSource.NebiusProvider";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Nebius region where the source bucket is located.
+     *
+     */
+    region: string;
+    /**
+     *  Name of the source bucket.
+     *
+     */
+    bucketName: string;
+    /**
+     *  Credentials for accessing the source bucket. These credentials must have list and get permissions.
+     *
+     */
+    credentials?: {
+        $case: "anonymous";
+        anonymous: TransferCredentialsAnonymous;
+    } | {
+        $case: "accessKey";
+        accessKey: TransferCredentialsAccessKey;
+    } | undefined;
+}
+export declare const TransferSource_NebiusProvider: MessageFns<TransferSource_NebiusProvider, "nebius.storage.v1.TransferSource.NebiusProvider">;
+export interface TransferSource_S3CompatibleProvider {
+    $type: "nebius.storage.v1.TransferSource.S3CompatibleProvider";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  The endpoint must be in the form of a URL, starting with the protocol (https),
+     *  followed by the endpoint address without a trailing slash.
+     *  Example: "https://storage.some-cloud".
+     *
+     */
+    endpoint: string;
+    /**
+     *  S3-compatible provider region where source bucket is located.
+     *
+     */
+    region: string;
+    /**
+     *  Name of the source bucket.
+     *
+     */
+    bucketName: string;
+    /**
+     *  Credentials for accessing the source bucket. These credentials must have list and get permissions.
+     *
+     */
+    credentials?: {
+        $case: "anonymous";
+        anonymous: TransferCredentialsAnonymous;
+    } | {
+        $case: "accessKey";
+        accessKey: TransferCredentialsAccessKey;
+    } | undefined;
+}
+export declare const TransferSource_S3CompatibleProvider: MessageFns<TransferSource_S3CompatibleProvider, "nebius.storage.v1.TransferSource.S3CompatibleProvider">;
+export interface TransferSource_AzureBlobStorageProvider {
+    $type: "nebius.storage.v1.TransferSource.AzureBlobStorageProvider";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  The endpoint must be in the form of a URL, starting with the protocol (https),
+     *  followed by the endpoint address without a trailing slash.
+     *  Example: "https://storageaccountname.blob.core.windows.net".
+     *
+     */
+    endpoint: string;
+    /**
+     *  Name of the source Azure Blob Storage container.
+     *
+     */
+    containerName: string;
+    /**
+     *  Credentials for accessing the source container. These credentials must have list and get permissions.
+     *
+     */
+    credentials?: {
+        $case: "anonymous";
+        anonymous: TransferCredentialsAnonymous;
+    } | {
+        $case: "azureStorageAccount";
+        azureStorageAccount: TransferCredentialsAzureStorageAccount;
+    } | undefined;
+}
+export declare const TransferSource_AzureBlobStorageProvider: MessageFns<TransferSource_AzureBlobStorageProvider, "nebius.storage.v1.TransferSource.AzureBlobStorageProvider">;
+export interface TransferDestination {
+    $type: "nebius.storage.v1.TransferDestination";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Prefix to add to the beginning of each transferred object key in the destination.
+     *  During transfer, the resulting object key in the destination is computed
+     *  by removing source.prefix (if provided) from the original key and then prepending destination.prefix.
+     *  Important: This transformation may result in an empty object key or one that exceeds allowed length limits.
+     *  Use prefixes that guarantee valid resulting object keys for your objects after transformation.
+     *
+     */
+    prefix: string;
+    /**
+     *  Destination storage provider configuration.
+     *
+     */
+    provider?: {
+        $case: "nebius";
+        nebius: TransferDestination_NebiusProvider;
+    } | {
+        $case: "s3Compatible";
+        s3Compatible: TransferDestination_S3CompatibleProvider;
+    } | undefined;
+}
+export declare const TransferDestination: MessageFns<TransferDestination, "nebius.storage.v1.TransferDestination">;
+export interface TransferDestination_NebiusProvider {
+    $type: "nebius.storage.v1.TransferDestination.NebiusProvider";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Nebius region where the destination bucket is located.
+     *
+     */
+    region: string;
+    /**
+     *  Name of the destination bucket.
+     *
+     */
+    bucketName: string;
+    /**
+     *  Credentials for accessing the destination bucket.
+     *  These credentials must have head, write permissions.
+     *
+     */
+    credentials?: {
+        $case: "accessKey";
+        accessKey: TransferCredentialsAccessKey;
+    } | undefined;
+}
+export declare const TransferDestination_NebiusProvider: MessageFns<TransferDestination_NebiusProvider, "nebius.storage.v1.TransferDestination.NebiusProvider">;
+export interface TransferDestination_S3CompatibleProvider {
+    $type: "nebius.storage.v1.TransferDestination.S3CompatibleProvider";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  The endpoint must be in the form of a URL, starting with the protocol (https),
+     *  followed by the endpoint address without a trailing slash.
+     *  Example: "https://storage.some-cloud".
+     *
+     */
+    endpoint: string;
+    /**
+     *  S3-compatible provider region where destination bucket is located.
+     *
+     */
+    region: string;
+    /**
+     *  Name of the destination bucket.
+     *
+     */
+    bucketName: string;
+    /**
+     *  Credentials for accessing the destination bucket.
+     *  These credentials must have head, write permissions.
+     *
+     */
+    credentials?: {
+        $case: "anonymous";
+        anonymous: TransferCredentialsAnonymous;
+    } | {
+        $case: "accessKey";
+        accessKey: TransferCredentialsAccessKey;
+    } | undefined;
+}
+export declare const TransferDestination_S3CompatibleProvider: MessageFns<TransferDestination_S3CompatibleProvider, "nebius.storage.v1.TransferDestination.S3CompatibleProvider">;
+export interface TransferCredentialsAnonymous {
+    $type: "nebius.storage.v1.TransferCredentialsAnonymous";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+}
+export declare const TransferCredentialsAnonymous: MessageFns<TransferCredentialsAnonymous, "nebius.storage.v1.TransferCredentialsAnonymous">;
+export interface TransferCredentialsAccessKey {
+    $type: "nebius.storage.v1.TransferCredentialsAccessKey";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Access key ID.
+     *
+     */
+    accessKeyId: string;
+    /**
+     *  Secret access key.
+     *
+     */
+    secretAccessKey: string;
+}
+export declare const TransferCredentialsAccessKey: MessageFns<TransferCredentialsAccessKey, "nebius.storage.v1.TransferCredentialsAccessKey">;
+export interface TransferCredentialsAzureStorageAccount {
+    $type: "nebius.storage.v1.TransferCredentialsAzureStorageAccount";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Storage account name.
+     *
+     */
+    accountName: string;
+    /**
+     *  Storage account access key.
+     *
+     */
+    accessKey: string;
+}
+export declare const TransferCredentialsAzureStorageAccount: MessageFns<TransferCredentialsAzureStorageAccount, "nebius.storage.v1.TransferCredentialsAzureStorageAccount">;
+export interface TransferStatus {
+    $type: "nebius.storage.v1.TransferStatus";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Current transfer state.
+     *
+     */
+    state: TransferStatus_State;
+    /**
+     *  Error information if the transfer has failed.
+     *
+     */
+    error?: TransferError | undefined;
+    /**
+     *  If the transfer is suspended, transfer's suspension state becomes SUSPENDED.
+     *
+     */
+    suspensionState: TransferStatus_SuspensionState;
+    /**
+     *  If there is active iteration, its status will be given.
+     *  If it is a new transfer that doesn't have iteration yet, nothing will be returned.
+     *  Otherwise, last finished transaction will be returned.
+     *
+     */
+    lastIteration?: TransferIteration | undefined;
+}
+export declare const TransferStatus: MessageFns<TransferStatus, "nebius.storage.v1.TransferStatus">;
+export interface TransferIteration {
+    $type: "nebius.storage.v1.TransferIteration";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Sequence number of the iteration in the transfer, starting from 1.
+     *
+     */
+    sequenceNumber: Long;
+    /**
+     *  Current iteration state.
+     *
+     */
+    state: TransferIteration_State;
+    /**
+     *  Human-readable error description. Populated only if state is FAILED.
+     *
+     */
+    error?: TransferError | undefined;
+    /**
+     *  Iteration start time.
+     *
+     */
+    startTime?: Dayjs | undefined;
+    /**
+     *  Iteration end time.
+     *
+     */
+    endTime?: Dayjs | undefined;
+    /**
+     *  Number of objects transferred during this iteration.
+     *
+     */
+    objectsTransferredCount: Long;
+    /**
+     *  Total size of objects transferred during this iteration.
+     *
+     */
+    objectsTransferredSize: Long;
+    /**
+     *  Average throughput in bytes per second during the iteration.
+     *
+     */
+    averageThroughputBytes: Long;
+}
+export declare const TransferIteration: MessageFns<TransferIteration, "nebius.storage.v1.TransferIteration">;
+export interface TransferError {
+    $type: "nebius.storage.v1.TransferError";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Endpoint where the error occurred.
+     *
+     */
+    origin: TransferError_Origin;
+    /**
+     *  Error code, usually taken from the endpoint response.
+     *
+     */
+    code: string;
+    /**
+     *  Error message, usually taken from the endpoint response.
+     *
+     */
+    message: string;
+}
+export declare const TransferError: MessageFns<TransferError, "nebius.storage.v1.TransferError">;
 export {};
 //# sourceMappingURL=index.d.ts.map