@nebius/js-sdk 0.1.0

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

@@ -0,0 +1,717 @@
+import { Long, unknownFieldsSymbol } from "../../../../runtime/protos/index";
+import type { Dayjs, 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 { Status } from "../../../google/rpc";
+export type ServiceError_RetryType = EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING">;
+interface ServiceError_RetryTypeValueMembers {
+    readonly UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING">;
+    /**
+     *  Just retry the failed call.
+     *
+     */
+    readonly CALL: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING">;
+    /**
+     *  Retry whole logic before call and make a new one.
+     *
+     */
+    readonly UNIT_OF_WORK: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING">;
+    /**
+     *  Do not retry, this is a fatal error.
+     *
+     */
+    readonly NOTHING: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING">;
+}
+export type ServiceError_RetryTypeClass = EnumClass<"UNRECOGNIZED" | "UNSPECIFIED" | "CALL" | "UNIT_OF_WORK" | "NOTHING"> & ServiceError_RetryTypeValueMembers;
+export declare const ServiceError_RetryType: ServiceError_RetryTypeClass;
+export interface ServiceError {
+    $type: "nebius.common.v1.ServiceError";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of Service which the error originated in. E.g. "dns".
+     *
+     */
+    service: string;
+    /**
+     *  Detailed error code, service-specific. E.g. "DnsZoneNotEmpty".
+     *  Name of the exception, without Exception suffix if not set.
+     *  Example: for PermissionDeniedException -> code == PermissionDenied.
+     *
+     */
+    code: string;
+    /**
+     *  Retry type tells how to provide retry, e.g.: just a single call or the whole logic before it.
+     *
+     */
+    retryType: ServiceError_RetryType;
+    /**
+     *  Additional message describing the error, if any.
+     *
+     */
+    details?: {
+        $case: "badRequest";
+        badRequest: BadRequest;
+    } | {
+        $case: "badResourceState";
+        badResourceState: BadResourceState;
+    } | {
+        $case: "resourceNotFound";
+        resourceNotFound: ResourceNotFound;
+    } | {
+        $case: "resourceAlreadyExists";
+        resourceAlreadyExists: ResourceAlreadyExists;
+    } | {
+        $case: "outOfRange";
+        outOfRange: OutOfRange;
+    } | {
+        $case: "permissionDenied";
+        permissionDenied: PermissionDenied;
+    } | {
+        $case: "resourceConflict";
+        resourceConflict: ResourceConflict;
+    } | {
+        $case: "operationAborted";
+        operationAborted: OperationAborted;
+    } | {
+        $case: "tooManyRequests";
+        tooManyRequests: TooManyRequests;
+    } | {
+        $case: "quotaFailure";
+        quotaFailure: QuotaFailure;
+    } | {
+        $case: "notEnoughResources";
+        notEnoughResources: NotEnoughResources;
+    } | {
+        $case: "internalError";
+        internalError: InternalError;
+    } | undefined;
+}
+export declare const ServiceError: MessageFns<ServiceError, "nebius.common.v1.ServiceError">;
+/**
+ *  The request is invalid.
+ *
+ */
+export interface BadRequest {
+    $type: "nebius.common.v1.BadRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Describes all violations.
+     *
+     */
+    violations: BadRequest_Violation[];
+}
+export declare const BadRequest: MessageFns<BadRequest, "nebius.common.v1.BadRequest">;
+export interface BadRequest_Violation {
+    $type: "nebius.common.v1.BadRequest.Violation";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  What field value is invalid.
+     *
+     */
+    field: string;
+    /**
+     *  Description why the value is invalid, in English.
+     *
+     */
+    message: string;
+}
+export declare const BadRequest_Violation: MessageFns<BadRequest_Violation, "nebius.common.v1.BadRequest.Violation">;
+/**
+ *  The resource we are trying to use, create, change or delete is in a bad state and cannot be used.
+ *
+ */
+export interface BadResourceState {
+    $type: "nebius.common.v1.BadResourceState";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the resource which is bad.
+     *
+     */
+    resourceId: string;
+    /**
+     *  The reason why this state is bad and cannot be used.
+     *
+     */
+    message: string;
+}
+export declare const BadResourceState: MessageFns<BadResourceState, "nebius.common.v1.BadResourceState">;
+/**
+ *  Resource we are trying to interact with does not exist.
+ *
+ */
+export interface ResourceNotFound {
+    $type: "nebius.common.v1.ResourceNotFound";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the requested resource.
+     *
+     */
+    resourceId: string;
+}
+export declare const ResourceNotFound: MessageFns<ResourceNotFound, "nebius.common.v1.ResourceNotFound">;
+/**
+ *  Resource we are trying to create already exists.
+ *
+ */
+export interface ResourceAlreadyExists {
+    $type: "nebius.common.v1.ResourceAlreadyExists";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the existing resource.
+     *
+     */
+    resourceId: string;
+}
+export declare const ResourceAlreadyExists: MessageFns<ResourceAlreadyExists, "nebius.common.v1.ResourceAlreadyExists">;
+/**
+ *  There is a difference between the actual resource state and the expected one.
+ *
+ */
+export interface ResourceConflict {
+    $type: "nebius.common.v1.ResourceConflict";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of conflicting resource.
+     *
+     */
+    resourceId: string;
+    /**
+     *  Detailed info about conflict.
+     *
+     */
+    message: string;
+}
+export declare const ResourceConflict: MessageFns<ResourceConflict, "nebius.common.v1.ResourceConflict">;
+/**
+ *  Operation on the resource has been aborted by a subsequent operation.
+ *
+ */
+export interface OperationAborted {
+    $type: "nebius.common.v1.OperationAborted";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the aborted operation.
+     *
+     */
+    operationId: string;
+    /**
+     *  ID of the subsequent operation.
+     *
+     */
+    abortedByOperationId: string;
+    /**
+     *  Resource ID corresponding to both of the operations.
+     *
+     */
+    resourceId: string;
+}
+export declare const OperationAborted: MessageFns<OperationAborted, "nebius.common.v1.OperationAborted">;
+/**
+ *  Indicates that element with requested parameters is exceeding the particular range.
+ *
+ */
+export interface OutOfRange {
+    $type: "nebius.common.v1.OutOfRange";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Requested value.
+     *
+     */
+    requested: string;
+    /**
+     *  Available limit.
+     *
+     */
+    limit: string;
+}
+export declare const OutOfRange: MessageFns<OutOfRange, "nebius.common.v1.OutOfRange">;
+/**
+ *  Indicates that the action cannot be performed because there are insufficient access rights to a resource.
+ *
+ */
+export interface PermissionDenied {
+    $type: "nebius.common.v1.PermissionDenied";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the resource that cannot be accessed.
+     *
+     */
+    resourceId: string;
+}
+export declare const PermissionDenied: MessageFns<PermissionDenied, "nebius.common.v1.PermissionDenied">;
+/**
+ *  Generic internal error.
+ *
+ */
+export interface InternalError {
+    $type: "nebius.common.v1.InternalError";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Error request ID.
+     *
+     */
+    requestId: string;
+    /**
+     *  Trace ID for the failing request.
+     *
+     */
+    traceId: string;
+}
+export declare const InternalError: MessageFns<InternalError, "nebius.common.v1.InternalError">;
+/**
+ *  You initiated too many requests to the service at once. Enhance your calm.
+ *
+ */
+export interface TooManyRequests {
+    $type: "nebius.common.v1.TooManyRequests";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  What request limit is exceeded (service-dependent).
+     *
+     */
+    violation: string;
+}
+export declare const TooManyRequests: MessageFns<TooManyRequests, "nebius.common.v1.TooManyRequests">;
+/**
+ *  Indicates a failure due to exceeding specified limits or allocations in a system or service.
+ *
+ */
+export interface QuotaFailure {
+    $type: "nebius.common.v1.QuotaFailure";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Describes all quota violations.
+     *
+     */
+    violations: QuotaFailure_Violation[];
+}
+export declare const QuotaFailure: MessageFns<QuotaFailure, "nebius.common.v1.QuotaFailure">;
+export interface QuotaFailure_Violation {
+    $type: "nebius.common.v1.QuotaFailure.Violation";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Which quota check failed.
+     *
+     */
+    quota: string;
+    /**
+     *  A description of how the quota check failed.
+     *
+     */
+    message: string;
+    /**
+     *  Maximum permissible value.
+     *
+     */
+    limit: string;
+    /**
+     *  Requested value.
+     *
+     */
+    requested: string;
+}
+export declare const QuotaFailure_Violation: MessageFns<QuotaFailure_Violation, "nebius.common.v1.QuotaFailure.Violation">;
+/**
+ *  Indicates that there are not enough resources available to perform the requested action.
+ *
+ */
+export interface NotEnoughResources {
+    $type: "nebius.common.v1.NotEnoughResources";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Describes all resource violations.
+     *
+     */
+    violations: NotEnoughResources_Violation[];
+}
+export declare const NotEnoughResources: MessageFns<NotEnoughResources, "nebius.common.v1.NotEnoughResources">;
+export interface NotEnoughResources_Violation {
+    $type: "nebius.common.v1.NotEnoughResources.Violation";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  The type of resource that is insufficient.
+     *  This field is populated when it is possible to determine the lacking resource type.
+     *  **Not for programmatic use.**
+     *
+     */
+    resourceType: string;
+    /**
+     *  A description of how the resource is insufficient.
+     *
+     */
+    message: string;
+    /**
+     *  Requested value.
+     *
+     */
+    requested: string;
+}
+export declare const NotEnoughResources_Violation: MessageFns<NotEnoughResources_Violation, "nebius.common.v1.NotEnoughResources.Violation">;
+/**
+ *  Common resource metadata.
+ *
+ */
+export interface ResourceMetadata {
+    $type: "nebius.common.v1.ResourceMetadata";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Identifier for the resource, unique for its resource type.
+     *
+     */
+    id: string;
+    /**
+     *  Identifier of the parent resource to which the resource belongs.
+     *
+     */
+    parentId: string;
+    /**
+     *  Human readable name for the resource.
+     *
+     */
+    name: string;
+    /**
+     *  Version of the resource for safe concurrent modifications and consistent reads.
+     *  Positive and monotonically increases on each resource spec change (but *not* on each change of the
+     *  resource's container(s) or status).
+     *  Service allows zero value or current.
+     *
+     */
+    resourceVersion: Long;
+    /**
+     *  Timestamp indicating when the resource was created.
+     *
+     */
+    createdAt?: Dayjs | undefined;
+    /**
+     *  Timestamp indicating when the resource was last updated.
+     *
+     */
+    updatedAt?: Dayjs | undefined;
+    /**
+     *  Labels associated with the resource.
+     *
+     */
+    labels: {
+        [key: string]: string;
+    };
+}
+export declare const ResourceMetadata: MessageFns<ResourceMetadata, "nebius.common.v1.ResourceMetadata">;
+/**
+ *  if service supports uniqueness of ResourceMetadata.name within tuple (scope) <resource_type, parent_id>
+ *  it also must have grpc method GetByName
+ *
+ */
+export interface GetByNameRequest {
+    $type: "nebius.common.v1.GetByNameRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    parentId: string;
+    name: string;
+}
+export declare const GetByNameRequest: MessageFns<GetByNameRequest, "nebius.common.v1.GetByNameRequest">;
+export interface GetOperationRequest {
+    $type: "nebius.common.v1.GetOperationRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    id: string;
+}
+export declare const GetOperationRequest: MessageFns<GetOperationRequest, "nebius.common.v1.GetOperationRequest">;
+export interface ListOperationsRequest {
+    $type: "nebius.common.v1.ListOperationsRequest";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the Resource to list operations for.
+     *
+     */
+    resourceId: string;
+    /**
+     *  Page size. [1...1000]. Optional, if not specified, a reasonable default will be chosen by the service.
+     *
+     */
+    pageSize: Long;
+    /**
+     *  Listing continuation token. Empty to start listing from the first page.
+     *
+     */
+    pageToken: string;
+}
+export declare const ListOperationsRequest: MessageFns<ListOperationsRequest, "nebius.common.v1.ListOperationsRequest">;
+export interface ListOperationsResponse {
+    $type: "nebius.common.v1.ListOperationsResponse";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    operations: Operation[];
+    nextPageToken: string;
+}
+export declare const ListOperationsResponse: MessageFns<ListOperationsResponse, "nebius.common.v1.ListOperationsResponse">;
+export type OperationServiceServiceDescription = typeof OperationServiceServiceDescription;
+export declare const OperationServiceServiceDescription: {
+    readonly get: {
+        readonly path: "/nebius.common.v1.OperationService/Get";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetOperationRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GetOperationRequest;
+        readonly responseSerialize: (value: Operation) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => Operation;
+    };
+    readonly list: {
+        readonly path: "/nebius.common.v1.OperationService/List";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListOperationsRequest) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => ListOperationsRequest;
+        readonly responseSerialize: (value: ListOperationsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => ListOperationsResponse;
+    };
+};
+export interface OperationServiceServer extends UntypedServiceImplementation {
+    get: handleUnaryCall<GetOperationRequest, Operation>;
+    list: handleUnaryCall<ListOperationsRequest, ListOperationsResponse>;
+}
+export interface OperationServiceBaseClient extends Client {
+    get(request: GetOperationRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: Operation) => void): ClientUnaryCall;
+    list(request: ListOperationsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: GrpcServiceError | null, response: ListOperationsResponse) => void): ClientUnaryCall;
+}
+export declare const OperationServiceBaseClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): OperationServiceBaseClient;
+    service: typeof OperationServiceServiceDescription;
+    serviceName: string;
+};
+export interface OperationService {
+    $type: "nebius.common.v1.OperationService";
+    get(request: GetOperationRequest): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    get(request: GetOperationRequest, metadata: Metadata): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    get(request: GetOperationRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    list(request: ListOperationsRequest): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+    list(request: ListOperationsRequest, metadata: Metadata): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+    list(request: ListOperationsRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+}
+export interface OperationServiceListResponse {
+    operations: OperationWrapper<GetOperationRequest>[];
+    nextPageToken: string;
+}
+export declare class OperationService implements OperationService {
+    private sdk;
+    private addr;
+    $type: "nebius.common.v1.OperationService";
+    private spec;
+    constructor(sdk: SDKInterface, addr: string);
+    get(request: GetOperationRequest): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    get(request: GetOperationRequest, metadata: Metadata): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    get(request: GetOperationRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<GetOperationRequest, OperationWrapper<GetOperationRequest>>;
+    list(request: ListOperationsRequest): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+    list(request: ListOperationsRequest, metadata: Metadata): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+    list(request: ListOperationsRequest, metadata: Metadata, options: Partial<CallOptions> & RetryOptions): SDKRequestClass<ListOperationsRequest, OperationServiceListResponse>;
+}
+export interface Operation {
+    $type: "nebius.common.v1.Operation";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  ID of the operation.
+     *
+     */
+    id: string;
+    /**
+     *  Human-readable description of the operation. 0-256 characters long.
+     *
+     */
+    description: string;
+    /**
+     *  Creation timestamp.
+     *
+     */
+    createdAt?: Dayjs | undefined;
+    /**
+     *  ID of the user or service account who initiated the operation.
+     *
+     */
+    createdBy: string;
+    /**
+     *  The time when the operation has finished.
+     *
+     */
+    finishedAt?: Dayjs | undefined;
+    /**
+     *  The request that generated this operation.
+     *
+     */
+    request?: {
+        typeUrl: string;
+        value: Uint8Array;
+    } | undefined;
+    /**
+     *  The request headers that are essential for the request that generated the operation.
+     *  For instance, `x-resetmask`. Without these headers the request might have been processed
+     *  differently if repeated.
+     *  All the header names *must* be converted to lower case.
+     *  Validator is based on:
+     *  https://httpwg.org/specs/rfc9110.html#considerations.for.new.field.names
+     *
+     */
+    requestHeaders: {
+        [key: string]: Operation_RequestHeader;
+    };
+    /**
+     *  ID of the resource that this operation creates, updates, deletes or otherwise changes.
+     *
+     *  If the operation affects multiple resources or does not affect any API resources at all
+     *  (e.g. a routine maintenance operation visible to the user), the [resource_id] must be empty.
+     *
+     */
+    resourceId: string;
+    /**
+     *  The status of this operation. Set when this operation is completed.
+     *  See https://github.com/grpc/grpc/blob/master/src/proto/grpc/status/status.proto.
+     *
+     *  [status.code] is https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto:
+     *  - If [status.code] == OK, the operation has completed successfully.
+     *  - If [status.code] != OK, the operation has failed or has been cancelled.
+     *    - [status.message] will contain a user-readable and actionable error message.
+     *    - [status.details] will contain additional diagnostic information in the form of [ServiceError] from nebius/common/v1/error.proto
+     *  - [status.code] must belong to an Operation-compatible subset of GRPC codes:
+     *    OK, CANCELLED, PERMISSION_DENIED, RESOURCE_EXHAUSTED, FAILED_PRECONDITION, ABORTED, INTERNAL
+     *
+     */
+    status?: Status | undefined;
+    /**
+     *  Extra information about this operation's progress. MAY be absent while the operation is running, MUST be absent after the operation has completed.
+     *
+     *  Type of message that's stored inside [progress_data] is service-dependent.
+     *
+     */
+    progressData?: {
+        typeUrl: string;
+        value: Uint8Array;
+    } | undefined;
+}
+export declare const Operation: MessageFns<Operation, "nebius.common.v1.Operation">;
+/**
+ *  Request header is a container for all the values of a particular header of a request because there is no such thing as `map<string, repeated string>`
+ *
+ */
+export interface Operation_RequestHeader {
+    $type: "nebius.common.v1.Operation.RequestHeader";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  The values of a particular header from a request
+     *
+     */
+    values: string[];
+}
+export declare const Operation_RequestHeader: MessageFns<Operation_RequestHeader, "nebius.common.v1.Operation.RequestHeader">;
+export type ResourceEvent_Level = EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+interface ResourceEvent_LevelValueMembers {
+    /**
+     *  Unspecified event severity level
+     *
+     */
+    readonly UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    /**
+     *  A debug event providing detailed insight. Such events are used to debug problems with specific resource(s) and process(es)
+     *
+     */
+    readonly DEBUG: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    /**
+     *  A normal event or state change. Informs what is happening with the API resource. Does not require user attention or interaction
+     *
+     */
+    readonly INFO: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    /**
+     *  Warning event. Indicates a potential or minor problem with the API resource and/or the corresponding processes. Needs user attention, but requires no immediate action (yet)
+     *
+     */
+    readonly WARN: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+    /**
+     *  Error event. Indicates a serious problem with the API resource and/or the corresponding processes. Requires immediate user action
+     *
+     */
+    readonly ERROR: EnumInstance<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+}
+export type ResourceEvent_LevelClass = EnumClass<"UNRECOGNIZED" | "UNSPECIFIED" | "DEBUG" | "INFO" | "WARN" | "ERROR"> & ResourceEvent_LevelValueMembers;
+export declare const ResourceEvent_Level: ResourceEvent_LevelClass;
+/**
+ *  Represents an API Resource-related event which is potentially important to the end-user. What exactly constitutes an *event* to be reported is service-dependent
+ *
+ */
+export interface ResourceEvent {
+    $type: "nebius.common.v1.ResourceEvent";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Time at which the event has occurred
+     *
+     */
+    occurredAt?: Dayjs | undefined;
+    /**
+     *  Severity level for the event
+     *
+     */
+    level: ResourceEvent_Level;
+    /**
+     *  Event code (unique within the API service), in UpperCamelCase, e.g. `"DiskAttached"`
+     *
+     */
+    code: string;
+    /**
+     *  A human-readable message describing what has happened (and suggested actions for the user, if this is a `WARN`- or `ERROR`-level event)
+     *
+     */
+    message: string;
+    /**
+     *  Describes a GRPC error status associated with an `ERROR`- or `WARN`-level event, if known. The `error` **must** have a standard GRPC `code` (which **must not** be `OK` (0)) and a human-readable `message`. A standard `common.v1.ServiceError` **should** also be included in `details`
+     *
+     */
+    error?: Status | undefined;
+}
+export declare const ResourceEvent: MessageFns<ResourceEvent, "nebius.common.v1.ResourceEvent">;
+/**
+ *  A resource event that has occurred (more or less in the same way) multiple times across a service-defined aggregation interval
+ *
+ */
+export interface RecurrentResourceEvent {
+    $type: "nebius.common.v1.RecurrentResourceEvent";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  Time of the first occurrence of a recurrent event
+     *
+     */
+    firstOccurredAt?: Dayjs | undefined;
+    /**
+     *  Last occurrence of a recurrent event
+     *
+     */
+    lastOccurrence?: ResourceEvent | undefined;
+    /**
+     *  The number of times this event has occurred between `first_occurred_at` and `last_occurrence.occurred_at`. Must be > 0
+     *
+     */
+    occurrenceCount: Long;
+}
+export declare const RecurrentResourceEvent: MessageFns<RecurrentResourceEvent, "nebius.common.v1.RecurrentResourceEvent">;
+export {};
+//# sourceMappingURL=index.d.ts.map