@nebius/js-sdk 0.1.0

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

@@ -0,0 +1,928 @@
+import { Long, unknownFieldsSymbol } from "../../../../runtime/protos/index";
+import type { Dayjs, Duration, MessageFns, EnumInstance, EnumClass } from "../../../../runtime/protos/index";
+import { customJson } from "../../../../runtime/util/logging";
+import { ChannelCredentials, Client, ClientUnaryCall, ClientOptions, CallOptions, Metadata, ServiceError as GrpcServiceError, handleUnaryCall, UntypedServiceImplementation } from "@grpc/grpc-js";
+import type { SDKInterface } from "../../../../sdk";
+import { Request as SDKRequestClass, type RetryOptions } from "../../../../runtime/request";
+import { Operation as OperationWrapper } from "../../../../runtime/operation";
+import { GetOperationRequest, Operation, OperationService, ResourceMetadata } from "../../common/v1";
+export type StorageClass = EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT">;
+interface StorageClassValueMembers {
+    readonly STORAGE_CLASS_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT">;
+    readonly STANDARD: EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT">;
+    readonly ENHANCED_THROUGHPUT: EnumInstance<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT">;
+}
+export type StorageClassClass = EnumClass<"UNRECOGNIZED" | "STORAGE_CLASS_UNSPECIFIED" | "STANDARD" | "ENHANCED_THROUGHPUT"> & StorageClassValueMembers;
+export declare const StorageClass: StorageClassClass;
+export type VersioningPolicy = EnumInstance<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED">;
+interface VersioningPolicyValueMembers {
+    readonly VERSIONING_POLICY_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED">;
+    readonly DISABLED: EnumInstance<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED">;
+    readonly ENABLED: EnumInstance<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED">;
+    readonly SUSPENDED: EnumInstance<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED">;
+}
+export type VersioningPolicyClass = EnumClass<"UNRECOGNIZED" | "VERSIONING_POLICY_UNSPECIFIED" | "DISABLED" | "ENABLED" | "SUSPENDED"> & VersioningPolicyValueMembers;
+export declare const VersioningPolicy: VersioningPolicyClass;
+export interface CurrentBucketCounters {
+    $type: "nebius.storage.v1.CurrentBucketCounters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    simpleObjectsQuantity: Long;
+    simpleObjectsSize: Long;
+    multipartObjectsQuantity: Long;
+    multipartObjectsSize: Long;
+    multipartUploadsQuantity: Long;
+    inflightPartsQuantity: Long;
+    inflightPartsSize: Long;
+}
+export declare const CurrentBucketCounters: MessageFns<CurrentBucketCounters, "nebius.storage.v1.CurrentBucketCounters">;
+/**
+ *  Counters for non-current object versions (for versioning buckets).
+ *
+ */
+export interface NonCurrentBucketCounters {
+    $type: "nebius.storage.v1.NonCurrentBucketCounters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    simpleObjectsQuantity: Long;
+    simpleObjectsSize: Long;
+    multipartObjectsQuantity: Long;
+    multipartObjectsSize: Long;
+}
+export declare const NonCurrentBucketCounters: MessageFns<NonCurrentBucketCounters, "nebius.storage.v1.NonCurrentBucketCounters">;
+export interface BucketCounters {
+    $type: "nebius.storage.v1.BucketCounters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    storageClass: StorageClass;
+    counters?: CurrentBucketCounters | undefined;
+    nonCurrentCounters?: NonCurrentBucketCounters | undefined;
+}
+export declare const BucketCounters: MessageFns<BucketCounters, "nebius.storage.v1.BucketCounters">;
+export interface GetBucketRequest {
+    $type: "nebius.storage.v1.GetBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const GetBucketRequest: MessageFns<GetBucketRequest, "nebius.storage.v1.GetBucketRequest">;
+export interface GetBucketByNameRequest {
+    $type: "nebius.storage.v1.GetBucketByNameRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    parentId: string;
+    name: string;
+}
+export declare const GetBucketByNameRequest: MessageFns<GetBucketByNameRequest, "nebius.storage.v1.GetBucketByNameRequest">;
+export interface CreateBucketRequest {
+    $type: "nebius.storage.v1.CreateBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: BucketSpec | undefined;
+}
+export declare const CreateBucketRequest: MessageFns<CreateBucketRequest, "nebius.storage.v1.CreateBucketRequest">;
+export interface UpdateBucketRequest {
+    $type: "nebius.storage.v1.UpdateBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: BucketSpec | undefined;
+}
+export declare const UpdateBucketRequest: MessageFns<UpdateBucketRequest, "nebius.storage.v1.UpdateBucketRequest">;
+export interface DeleteBucketRequest {
+    $type: "nebius.storage.v1.DeleteBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+    /**
+     *  You can provide purge_at or ttl after which the bucket will be purged automatically.
+     *  Otherwise, default ttl of 7 days will be applied.
+     *
+     */
+    purge?: {
+        $case: "purgeAt";
+        purgeAt: Dayjs;
+    } | {
+        $case: "ttl";
+        ttl: Duration;
+    } | undefined;
+}
+export declare const DeleteBucketRequest: MessageFns<DeleteBucketRequest, "nebius.storage.v1.DeleteBucketRequest">;
+export interface PurgeBucketRequest {
+    $type: "nebius.storage.v1.PurgeBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const PurgeBucketRequest: MessageFns<PurgeBucketRequest, "nebius.storage.v1.PurgeBucketRequest">;
+export interface UndeleteBucketRequest {
+    $type: "nebius.storage.v1.UndeleteBucketRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const UndeleteBucketRequest: MessageFns<UndeleteBucketRequest, "nebius.storage.v1.UndeleteBucketRequest">;
+export interface ListBucketsRequest {
+    $type: "nebius.storage.v1.ListBucketsRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Represents the container ID.
+     *
+     */
+    parentId: 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;
+    /**
+     *  A filter to narrow down the results based on specific criteria.
+     *
+     */
+    filter: string;
+}
+export declare const ListBucketsRequest: MessageFns<ListBucketsRequest, "nebius.storage.v1.ListBucketsRequest">;
+export interface ListBucketsResponse {
+    $type: "nebius.storage.v1.ListBucketsResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  List of buckets returned in the response. The field should be named as `items` for consistency.
+     *
+     */
+    items: Bucket[];
+    /**
+     *  Token for pagination, indicating the next set of results can be retrieved using this token.
+     *
+     */
+    nextPageToken: string;
+}
+export declare const ListBucketsResponse: MessageFns<ListBucketsResponse, "nebius.storage.v1.ListBucketsResponse">;
+export type BucketServiceServiceDescription = typeof BucketServiceServiceDescription;
+export declare const BucketServiceServiceDescription: {
+    readonly get: {
+        readonly path: "/nebius.storage.v1.BucketService/Get";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetBucketRequest;
+        readonly responseSerialize: (value: Bucket) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Bucket;
+    };
+    readonly getByName: {
+        readonly path: "/nebius.storage.v1.BucketService/GetByName";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetBucketByNameRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetBucketByNameRequest;
+        readonly responseSerialize: (value: Bucket) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Bucket;
+    };
+    readonly list: {
+        readonly path: "/nebius.storage.v1.BucketService/List";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListBucketsRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ListBucketsRequest;
+        readonly responseSerialize: (value: ListBucketsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ListBucketsResponse;
+    };
+    readonly create: {
+        readonly path: "/nebius.storage.v1.BucketService/Create";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => CreateBucketRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly update: {
+        readonly path: "/nebius.storage.v1.BucketService/Update";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => UpdateBucketRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly delete: {
+        readonly path: "/nebius.storage.v1.BucketService/Delete";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => DeleteBucketRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly purge: {
+        readonly path: "/nebius.storage.v1.BucketService/Purge";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: PurgeBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => PurgeBucketRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly undelete: {
+        readonly path: "/nebius.storage.v1.BucketService/Undelete";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UndeleteBucketRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => UndeleteBucketRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+};
+export interface BucketServiceServer extends UntypedServiceImplementation {
+    get: handleUnaryCall<GetBucketRequest, Bucket>;
+    getByName: handleUnaryCall<GetBucketByNameRequest, Bucket>;
+    list: handleUnaryCall<ListBucketsRequest, ListBucketsResponse>;
+    create: handleUnaryCall<CreateBucketRequest, Operation>;
+    update: handleUnaryCall<UpdateBucketRequest, Operation>;
+    delete: handleUnaryCall<DeleteBucketRequest, Operation>;
+    purge: handleUnaryCall<PurgeBucketRequest, Operation>;
+    undelete: handleUnaryCall<UndeleteBucketRequest, Operation>;
+}
+export interface BucketServiceBaseClient extends Client {
+    get(request: GetBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Bucket) => void): ClientUnaryCall;
+    getByName(request: GetBucketByNameRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Bucket) => void): ClientUnaryCall;
+    list(request: ListBucketsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: ListBucketsResponse) => void): ClientUnaryCall;
+    create(request: CreateBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    update(request: UpdateBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    delete(request: DeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    purge(request: PurgeBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    undelete(request: UndeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+}
+export declare const BucketServiceBaseClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): BucketServiceBaseClient;
+    service: typeof BucketServiceServiceDescription;
+    serviceName: string;
+};
+export interface BucketService {
+    $type: "nebius.storage.v1.BucketService";
+    get(request: GetBucketRequest): SDKRequestClass<GetBucketRequest, Bucket>;
+    get(request: GetBucketRequest, metadata: Metadata): SDKRequestClass<GetBucketRequest, Bucket>;
+    get(request: GetBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetBucketRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest, metadata: Metadata): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    list(request: ListBucketsRequest): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    list(request: ListBucketsRequest, metadata: Metadata): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    list(request: ListBucketsRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    create(request: CreateBucketRequest): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateBucketRequest, metadata: Metadata): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest, metadata: Metadata): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest, metadata: Metadata): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Purge instantly deletes the bucket in ScheduledForDeletion state.
+     *  It can be used only for buckets in ScheduledForDeletion state.
+     *  If you want to delete Active bucket instantly, use Delete with zero ttl.
+     *
+     */
+    purge(request: PurgeBucketRequest): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    purge(request: PurgeBucketRequest, metadata: Metadata): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    purge(request: PurgeBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    /**
+     *  Undelete recovers the bucket from ScheduledForDeletion state to Active.
+     *
+     */
+    undelete(request: UndeleteBucketRequest): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    undelete(request: UndeleteBucketRequest, metadata: Metadata): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    undelete(request: UndeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+}
+export declare class BucketService implements BucketService {
+    private sdk;
+    $type: "nebius.storage.v1.BucketService";
+    private addr;
+    private spec;
+    private apiServiceName;
+    constructor(sdk: SDKInterface);
+    getOperationService(): OperationService;
+    get(request: GetBucketRequest): SDKRequestClass<GetBucketRequest, Bucket>;
+    get(request: GetBucketRequest, metadata: Metadata): SDKRequestClass<GetBucketRequest, Bucket>;
+    get(request: GetBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetBucketRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest, metadata: Metadata): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    getByName(request: GetBucketByNameRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetBucketByNameRequest, Bucket>;
+    list(request: ListBucketsRequest): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    list(request: ListBucketsRequest, metadata: Metadata): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    list(request: ListBucketsRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListBucketsRequest, ListBucketsResponse>;
+    create(request: CreateBucketRequest): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateBucketRequest, metadata: Metadata): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    create(request: CreateBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<CreateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest, metadata: Metadata): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    update(request: UpdateBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UpdateBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest, metadata: Metadata): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    delete(request: DeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<DeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    purge(request: PurgeBucketRequest): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    purge(request: PurgeBucketRequest, metadata: Metadata): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    purge(request: PurgeBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<PurgeBucketRequest, OperationWrapper<GetOperationRequest>>;
+    undelete(request: UndeleteBucketRequest): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    undelete(request: UndeleteBucketRequest, metadata: Metadata): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+    undelete(request: UndeleteBucketRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<UndeleteBucketRequest, OperationWrapper<GetOperationRequest>>;
+}
+export type BucketStatus_State = EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+interface BucketStatus_StateValueMembers {
+    readonly STATE_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+    /**
+     *  Bucket is under creation and cannot be used yet.
+     *
+     */
+    readonly CREATING: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+    /**
+     *  Bucket is active and ready for usage.
+     *
+     */
+    readonly ACTIVE: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+    /**
+     *  Bucket is being updated.
+     *  It can be used, but some settings are being modified and you can observe their inconsistency.
+     *
+     */
+    readonly UPDATING: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+    /**
+     *  Bucket is scheduled for deletion.
+     *  It cannot be used in s3 api anymore.
+     *
+     */
+    readonly SCHEDULED_FOR_DELETION: EnumInstance<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION">;
+}
+export type BucketStatus_StateClass = EnumClass<"UNRECOGNIZED" | "STATE_UNSPECIFIED" | "CREATING" | "ACTIVE" | "UPDATING" | "SCHEDULED_FOR_DELETION"> & BucketStatus_StateValueMembers;
+export declare const BucketStatus_State: BucketStatus_StateClass;
+export type BucketStatus_SuspensionState = EnumInstance<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED">;
+interface BucketStatus_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 BucketStatus_SuspensionStateClass = EnumClass<"UNRECOGNIZED" | "SUSPENSION_STATE_UNSPECIFIED" | "NOT_SUSPENDED" | "SUSPENDED"> & BucketStatus_SuspensionStateValueMembers;
+export declare const BucketStatus_SuspensionState: BucketStatus_SuspensionStateClass;
+export interface Bucket {
+    $type: "nebius.storage.v1.Bucket";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    metadata?: ResourceMetadata | undefined;
+    spec?: BucketSpec | undefined;
+    status?: BucketStatus | undefined;
+}
+export declare const Bucket: MessageFns<Bucket, "nebius.storage.v1.Bucket">;
+export interface BucketSpec {
+    $type: "nebius.storage.v1.BucketSpec";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Supports transitions:
+     *   * disabled -> enabled
+     *   * disabled -> suspended
+     *   * enabled <-> suspended
+     *
+     */
+    versioningPolicy: VersioningPolicy;
+    /**
+     *  Maximum bucket size.
+     *  Zero means unlimited.
+     *  Actual limit can be lower if customer doesn't have enough quota.
+     *  Real bucket size can go a little higher if customer writes too fast.
+     *
+     */
+    maxSizeBytes: Long;
+    lifecycleConfiguration?: LifecycleConfiguration | undefined;
+    /**
+     *  Storage class to use by default for uploads to the bucket. It may be overridden by `x-amz-storage-class` header.
+     *  If not set - STANDARD is used as a default storage class.
+     *
+     */
+    defaultStorageClass: StorageClass;
+    /**
+     *  Storage class to override any other storage class of uploading objects. It overrides the storage class regardless
+     *  of how the original storage class was specified - either the default storage class
+     *  or the one provided via the `x-amz-storage-class` header.
+     *
+     * @deprecated Deprecated, will be removed on 2025-12-01: Use `default_storage_class` with `force_storage_class` instead.
+     */
+    overrideStorageClass: StorageClass;
+    /**
+     *  Flag to force usage of default_storage_class, ignoring `x-amz-storage-class` header.
+     *
+     */
+    forceStorageClass: boolean;
+}
+export declare const BucketSpec: MessageFns<BucketSpec, "nebius.storage.v1.BucketSpec">;
+export interface BucketStatus {
+    $type: "nebius.storage.v1.BucketStatus";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    counters: BucketCounters[];
+    state: BucketStatus_State;
+    suspensionState: BucketStatus_SuspensionState;
+    /**
+     *  The time when the bucket was deleted (or scheduled for deletion).
+     *  It resets to null if the bucket is undeleted.
+     *
+     */
+    deletedAt?: Dayjs | undefined;
+    /**
+     *  The time when the bucket will be automatically purged in case it was soft-deleted.
+     *
+     */
+    purgeAt?: Dayjs | undefined;
+    /**
+     *  The domain of the endpoint where the bucket can be accessed. It omits the scheme (HTTPS) and the port (443)
+     *  and contains only the FQDN address.
+     *
+     */
+    domainName: string;
+    /**
+     *  The name of the region where the bucket is located for use with S3 clients, i.e. "eu-west1".
+     *
+     */
+    region: string;
+}
+export declare const BucketStatus: MessageFns<BucketStatus, "nebius.storage.v1.BucketStatus">;
+export type LifecycleRule_Status = EnumInstance<"UNRECOGNIZED" | "STATUS_UNSPECIFIED" | "ENABLED" | "DISABLED">;
+interface LifecycleRule_StatusValueMembers {
+    readonly STATUS_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "STATUS_UNSPECIFIED" | "ENABLED" | "DISABLED">;
+    readonly ENABLED: EnumInstance<"UNRECOGNIZED" | "STATUS_UNSPECIFIED" | "ENABLED" | "DISABLED">;
+    readonly DISABLED: EnumInstance<"UNRECOGNIZED" | "STATUS_UNSPECIFIED" | "ENABLED" | "DISABLED">;
+}
+export type LifecycleRule_StatusClass = EnumClass<"UNRECOGNIZED" | "STATUS_UNSPECIFIED" | "ENABLED" | "DISABLED"> & LifecycleRule_StatusValueMembers;
+export declare const LifecycleRule_Status: LifecycleRule_StatusClass;
+/**
+ *  The lifecycle configuration consists of one or more rules.
+ *  An Lifecycle configuration can have up to 1,000 rules.
+ *  Each rule consists of the following:
+ *  - A filter identifying a subset of objects to which the rule applies.
+ *    The filter can be based on a key name prefix, object size, or any combination of these.
+ *  - A status indicating whether the rule is currently active.
+ *  - One or more lifecycle expiration actions that you want to be performed on the objects
+ *    identified by the filter. If the state of your bucket is versioning-enabled or versioning-suspended
+ *    (bucket.spec.versioning_policy equals to ENABLED or SUSPENDED) you can have many versions of the same
+ *    object (one current version and zero or more noncurrent versions). The system provides predefined actions
+ *    that you can specify for current and noncurrent object versions.
+ *
+ */
+export interface LifecycleConfiguration {
+    $type: "nebius.storage.v1.LifecycleConfiguration";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    rules: LifecycleRule[];
+}
+export declare const LifecycleConfiguration: MessageFns<LifecycleConfiguration, "nebius.storage.v1.LifecycleConfiguration">;
+export interface LifecycleRule {
+    $type: "nebius.storage.v1.LifecycleRule";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Unique identifier for the rule per configuration.
+     *  The value cannot be longer than 255 characters.
+     *
+     */
+    id: string;
+    status: LifecycleRule_Status;
+    /**
+     *  The Filter is used to identify objects that a Lifecycle Rule applies to.
+     *  The Lifecycle Rule will apply to any object matching all of the predicates
+     *  configured inside (using logical AND).
+     *
+     */
+    filter?: LifecycleFilter | undefined;
+    /**
+     *  Specifies the expiration for the lifecycle of the object in the form of date, days and,
+     *  whether the object has a delete marker.
+     *
+     */
+    expiration?: LifecycleExpiration | undefined;
+    /**
+     *  Specifies when noncurrent object versions expire.
+     *  It works only on a bucket that has versioning enabled (or suspended).
+     *
+     */
+    noncurrentVersionExpiration?: LifecycleNoncurrentVersionExpiration | undefined;
+    /**
+     *  Specifies the days since the initiation of an incomplete multipart upload that
+     *  the system will wait before permanently removing all parts of the upload.
+     *
+     */
+    abortIncompleteMultipartUpload?: LifecycleAbortIncompleteMultipartUpload | undefined;
+    /**
+     *  Specifies the transition for the lifecycle of an object in the form of date or days and
+     *  target storage class to transit object to.
+     *
+     */
+    transition?: LifecycleTransition | undefined;
+    /**
+     *  Specifies the transition for the lifecycle of a noncurrent object.
+     *  It works only on a bucket that has versioning enabled (or suspended).
+     *
+     */
+    noncurrentVersionTransition?: LifecycleNoncurrentVersionTransition | undefined;
+}
+export declare const LifecycleRule: MessageFns<LifecycleRule, "nebius.storage.v1.LifecycleRule">;
+export interface LifecycleFilter {
+    $type: "nebius.storage.v1.LifecycleFilter";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Prefix identifying one or more objects to which the rule applies.
+     *  If prefix is empty, the rule applies to all objects in the bucket.
+     *
+     */
+    prefix: string;
+    /**
+     *  Minimum object size to which the rule applies.
+     *
+     */
+    objectSizeGreaterThanBytes: Long;
+    /**
+     *  Maximum object size to which the rule applies.
+     *
+     */
+    objectSizeLessThanBytes: Long;
+}
+export declare const LifecycleFilter: MessageFns<LifecycleFilter, "nebius.storage.v1.LifecycleFilter">;
+export interface LifecycleExpiration {
+    $type: "nebius.storage.v1.LifecycleExpiration";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Indicates whether the system will remove a "delete marker" with no noncurrent versions.
+     *  If set to true, the "delete marker" will be permanently removed.
+     *  If set to false the policy takes no action.
+     *  This cannot be specified with Days or Date in a LifecycleExpiration Policy.
+     *
+     */
+    expiredObjectDeleteMarker: boolean;
+    expiredWith?: {
+        $case: "date";
+        date: Dayjs;
+    } | {
+        $case: "days";
+        days: number;
+    } | undefined;
+}
+export declare const LifecycleExpiration: MessageFns<LifecycleExpiration, "nebius.storage.v1.LifecycleExpiration">;
+export interface LifecycleNoncurrentVersionExpiration {
+    $type: "nebius.storage.v1.LifecycleNoncurrentVersionExpiration";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Specifies how many noncurrent versions the system will retain.
+     *
+     */
+    newerNoncurrentVersions?: number | undefined;
+    /**
+     *  Specifies the number of days an object is noncurrent before the system will expire it.
+     *
+     */
+    noncurrentDays: number;
+}
+export declare const LifecycleNoncurrentVersionExpiration: MessageFns<LifecycleNoncurrentVersionExpiration, "nebius.storage.v1.LifecycleNoncurrentVersionExpiration">;
+export interface LifecycleAbortIncompleteMultipartUpload {
+    $type: "nebius.storage.v1.LifecycleAbortIncompleteMultipartUpload";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Specifies the days since the initiation of an incomplete multipart upload that
+     *  the system will wait before permanently removing all parts of the upload.
+     *
+     */
+    daysAfterInitiation: number;
+}
+export declare const LifecycleAbortIncompleteMultipartUpload: MessageFns<LifecycleAbortIncompleteMultipartUpload, "nebius.storage.v1.LifecycleAbortIncompleteMultipartUpload">;
+export interface LifecycleTransition {
+    $type: "nebius.storage.v1.LifecycleTransition";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Target storage class to transit to.
+     *
+     */
+    storageClass: StorageClass;
+    transitedWith?: {
+        $case: "date";
+        date: Dayjs;
+    } | {
+        $case: "days";
+        days: number;
+    } | undefined;
+}
+export declare const LifecycleTransition: MessageFns<LifecycleTransition, "nebius.storage.v1.LifecycleTransition">;
+export interface LifecycleNoncurrentVersionTransition {
+    $type: "nebius.storage.v1.LifecycleNoncurrentVersionTransition";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Specifies how many noncurrent versions the system will retain without transition.
+     *
+     */
+    newerNoncurrentVersions?: number | undefined;
+    /**
+     *  Specifies the number of days an object is noncurrent before the system will transit it.
+     *
+     */
+    noncurrentDays: number;
+    /**
+     *  Target storage class to transit to.
+     *
+     */
+    storageClass: StorageClass;
+}
+export declare const LifecycleNoncurrentVersionTransition: MessageFns<LifecycleNoncurrentVersionTransition, "nebius.storage.v1.LifecycleNoncurrentVersionTransition">;
+export interface CompleteMultipartUploadRequestParameters {
+    $type: "nebius.storage.v1.CompleteMultipartUploadRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    parts: CompleteMultipartUploadRequestParameters_Part[];
+}
+export declare const CompleteMultipartUploadRequestParameters: MessageFns<CompleteMultipartUploadRequestParameters, "nebius.storage.v1.CompleteMultipartUploadRequestParameters">;
+export interface CompleteMultipartUploadRequestParameters_Part {
+    $type: "nebius.storage.v1.CompleteMultipartUploadRequestParameters.Part";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    partNumber: number;
+    etag: string;
+}
+export declare const CompleteMultipartUploadRequestParameters_Part: MessageFns<CompleteMultipartUploadRequestParameters_Part, "nebius.storage.v1.CompleteMultipartUploadRequestParameters.Part">;
+export interface CompleteMultipartUploadResponse {
+    $type: "nebius.storage.v1.CompleteMultipartUploadResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    etag: string;
+}
+export declare const CompleteMultipartUploadResponse: MessageFns<CompleteMultipartUploadResponse, "nebius.storage.v1.CompleteMultipartUploadResponse">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface CopyObjectRequestParameters {
+    $type: "nebius.storage.v1.CopyObjectRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    source?: CopyObjectRequestParameters_Source | undefined;
+    target?: CopyObjectRequestParameters_Target | undefined;
+}
+export declare const CopyObjectRequestParameters: MessageFns<CopyObjectRequestParameters, "nebius.storage.v1.CopyObjectRequestParameters">;
+export interface CopyObjectRequestParameters_Source {
+    $type: "nebius.storage.v1.CopyObjectRequestParameters.Source";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    version: string;
+}
+export declare const CopyObjectRequestParameters_Source: MessageFns<CopyObjectRequestParameters_Source, "nebius.storage.v1.CopyObjectRequestParameters.Source">;
+export interface CopyObjectRequestParameters_Target {
+    $type: "nebius.storage.v1.CopyObjectRequestParameters.Target";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+}
+export declare const CopyObjectRequestParameters_Target: MessageFns<CopyObjectRequestParameters_Target, "nebius.storage.v1.CopyObjectRequestParameters.Target">;
+export interface CopyObjectResponse {
+    $type: "nebius.storage.v1.CopyObjectResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    lastModified?: Dayjs | undefined;
+}
+export declare const CopyObjectResponse: MessageFns<CopyObjectResponse, "nebius.storage.v1.CopyObjectResponse">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface DeleteObjectRequestParameters {
+    $type: "nebius.storage.v1.DeleteObjectRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    version: string;
+}
+export declare const DeleteObjectRequestParameters: MessageFns<DeleteObjectRequestParameters, "nebius.storage.v1.DeleteObjectRequestParameters">;
+export interface DeleteObjectResponse {
+    $type: "nebius.storage.v1.DeleteObjectResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    deleteMarker: boolean;
+}
+export declare const DeleteObjectResponse: MessageFns<DeleteObjectResponse, "nebius.storage.v1.DeleteObjectResponse">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface DeleteObjectsRequestParameters {
+    $type: "nebius.storage.v1.DeleteObjectsRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objects: DeleteObjectsRequestParameters_ObjectKey[];
+}
+export declare const DeleteObjectsRequestParameters: MessageFns<DeleteObjectsRequestParameters, "nebius.storage.v1.DeleteObjectsRequestParameters">;
+export interface DeleteObjectsRequestParameters_ObjectKey {
+    $type: "nebius.storage.v1.DeleteObjectsRequestParameters.ObjectKey";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    key: string;
+    version: string;
+}
+export declare const DeleteObjectsRequestParameters_ObjectKey: MessageFns<DeleteObjectsRequestParameters_ObjectKey, "nebius.storage.v1.DeleteObjectsRequestParameters.ObjectKey">;
+export interface DeleteObjectsResponse {
+    $type: "nebius.storage.v1.DeleteObjectsResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    deleted: DeleteObjectsResponse_DeleteSuccess[];
+    errors: DeleteObjectsResponse_DeleteError[];
+}
+export declare const DeleteObjectsResponse: MessageFns<DeleteObjectsResponse, "nebius.storage.v1.DeleteObjectsResponse">;
+export interface DeleteObjectsResponse_DeleteSuccess {
+    $type: "nebius.storage.v1.DeleteObjectsResponse.DeleteSuccess";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    deleteMarker: boolean;
+    objectKey: string;
+    version: string;
+}
+export declare const DeleteObjectsResponse_DeleteSuccess: MessageFns<DeleteObjectsResponse_DeleteSuccess, "nebius.storage.v1.DeleteObjectsResponse.DeleteSuccess">;
+export interface DeleteObjectsResponse_DeleteError {
+    $type: "nebius.storage.v1.DeleteObjectsResponse.DeleteError";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    code: string;
+    message: string;
+    objectKey: string;
+    version: string;
+}
+export declare const DeleteObjectsResponse_DeleteError: MessageFns<DeleteObjectsResponse_DeleteError, "nebius.storage.v1.DeleteObjectsResponse.DeleteError">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface ObjectRequestParameters {
+    $type: "nebius.storage.v1.ObjectRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    version: string;
+}
+export declare const ObjectRequestParameters: MessageFns<ObjectRequestParameters, "nebius.storage.v1.ObjectRequestParameters">;
+export interface ObjectResponse {
+    $type: "nebius.storage.v1.ObjectResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    version: string;
+    lastModified?: Dayjs | undefined;
+}
+export declare const ObjectResponse: MessageFns<ObjectResponse, "nebius.storage.v1.ObjectResponse">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface ListObjectVersionsRequestParameters {
+    $type: "nebius.storage.v1.ListObjectVersionsRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    prefix: string;
+    keyMarker: string;
+    versionIdMarker: number;
+    limit: number;
+    delimiter: string;
+}
+export declare const ListObjectVersionsRequestParameters: MessageFns<ListObjectVersionsRequestParameters, "nebius.storage.v1.ListObjectVersionsRequestParameters">;
+export interface ListObjectVersionsResponse {
+    $type: "nebius.storage.v1.ListObjectVersionsResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    versions: ListObjectVersionsResponse_VersionView[];
+    deleteMarkers: ListObjectVersionsResponse_DeleteMarkerView[];
+    commonPrefixes: string[];
+    truncated: boolean;
+    nextKeyMarker: string;
+    nextVersionIdMarker: number;
+}
+export declare const ListObjectVersionsResponse: MessageFns<ListObjectVersionsResponse, "nebius.storage.v1.ListObjectVersionsResponse">;
+export interface ListObjectVersionsResponse_VersionView {
+    $type: "nebius.storage.v1.ListObjectVersionsResponse.VersionView";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    latest: boolean;
+    objectKey: string;
+    lastModified?: Dayjs | undefined;
+    size: Long;
+    versionId: string;
+    storageClass: string;
+}
+export declare const ListObjectVersionsResponse_VersionView: MessageFns<ListObjectVersionsResponse_VersionView, "nebius.storage.v1.ListObjectVersionsResponse.VersionView">;
+export interface ListObjectVersionsResponse_DeleteMarkerView {
+    $type: "nebius.storage.v1.ListObjectVersionsResponse.DeleteMarkerView";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    latest: boolean;
+    objectKey: string;
+    lastModified?: Dayjs | undefined;
+    versionId: string;
+}
+export declare const ListObjectVersionsResponse_DeleteMarkerView: MessageFns<ListObjectVersionsResponse_DeleteMarkerView, "nebius.storage.v1.ListObjectVersionsResponse.DeleteMarkerView">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface ListObjectsRequestParameters {
+    $type: "nebius.storage.v1.ListObjectsRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    prefix: string;
+    delimiter: string;
+    startAfter: string;
+    limit: number;
+}
+export declare const ListObjectsRequestParameters: MessageFns<ListObjectsRequestParameters, "nebius.storage.v1.ListObjectsRequestParameters">;
+export interface ListObjectsResponse {
+    $type: "nebius.storage.v1.ListObjectsResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    objects: ListObjectsResponse_ObjectView[];
+    commonPrefixes: string[];
+    truncated: boolean;
+}
+export declare const ListObjectsResponse: MessageFns<ListObjectsResponse, "nebius.storage.v1.ListObjectsResponse">;
+export interface ListObjectsResponse_ObjectView {
+    $type: "nebius.storage.v1.ListObjectsResponse.ObjectView";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    objectKey: string;
+    lastModified?: Dayjs | undefined;
+    size: Long;
+    storageClass: string;
+}
+export declare const ListObjectsResponse_ObjectView: MessageFns<ListObjectsResponse_ObjectView, "nebius.storage.v1.ListObjectsResponse.ObjectView">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface PostObjectRequestParameters {
+    $type: "nebius.storage.v1.PostObjectRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    size: Long;
+}
+export declare const PostObjectRequestParameters: MessageFns<PostObjectRequestParameters, "nebius.storage.v1.PostObjectRequestParameters">;
+export interface PostObjectResponse {
+    $type: "nebius.storage.v1.PostObjectResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    version: string;
+}
+export declare const PostObjectResponse: MessageFns<PostObjectResponse, "nebius.storage.v1.PostObjectResponse">;
+/**
+ *  ----------------------------------------
+ *
+ */
+export interface PutObjectRequestParameters {
+    $type: "nebius.storage.v1.PutObjectRequestParameters";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    bucketName: string;
+    objectKey: string;
+    size: Long;
+    storageClass: string;
+    expectedMd5: string;
+}
+export declare const PutObjectRequestParameters: MessageFns<PutObjectRequestParameters, "nebius.storage.v1.PutObjectRequestParameters">;
+export interface PutObjectResponse {
+    $type: "nebius.storage.v1.PutObjectResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    etag: string;
+    version: string;
+}
+export declare const PutObjectResponse: MessageFns<PutObjectResponse, "nebius.storage.v1.PutObjectResponse">;
+export {};
+//# sourceMappingURL=index.d.ts.map