ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/types/api/schema/cdcStream.d.ts

@@ -0,0 +1,29 @@
+import type { TPathID } from './shared';
+export interface TCdcStreamDescription {
+    Name?: string;
+    Mode?: ECdcStreamMode;
+    Format?: ECdcStreamFormat;
+    PathId?: TPathID;
+    State?: ECdcStreamState;
+    /** uint64 */
+    SchemaVersion?: string;
+}
+declare enum ECdcStreamMode {
+    ECdcStreamModeInvalid = "ECdcStreamModeInvalid",
+    ECdcStreamModeKeysOnly = "ECdcStreamModeKeysOnly",
+    ECdcStreamModeUpdate = "ECdcStreamModeUpdate",
+    ECdcStreamModeNewImage = "ECdcStreamModeNewImage",
+    ECdcStreamModeOldImage = "ECdcStreamModeOldImage",
+    ECdcStreamModeNewAndOldImages = "ECdcStreamModeNewAndOldImages"
+}
+declare enum ECdcStreamFormat {
+    ECdcStreamFormatInvalid = "ECdcStreamFormatInvalid",
+    ECdcStreamFormatProto = "ECdcStreamFormatProto",
+    ECdcStreamFormatJson = "ECdcStreamFormatJson"
+}
+declare enum ECdcStreamState {
+    ECdcStreamStateInvalid = "ECdcStreamStateInvalid",
+    ECdcStreamStateReady = "ECdcStreamStateReady",
+    ECdcStreamStateDisabled = "ECdcStreamStateDisabled"
+}
+export {};

package/dist/types/api/schema/cdcStream.js

@@ -0,0 +1,22 @@
+var ECdcStreamMode;
+(function (ECdcStreamMode) {
+    ECdcStreamMode["ECdcStreamModeInvalid"] = "ECdcStreamModeInvalid";
+    ECdcStreamMode["ECdcStreamModeKeysOnly"] = "ECdcStreamModeKeysOnly";
+    ECdcStreamMode["ECdcStreamModeUpdate"] = "ECdcStreamModeUpdate";
+    ECdcStreamMode["ECdcStreamModeNewImage"] = "ECdcStreamModeNewImage";
+    ECdcStreamMode["ECdcStreamModeOldImage"] = "ECdcStreamModeOldImage";
+    ECdcStreamMode["ECdcStreamModeNewAndOldImages"] = "ECdcStreamModeNewAndOldImages";
+})(ECdcStreamMode || (ECdcStreamMode = {}));
+var ECdcStreamFormat;
+(function (ECdcStreamFormat) {
+    ECdcStreamFormat["ECdcStreamFormatInvalid"] = "ECdcStreamFormatInvalid";
+    ECdcStreamFormat["ECdcStreamFormatProto"] = "ECdcStreamFormatProto";
+    ECdcStreamFormat["ECdcStreamFormatJson"] = "ECdcStreamFormatJson";
+})(ECdcStreamFormat || (ECdcStreamFormat = {}));
+var ECdcStreamState;
+(function (ECdcStreamState) {
+    ECdcStreamState["ECdcStreamStateInvalid"] = "ECdcStreamStateInvalid";
+    ECdcStreamState["ECdcStreamStateReady"] = "ECdcStreamStateReady";
+    ECdcStreamState["ECdcStreamStateDisabled"] = "ECdcStreamStateDisabled";
+})(ECdcStreamState || (ECdcStreamState = {}));
+export {};

package/dist/types/api/schema/columnEntity.d.ts

@@ -0,0 +1,105 @@
+import type { EColumnCodec, EUnit, TPathID, TStorageSettings, TTypeInfo } from './shared';
+export interface TColumnTableDescription {
+    Name?: string;
+    Schema?: TColumnTableSchema;
+    TtlSettings?: TColumnDataLifeCycle;
+    SchemaPresetId?: number;
+    SchemaPresetName?: string;
+    ColumnStorePathId?: TPathID;
+    ColumnShardCount?: number;
+    Sharding?: TColumnTableSharding;
+    /** uint64 */
+    SchemaPresetVersionAdj?: string;
+    /** uint64 */
+    TtlSettingsPresetVersionAdj?: string;
+    StorageConfig?: TColumnStorageConfig;
+}
+export interface TColumnStoreDescription {
+    Name?: string;
+    ColumnShardCount?: number;
+    /** uint64 */
+    ColumnShards?: string[];
+    SchemaPresets?: TColumnTableSchemaPreset[];
+    StorageConfig?: TColumnStorageConfig;
+    NextSchemaPresetId?: number;
+    NextTtlSettingsPresetId?: number;
+}
+export interface TColumnDataLifeCycle {
+    Enabled?: TTtl;
+    Disabled?: {};
+    Tiering?: TStorageTiering;
+    /** uint64 */
+    Version?: string;
+}
+interface TColumnStorageConfig {
+    SysLog?: TStorageSettings;
+    Log?: TStorageSettings;
+    Data?: TStorageSettings;
+    DataChannelCount?: number;
+}
+interface TStorageTiering {
+    Tiers?: TStorageTier[];
+}
+interface TStorageTier {
+    Name?: string;
+    Eviction?: TTtl;
+}
+interface TTtl {
+    ColumnName?: string;
+    ExpireAfterSeconds?: number;
+    /** uint64 */
+    ExpireAfterBytes?: string;
+    ColumnUnit?: EUnit;
+}
+interface TColumnTableSchema {
+    Columns?: TOlapColumnDescription[];
+    KeyColumnNames?: string[];
+    Engine?: EColumnTableEngine;
+    NextColumnId?: number;
+    /** uint64 */
+    Version?: string;
+    DefaultCompression?: TCompressionOptions;
+    EnableTiering?: boolean;
+}
+interface TColumnTableSchemaPreset {
+    Id?: number;
+    Name?: string;
+    Schema?: TColumnTableSchema;
+}
+interface TOlapColumnDescription {
+    Id?: number;
+    Name?: string;
+    Type?: string;
+    TypeId?: number;
+    TypeInfo?: TTypeInfo;
+}
+interface TColumnTableSharding {
+    /** uint64 */
+    Version?: string;
+    /** uint64 */
+    ColumnShards?: string[];
+    /** uint64 */
+    AdditionalColumnShards?: string[];
+    UniquePrimaryKey?: boolean;
+    RandomSharding?: {};
+    HashSharding?: THashSharding;
+}
+interface THashSharding {
+    Function?: EHashFunction;
+    Columns?: string[];
+    UniqueShardKey?: boolean;
+    ActiveShardsCount?: number;
+}
+interface TCompressionOptions {
+    CompressionCodec?: EColumnCodec;
+    CompressionLevel?: number;
+}
+declare enum EHashFunction {
+    HASH_FUNCTION_MODULO_N = "HASH_FUNCTION_MODULO_N",
+    HASH_FUNCTION_CLOUD_LOGS = "HASH_FUNCTION_CLOUD_LOGS"
+}
+declare enum EColumnTableEngine {
+    COLUMN_ENGINE_NONE = "COLUMN_ENGINE_NONE",
+    COLUMN_ENGINE_REPLACING_TIMESERIES = "COLUMN_ENGINE_REPLACING_TIMESERIES"
+}
+export {};

package/dist/types/api/schema/columnEntity.js

@@ -0,0 +1,11 @@
+var EHashFunction;
+(function (EHashFunction) {
+    EHashFunction["HASH_FUNCTION_MODULO_N"] = "HASH_FUNCTION_MODULO_N";
+    EHashFunction["HASH_FUNCTION_CLOUD_LOGS"] = "HASH_FUNCTION_CLOUD_LOGS";
+})(EHashFunction || (EHashFunction = {}));
+var EColumnTableEngine;
+(function (EColumnTableEngine) {
+    EColumnTableEngine["COLUMN_ENGINE_NONE"] = "COLUMN_ENGINE_NONE";
+    EColumnTableEngine["COLUMN_ENGINE_REPLACING_TIMESERIES"] = "COLUMN_ENGINE_REPLACING_TIMESERIES";
+})(EColumnTableEngine || (EColumnTableEngine = {}));
+export {};

package/dist/types/api/schema/externalDataSource.d.ts

@@ -0,0 +1,22 @@
+import type { TPathID } from './shared';
+export interface TExternalDataSourceDescription {
+    Name?: string;
+    PathId?: TPathID;
+    /** uint64 */
+    Version?: string;
+    SourceType?: string;
+    Location?: string;
+    Installation?: string;
+    Auth?: TAuth;
+}
+interface TAuth {
+    None?: NoneAuth;
+    ServiceAccount?: ServiceAccountAuth;
+}
+interface NoneAuth {
+}
+interface ServiceAccountAuth {
+    Id?: string;
+    SecretName?: string;
+}
+export {};

package/dist/types/api/schema/externalDataSource.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/schema/externalTable.d.ts

@@ -0,0 +1,13 @@
+import type { TColumnDescription, TPathID } from './shared';
+export interface TExternalTableDescription {
+    Name?: string;
+    PathId?: TPathID;
+    /** uint64 */
+    Version?: string;
+    SourceType?: string;
+    DataSourcePath?: string;
+    Location?: string;
+    Columns?: TColumnDescription[];
+    /** bytes */
+    Content?: unknown;
+}

package/dist/types/api/schema/externalTable.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/schema/index.d.ts

@@ -0,0 +1,9 @@
+export * from './schema';
+export * from './shared';
+export * from './cdcStream';
+export * from './columnEntity';
+export * from './externalDataSource';
+export * from './externalTable';
+export * from './persQueueGroup';
+export * from './table';
+export * from './tableIndex';

package/dist/types/api/schema/index.js

@@ -0,0 +1,9 @@
+export * from './schema';
+export * from './shared';
+export * from './cdcStream';
+export * from './columnEntity';
+export * from './externalDataSource';
+export * from './externalTable';
+export * from './persQueueGroup';
+export * from './table';
+export * from './tableIndex';

package/dist/types/api/schema/persQueueGroup.d.ts

@@ -0,0 +1,154 @@
+export interface TPersQueueGroupDescription {
+    Name: string;
+    /** uint64 */
+    PathId?: string;
+    TotalGroupCount: number;
+    PartitionsToAdd?: TPartitionToAdd[];
+    PartitionsToDelete?: number[];
+    NextPartitionId?: number;
+    PartitionPerTablet?: number;
+    PQTabletConfig: TPQTabletConfig;
+    Partitions?: TPartition[];
+    /** uint64 */
+    AlterVersion?: string;
+    /** uint64 */
+    BalancerTabletID?: string;
+    PartitionBoundaries?: unknown;
+    BootstrapConfig?: TBootstrapConfig;
+}
+export interface TPQTabletConfig {
+    /** uint64 */
+    CacheSize?: string;
+    PartitionConfig: TPQPartitionConfig;
+    /** @deprecated use Partitions */
+    PartitionIds?: number[];
+    TopicName?: string;
+    Version?: number;
+    LocalDC?: boolean;
+    RequireAuthWrite?: boolean;
+    RequireAuthRead?: boolean;
+    Producer?: string;
+    Ident?: string;
+    Topic?: string;
+    DC?: string;
+    ReadRules?: string[];
+    /** uint64[] */
+    ReadFromTimestampsMs?: number[];
+    /** uint64[] */
+    ConsumerFormatVersions?: number[];
+    ConsumerCodecs?: TCodecs[];
+    ReadRuleServiceTypes?: string;
+    /** uint64 */
+    FormatVersion?: string;
+    Codecs?: TCodecs;
+    /** uint64[] */
+    ReadRuleVersions?: string[];
+    /** uint64[] */
+    ReadRuleGenerations?: string[];
+    TopicPath?: string;
+    YcCloudId?: string;
+    YcFolderId?: string;
+    YdbDatabaseId?: string;
+    YdbDatabasePath?: string;
+    FederationAccount?: string;
+    PartitionKeySchema?: TKeyComponentSchema[];
+    Partitions?: TPartition[];
+    MeteringMode?: EMeteringMode;
+}
+export interface TPQPartitionConfig {
+    MaxCountInPartition?: number;
+    /** int64 */
+    MaxSizeInPartition?: string;
+    LifetimeSeconds: number;
+    /** uint64 */
+    StorageLimitBytes?: string;
+    ImportantClientId?: string[];
+    LowWatermark?: number;
+    SourceIdLifetimeSeconds?: number;
+    SourceIdMaxCounts?: number;
+    /** uint64 */
+    WriteSpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+    ReadQuota?: TReadQuota[];
+    /** uint64 */
+    MaxWriteInflightSize?: string;
+    /** uint64 */
+    BorderWriteInflightSize?: string;
+    NumChannels?: number;
+    TotalPartitions?: number;
+    ExplicitChannelProfiles?: TChannelProfile[];
+    MirrorFrom?: TMirrorPartitionConfig;
+}
+interface TMirrorPartitionConfig {
+    Endpoint?: string;
+    EndpointPort?: number;
+    Topic?: string;
+    Consumer?: string;
+    /** uint64 */
+    ReadFromTimestampsMs?: string;
+    Credentials?: TCredentials;
+    Database?: string;
+    UseSecureConnection?: boolean;
+    SyncWriteTime?: boolean;
+}
+interface TChannelProfile {
+    PoolKind?: string;
+    /** uint64 */
+    Size?: string;
+    ReadIops?: number;
+    ReadBandwidth?: number;
+    WriteIops?: number;
+    WriteBandwidth?: number;
+}
+interface IamCredentials {
+    Endpoint?: string;
+    ServiceAccountKey?: string;
+}
+interface TCredentials {
+    OauthToken?: string;
+    JwtParams?: string;
+    Iam?: IamCredentials;
+}
+interface TBootstrapConfig {
+    ExplicitMessageGroups?: TMessageGroup[];
+}
+interface TMessageGroup {
+    Id?: string;
+    KeyRange?: TPartitionKeyRange;
+}
+interface TKeyComponentSchema {
+    Name?: string;
+    TypeId?: number;
+}
+interface TReadQuota {
+    ClientId?: string;
+    /** uint64 */
+    SpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+}
+interface TPartition {
+    PartitionId?: number;
+    /** uint64 */
+    TabletId?: string;
+    KeyRange?: TPartitionKeyRange;
+}
+interface TPartitionToAdd {
+    PartitionId?: number;
+    GroupId?: number;
+}
+interface TCodecs {
+    /** int64 */
+    Ids?: string[];
+    Codecs?: string[];
+}
+interface TPartitionKeyRange {
+    FromBound?: string;
+    ToBound?: string;
+}
+export declare enum EMeteringMode {
+    METERING_MODE_RESERVED_CAPACITY = "METERING_MODE_RESERVED_CAPACITY",
+    METERING_MODE_REQUEST_UNITS = "METERING_MODE_REQUEST_UNITS"
+}
+export {};

package/dist/types/api/schema/persQueueGroup.js

@@ -0,0 +1,5 @@
+export var EMeteringMode;
+(function (EMeteringMode) {
+    EMeteringMode["METERING_MODE_RESERVED_CAPACITY"] = "METERING_MODE_RESERVED_CAPACITY";
+    EMeteringMode["METERING_MODE_REQUEST_UNITS"] = "METERING_MODE_REQUEST_UNITS";
+})(EMeteringMode || (EMeteringMode = {}));

package/dist/types/api/schema/schema.d.ts

@@ -0,0 +1,247 @@
+import type { TMetrics } from '../tenant';
+import type { TCdcStreamDescription } from './cdcStream';
+import type { TColumnStoreDescription, TColumnTableDescription } from './columnEntity';
+import type { TExternalDataSourceDescription } from './externalDataSource';
+import type { TExternalTableDescription } from './externalTable';
+import type { TPersQueueGroupDescription } from './persQueueGroup';
+import type { TTableDescription, TTableStats } from './table';
+import type { TIndexDescription } from './tableIndex';
+/**
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/flat_tx_scheme.proto
+ */
+export interface TEvDescribeSchemeResult {
+    Status?: EStatus;
+    Reason?: string;
+    Path?: string;
+    PathDescription?: TPathDescription;
+    /** fixed64 */
+    PathOwner?: string;
+    /** fixed64 */
+    PathId?: string;
+    LastExistedPrefixPath?: string;
+    /** fixed64 */
+    LastExistedPrefixPathId?: string;
+    LastExistedPrefixDescription?: TPathDescription;
+    /** fixed64 */
+    PathOwnerId?: string;
+}
+declare enum EStatus {
+    StatusSuccess = "StatusSuccess",
+    StatusAccepted = "StatusAccepted",
+    StatusPathDoesNotExist = "StatusPathDoesNotExist",
+    StatusPathIsNotDirectory = "StatusPathIsNotDirectory",
+    StatusAlreadyExists = "StatusAlreadyExists",
+    StatusSchemeError = "StatusSchemeError",
+    StatusNameConflict = "StatusNameConflict",
+    StatusInvalidParameter = "StatusInvalidParameter",
+    StatusMultipleModifications = "StatusMultipleModifications",
+    StatusReadOnly = "StatusReadOnly",
+    StatusTxIdNotExists = "StatusTxIdNotExists",
+    StatusTxIsNotCancellable = "StatusTxIsNotCancellable",
+    StatusAccessDenied = "StatusAccessDenied",
+    StatusNotAvailable = "StatusNotAvailable",
+    StatusPreconditionFailed = "StatusPreconditionFailed",
+    StatusRedirectDomain = "StatusRedirectDomain",
+    StatusQuotaExceeded = "StatusQuotaExceeded",
+    StatusResourceExhausted = "StatusResourceExhausted"
+}
+/**
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/flat_scheme_op.proto
+ *
+ * incomplete interface, only currently used fields are covered
+ */
+export interface TPathDescription {
+    /** info about the path itself */
+    Self?: TDirEntry;
+    DomainDescription?: TDomainDescription;
+    Children?: TDirEntry[];
+    Table?: TTableDescription;
+    TableStats?: TTableStats;
+    TabletMetrics?: TMetrics;
+    TablePartitions?: TTablePartition[];
+    TablePartitionStats?: TTableStats[];
+    TablePartitionMetrics?: TMetrics[];
+    ColumnStoreDescription?: TColumnStoreDescription;
+    ColumnTableDescription?: TColumnTableDescription;
+    TableIndex?: TIndexDescription;
+    CdcStreamDescription?: TCdcStreamDescription;
+    PersQueueGroup?: TPersQueueGroupDescription;
+    ExternalTableDescription?: TExternalTableDescription;
+    ExternalDataSourceDescription?: TExternalDataSourceDescription;
+}
+export interface TDirEntry {
+    Name?: string;
+    /** uint64 */
+    PathId?: string;
+    /** uint64 */
+    SchemeshardId?: string;
+    PathType?: EPathType;
+    CreateFinished?: boolean;
+    /** uint64 */
+    CreateTxId?: string;
+    /** uint64 */
+    CreateStep?: string;
+    /** uint64 */
+    ParentPathId?: string;
+    PathState?: EPathState;
+    Owner?: string;
+    ACL?: string;
+    EffectiveACL?: string;
+    /** uint64 */
+    PathVersion?: string;
+    PathSubType?: EPathSubType;
+    Version?: TPathVersion;
+}
+interface TDomainDescription {
+    ProcessingParams?: TProcessingParams;
+    DomainKey?: TDomainKey;
+    StoragePools?: TStoragePool[];
+    /** uint64 */
+    PathsInside?: string;
+    /** uint64 */
+    PathsLimit?: string;
+    /** uint64 */
+    ShardsInside?: string;
+    /** uint64 */
+    ShardsLimit?: string;
+    ResourcesDomainKey?: TDomainKey;
+    DiskSpaceUsage?: TDiskSpaceUsage;
+    /** uint64 */
+    PQPartitionsInside?: string;
+    /** uint64 */
+    PQPartitionsLimit?: string;
+    DomainState?: TDomainState;
+    DeclaredSchemeQuotas?: TSchemeQuotas;
+    DatabaseQuotas?: DatabaseQuotas;
+    SecurityState?: TSecurityState;
+}
+interface TDomainKey {
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    PathId?: string;
+}
+interface TProcessingParams {
+    Version?: number;
+    /** uint64 */
+    PlanResolution?: string;
+    /** fixed64 */
+    Coordinators?: string[];
+    /** uint64 */
+    TimeCastBucketsPerMediator?: string;
+    /** fixed64 */
+    Mediators?: string[];
+    /** fixed64 */
+    SchemeShard?: string;
+    /** fixed64 */
+    Hive?: string;
+    /** fixed64 */
+    SysViewProcessor?: string;
+}
+interface TDomainState {
+    DiskQuotaExceeded?: boolean;
+}
+interface TDiskSpaceUsage {
+    Tables?: TTables;
+}
+interface TTables {
+    /** uint64 */
+    TotalSize?: string;
+    /** uint64 */
+    DataSize?: string;
+    /** uint64 */
+    IndexSize?: string;
+}
+interface TStoragePool {
+    Name?: string;
+    Kind?: string;
+}
+interface TSchemeQuotas {
+    SchemeQuotas?: TSchemeQuota[];
+}
+interface TSchemeQuota {
+    /** double */
+    BucketSize?: number;
+    /** uint64 */
+    BucketSeconds?: string;
+}
+interface TSecurityState {
+    PublicKeys?: TPublicKey[];
+    Sids?: TSid[];
+    Audience: string;
+}
+interface TPublicKey {
+    /** uint64 */
+    KeyId: string;
+    KeyDataPEM: string;
+    /** uint64 */
+    ExpiresAt: string;
+}
+interface TSid {
+    Name: string;
+    Type: SidType;
+    Hash: string;
+    Members?: string[];
+}
+declare enum SidType {
+    'UNKNOWN' = "UNKNOWN",
+    'USER' = "USER",
+    'GROUP' = "GROUP"
+}
+interface DatabaseQuotas {
+    /** uint64 */
+    data_size_hard_quota: string;
+    /** uint64 */
+    data_size_soft_quota: string;
+    /** uint64 */
+    data_stream_shards_quota: string;
+    /** uint64 */
+    data_stream_reserved_storage_quota: string;
+    ttl_min_run_internal_seconds: number;
+}
+export declare enum EPathType {
+    EPathTypeInvalid = "EPathTypeInvalid",
+    EPathTypeDir = "EPathTypeDir",
+    EPathTypeTable = "EPathTypeTable",
+    EPathTypePersQueueGroup = "EPathTypePersQueueGroup",
+    EPathTypeSubDomain = "EPathTypeSubDomain",
+    EPathTypeTableIndex = "EPathTypeTableIndex",
+    EPathTypeExtSubDomain = "EPathTypeExtSubDomain",
+    EPathTypeColumnStore = "EPathTypeColumnStore",
+    EPathTypeColumnTable = "EPathTypeColumnTable",
+    EPathTypeCdcStream = "EPathTypeCdcStream",
+    EPathTypeExternalDataSource = "EPathTypeExternalDataSource",
+    EPathTypeExternalTable = "EPathTypeExternalTable"
+}
+export declare enum EPathSubType {
+    EPathSubTypeEmpty = "EPathSubTypeEmpty",
+    EPathSubTypeSyncIndexImplTable = "EPathSubTypeSyncIndexImplTable",
+    EPathSubTypeAsyncIndexImplTable = "EPathSubTypeAsyncIndexImplTable",
+    EPathSubTypeStreamImpl = "EPathSubTypeStreamImpl"
+}
+declare enum EPathState {
+    EPathStateNotExist = "EPathStateNotExist",
+    EPathStateNoChanges = "EPathStateNoChanges",
+    EPathStateCreate = "EPathStateCreate",
+    EPathStateAlter = "EPathStateAlter",
+    EPathStateDrop = "EPathStateDrop",
+    EPathStateCopying = "EPathStateCopying",
+    EPathStateBackup = "EPathStateBackup",
+    EPathStateUpgrade = "EPathStateUpgrade",
+    EPathStateMigrated = "EPathStateMigrated",
+    EPathStateRestore = "EPathStateRestore",
+    EPathStateMoving = "EPathStateMoving"
+}
+interface TPathVersion {
+    /** uint64 */
+    GeneralVersion?: string;
+}
+interface TTablePartition {
+    /** bytes */
+    EndOfRangeKeyPrefix?: unknown;
+    IsPoint?: boolean;
+    IsInclusive?: boolean;
+    /** uint64 */
+    DatashardId?: string;
+}
+export {};