ydb-embedded-ui 22.2.0 → 22.4.0

package/src/containers/Tenant/Diagnostics/StreamingQueryGraph/StreamingQueryGraph.tsx

@@ -0,0 +1,79 @@
+import React from 'react';
+
+import {Text, useThemeValue} from '@gravity-ui/uikit';
+
+import {ResponseError} from '../../../../components/Errors/ResponseError';
+import {Loader} from '../../../../components/Loader';
+import {prepareStreamingQueryPlan} from '../../../../store/reducers/query/parsers/prepareStreamingQueryPlan';
+import {streamingQueriesApi} from '../../../../store/reducers/streamingQuery/streamingQuery';
+import {cn} from '../../../../utils/cn';
+import {getStringifiedData} from '../../../../utils/dataFormatters/dataFormatters';
+import {useAutoRefreshInterval} from '../../../../utils/hooks';
+import {parseIssuesData} from '../../../../utils/query';
+import {ResultIssues} from '../../Query/Issues/Issues';
+import {Graph} from '../../Query/QueryResult/components/Graph/Graph';
+
+import i18n from './i18n';
+
+import './StreamingQueryGraph.scss';
+
+interface StreamingQueryGraphProps {
+    database: string;
+    path: string;
+}
+
+const RUNNING_STATUS = 'RUNNING';
+
+const b = cn('ydb-streaming-query-graph');
+
+const PLAN_STATE_MESSAGES = {
+    empty: 'description_no-plan',
+    unparsed: 'description_unparsed-plan',
+    unsupported: 'description_unsupported-plan',
+} as const;
+
+export function StreamingQueryGraph({database, path}: StreamingQueryGraphProps) {
+    const theme = useThemeValue();
+    const [autoRefreshInterval] = useAutoRefreshInterval();
+
+    const {
+        currentData: planData,
+        isFetching,
+        error,
+    } = streamingQueriesApi.useGetStreamingQueryPlanQuery(
+        {database, path},
+        {skip: !database || !path, pollingInterval: autoRefreshInterval},
+    );
+
+    const row = planData?.resultSets?.[0]?.result?.[0];
+
+    const {state, prepared} = React.useMemo(
+        () => prepareStreamingQueryPlan(getStringifiedData(row?.Plan)),
+        [row?.Plan],
+    );
+
+    if (isFetching && planData === undefined) {
+        return <Loader size="s" className={b('loader')} />;
+    }
+
+    const status = getStringifiedData(row?.Status);
+    const issues = parseIssuesData(row?.Issues);
+    const showStatus = Boolean(issues) || Boolean(status && status !== RUNNING_STATUS);
+
+    return (
+        <div className={b()}>
+            {error ? <ResponseError error={error} /> : null}
+            {showStatus ? (
+                <div className={b('status')}>
+                    {status ? <Text variant="subheader-2">{status}</Text> : null}
+                    {issues ? <ResultIssues data={issues} /> : null}
+                </div>
+            ) : null}
+            {state === 'ready' ? (
+                <Graph explain={prepared} theme={theme} />
+            ) : (
+                <div>{i18n(PLAN_STATE_MESSAGES[state])}</div>
+            )}
+        </div>
+    );
+}

package/src/containers/Tenant/Diagnostics/StreamingQueryGraph/i18n/en.json

@@ -0,0 +1,5 @@
+{
+  "description_no-plan": "The query has not reported its plan yet.",
+  "description_unparsed-plan": "The plan cannot be displayed.",
+  "description_unsupported-plan": "The plan version is not supported and cannot be rendered."
+}

package/src/containers/Tenant/Diagnostics/StreamingQueryGraph/i18n/index.ts

@@ -0,0 +1,7 @@
+import {registerKeysets} from '../../../../../utils/i18n';
+
+import en from './en.json';
+
+const COMPONENT = 'ydb-tenant-diagnostics-streaming-query-graph';
+
+export default registerKeysets(COMPONENT, {en});

package/src/containers/Tenant/Diagnostics/StreamingQueryGraph/index.ts

@@ -0,0 +1 @@
+export {StreamingQueryGraph} from './StreamingQueryGraph';

package/src/containers/Tenant/Diagnostics/i18n/en.json

@@ -15,6 +15,7 @@
   "title_describe": "Describe",
   "title_hot-keys": "Hot keys",
   "title_graph": "Graph",
+  "title_computation-graph": "Computation Graph",
   "title_consumers": "Consumers",
   "title_partitions": "Partitions",
   "title_data": "Data",

package/src/containers/Tenant/Diagnostics/tabsContent.tsx

@@ -19,6 +19,7 @@ import {HotKeys} from './HotKeys/HotKeys';
 import {NetworkWrapper} from './Network/NetworkWrapper';
 import {Partitions} from './Partitions/Partitions';
 import {StorageUsage} from './StorageUsage/StorageUsage';
+import {StreamingQueryGraph} from './StreamingQueryGraph';
 import {TenantOverview} from './TenantOverview/TenantOverview';
 import {TopQueries} from './TopQueries/TopQueries';
 import {TopShards} from './TopShards/TopShards';
@@ -182,6 +183,9 @@ const diagnosticsTabRenderers: Record<TenantDiagnosticsTab, DiagnosticsTabRender
             database,
             scrollContainerRef,
         }),
+    [TENANT_DIAGNOSTICS_TABS_IDS.computationGraph]: ({database, path}) => (
+        <StreamingQueryGraph database={database} path={path} />
+    ),
     [TENANT_DIAGNOSTICS_TABS_IDS.monitoring]: ({database, databaseFullPath}) => {
         const content = uiFactory.renderMonitoring?.({database, databaseFullPath});
 

package/src/containers/Tenant/Healthcheck/components/HealthcheckDrawer.tsx

@@ -9,10 +9,12 @@ import {EnableFullscreenButton} from '../../../../components/EnableFullscreenBut
 import type {SelfCheckResult} from '../../../../types/api/healthcheck';
 import {uiFactory} from '../../../../uiFactory/uiFactory';
 import {createAndDownloadJsonFile} from '../../../../utils/downloadFile';
+import type {HealthcheckAssistantTarget} from '../types';
 
 import {HealthcheckDrawerTitle} from './HealthcheckDrawerTitle';
 
 interface HealthcheckDrawerProps {
+    target?: HealthcheckAssistantTarget;
     children: React.ReactNode;
     isDrawerVisible: boolean;
     onCloseDrawer: () => void;
@@ -29,6 +31,7 @@ interface HealthcheckDrawerProps {
 }
 
 export function HealthcheckDrawer({
+    target,
     children,
     isDrawerVisible,
     onCloseDrawer,
@@ -51,11 +54,11 @@ export function HealthcheckDrawer({
 
         return (
             <React.Fragment>
-                {renderDrawerExtension()}
+                {renderDrawerExtension({target})}
                 {renderDrawerContent()}
             </React.Fragment>
         );
-    }, [renderDrawerContent, renderDrawerExtension]);
+    }, [renderDrawerContent, renderDrawerExtension, target]);
 
     const handleDownload = React.useCallback(
         (event: React.MouseEvent<HTMLButtonElement>) => {

package/src/containers/Tenant/Query/QueryEditor/YqlEditor/YqlEditor.tsx

@@ -119,6 +119,14 @@ export function YqlEditor({
     const currentStatementCleanupRef = React.useRef<VoidFunction>();
     const [isEditorMounted, setIsEditorMounted] = React.useState(false);
 
+    React.useEffect(() => {
+        // onEditorReady removes the parent's visibility:hidden loading state.
+        // Focus after that render commits; focusing during editorDidMount is too early.
+        if (isEditorMounted) {
+            editorRef.current?.focus();
+        }
+    }, [isEditorMounted]);
+
     const isMultiTabQueryEditorEnabled = useMultiTabQueryEditorEnabled();
     const isAutocompleteEnabled = useEventHandler(() => Boolean(enableAutocomplete));
 
@@ -330,7 +338,6 @@ export function YqlEditor({
         if (!isMultiTabQueryEditorEnabled) {
             initUserPrompt(editor, getLastQueryText);
         }
-        editor.focus();
         editor.addAction({
             id: 'sendQuery',
             label: i18n('action_send-query'),

package/src/containers/Tenant/TenantDrawerHealthcheck.tsx

@@ -8,6 +8,7 @@ import {useTypedSelector} from '../../utils/hooks';
 
 import {Healthcheck} from './Healthcheck/Healthcheck';
 import {HealthcheckDrawer} from './Healthcheck/components/HealthcheckDrawer';
+import {getDatabaseHealthcheckAssistantTarget} from './Healthcheck/utils';
 import {useCurrentSchema} from './TenantContext';
 import i18n from './i18n';
 import {useTenantQueryParams} from './useTenantQueryParams';
@@ -46,6 +47,15 @@ export function TenantDrawerHealthcheck({children, clusterName}: TenantDrawerHea
 
     return (
         <HealthcheckDrawer
+            target={
+                database
+                    ? getDatabaseHealthcheckAssistantTarget({
+                          database,
+                          clusterName,
+                          scope: 'database',
+                      })
+                    : undefined
+            }
             isDrawerVisible={Boolean(showHealthcheck)}
             onCloseDrawer={handleCloseDrawer}
             renderDrawerContent={renderDrawerContent}

package/src/containers/Tenants/DatabaseDrawerHealthcheck.tsx

@@ -8,6 +8,7 @@ import type {PreparedTenant} from '../../store/reducers/tenants/types';
 import {useTypedSelector} from '../../utils/hooks';
 import {Healthcheck} from '../Tenant/Healthcheck/Healthcheck';
 import {HealthcheckDrawer} from '../Tenant/Healthcheck/components/HealthcheckDrawer';
+import {getDatabaseHealthcheckAssistantTarget} from '../Tenant/Healthcheck/utils';
 import tenantI18n from '../Tenant/i18n';
 import {useTenantQueryParams} from '../Tenant/useTenantQueryParams';
 
@@ -78,6 +79,15 @@ export function DatabaseDrawerHealthcheck({children, clusterName}: DatabaseDrawe
 
     return (
         <HealthcheckDrawer
+            target={
+                database
+                    ? getDatabaseHealthcheckAssistantTarget({
+                          database,
+                          clusterName: selectedClusterName,
+                          scope: 'database',
+                      })
+                    : undefined
+            }
             isDrawerVisible={Boolean(database)}
             onCloseDrawer={handleCloseDrawer}
             renderDrawerContent={renderDrawerContent}

package/src/lib.ts

@@ -46,6 +46,7 @@ export type {
     IllustrationComponent,
     IllustrationName,
     RenderHealthcheckAssistantAction,
+    HealthcheckDrawerExtensionProps,
 } from './uiFactory/types';
 export type {
     HealthcheckAssistantActionProps,

package/src/store/reducers/executeTopQueries/executeTopQueries.ts

@@ -106,6 +106,17 @@ WHERE Query NOT LIKE '%${QUERY_TECHNICAL_MARK}%'
 AND QueryStartAt is not null`;
 }
 
+function getRunningQueriesByPoolText(poolName: string) {
+    const escapedPoolName = poolName.replace(/'/g, "''");
+    return `${QUERY_TECHNICAL_MARK}
+SELECT
+    COUNT_IF(State = 'EXECUTING' AND (WmState IS NULL OR WmState NOT IN ('PENDING', 'DELAYED'))) as RunningQueriesCount,
+    COUNT_IF(State = 'QUEUED' OR WmState = 'PENDING' OR WmState = 'DELAYED') as QueuedQueriesCount
+FROM \`.sys/query_sessions\`
+WHERE Query NOT LIKE '%${QUERY_TECHNICAL_MARK}%'
+AND WmPoolId = '${escapedPoolName}'`;
+}
+
 interface QueriesRequestParams {
     database: string;
     filters?: TopQueriesFilters;
@@ -233,6 +244,41 @@ export const topQueriesApi = api.injectEndpoints({
             },
             providesTags: ['All'],
         }),
+        getRunningQueriesByPool: build.query({
+            queryFn: async (
+                {database, poolName}: {database: string; poolName: string},
+                {signal},
+            ) => {
+                try {
+                    const response = await window.api.viewer.sendQuery(
+                        {
+                            query: getRunningQueriesByPoolText(poolName),
+                            database,
+                            action: 'execute-query',
+                            internal_call: true,
+                        },
+                        {signal, withRetries: true},
+                    );
+
+                    if (isQueryErrorResponse(response)) {
+                        throw response;
+                    }
+
+                    const data = parseQueryAPIResponse(response);
+                    const row = data?.resultSets?.[0]?.result?.[0];
+
+                    return {
+                        data: {
+                            runningQueriesCount: Number(row?.RunningQueriesCount) || 0,
+                            queuedQueriesCount: Number(row?.QueuedQueriesCount) || 0,
+                        },
+                    };
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
     }),
     overrideExisting: 'throw',
 });

package/src/store/reducers/header/types.ts

@@ -76,7 +76,9 @@ export type PageBreadcrumbsOptions<T extends Page = undefined> = T extends 'home
           ? NodeBreadcrumbsOptions
           : T extends 'tablet'
             ? TabletBreadcrumbsOptions
-            : {};
+            : T extends 'storageGroup'
+              ? StorageGroupBreadcrumbsOptions
+              : {};
 
 export interface HeaderState {
     page?: Page;

package/src/store/reducers/pdisk/types.ts

@@ -5,6 +5,7 @@ export interface PDiskData extends PreparedPDisk {
     NodeHost?: string;
     NodeType?: string;
     NodeDC?: string;
+    NodeRack?: string;
     SlotItems?: (SlotItem<'vDisk'> | SlotItem<'log'> | SlotItem<'empty'>)[];
 }
 

package/src/store/reducers/pdisk/utils.ts

@@ -62,9 +62,11 @@ export function preparePDiskDataResponse([pdiskResponse = {}, nodeResponse]: [
         };
     }
 
-    const preparedVDisks = WhiteboardVDisksData.map((disk) =>
-        prepareWhiteboardVDiskData({...disk, NodeId}),
-    );
+    const preparedVDisks = WhiteboardVDisksData.map((disk) => ({
+        ...prepareWhiteboardVDiskData({...disk, NodeId}),
+        PDiskType: preparedPDisk.Type,
+        PDiskPath: preparedPDisk.Path,
+    }));
 
     setDonorRecipientReferences((cb) => {
         for (const vDisk of preparedVDisks) {
@@ -145,6 +147,7 @@ export function preparePDiskDataResponse([pdiskResponse = {}, nodeResponse]: [
         NodeHost: preparedNode.Host,
         NodeType: preparedNode.Roles?.[0],
         NodeDC: preparedNode.DC,
+        NodeRack: preparedNode.Rack,
         SlotItems: diskSlots,
     };
 }

package/src/store/reducers/query/parsers/prepareStreamingQueryPlan.ts

@@ -0,0 +1,74 @@
+import type {QueryPlan} from '../../../../types/api/query';
+import type {PreparedQueryData} from '../types';
+
+import {preparePlanData} from './preparePlanData';
+
+// empty: nothing has been published yet; unparsed: a plan arrived but cannot be read,
+// for instance truncated by the backend; unsupported: a readable plan of an unknown version.
+export type StreamingQueryPlanState = 'empty' | 'unparsed' | 'unsupported' | 'ready';
+
+interface StreamingQueryPlan {
+    state: StreamingQueryPlanState;
+    prepared?: PreparedQueryData['preparedPlan'];
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isPlanNode(value: unknown) {
+    return isObject(value) && typeof value['Node Type'] === 'string';
+}
+
+function isStringList(value: unknown) {
+    return (
+        value === undefined || (Array.isArray(value) && value.every((i) => typeof i === 'string'))
+    );
+}
+
+// The graph blocks render these fields directly, so anything else would throw while drawing.
+function isRenderable(prepared: PreparedQueryData['preparedPlan']) {
+    return (prepared?.nodes ?? []).every(({data}) => {
+        return (
+            (data?.id === undefined || typeof data.id === 'number') &&
+            (data?.name === undefined || typeof data.name === 'string') &&
+            isStringList(data?.operators) &&
+            isStringList(data?.tables)
+        );
+    });
+}
+
+export function prepareStreamingQueryPlan(planText?: string): StreamingQueryPlan {
+    if (!planText) {
+        return {state: 'empty'};
+    }
+
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(planText);
+    } catch {
+        return {state: 'unparsed'};
+    }
+
+    if (!isObject(parsed) || !isObject(parsed.meta)) {
+        return {state: 'empty'};
+    }
+    if (!parsed.Plan) {
+        return {state: 'empty'};
+    }
+    if (!isPlanNode(parsed.Plan)) {
+        return {state: 'unparsed'};
+    }
+
+    try {
+        const {simplifiedPlan: _simplifiedPlan, ...prepared} = preparePlanData(
+            parsed as unknown as QueryPlan,
+        );
+        if (!isRenderable(prepared)) {
+            return {state: 'unparsed'};
+        }
+        return prepared.nodes?.length ? {state: 'ready', prepared} : {state: 'unsupported'};
+    } catch {
+        return {state: 'unparsed'};
+    }
+}

package/src/store/reducers/storage/prepareGroupsDisks.ts

@@ -32,31 +32,14 @@ export function prepareGroupsVDisk(data: TStorageVDisk = {}): PreparedVDisk {
         SlotSize: PDisk?.SlotSize,
     });
 
-    const whiteboardAllocatedSize = parseOptionalNonNegativeNumber(whiteboardVDisk.AllocatedSize);
-    const whiteboardAvailableSize = parseOptionalNonNegativeNumber(whiteboardVDisk.AvailableSize);
-    const whiteboardSlotSize = parseOptionalNonNegativeNumber(
-        PDisk?.Whiteboard?.EnforcedDynamicSlotSize,
-    );
-    const whiteboardSizeFields =
+    const WhiteboardSize =
         hasWhiteboardData && data.Whiteboard
             ? prepareVDiskSizeFields({
-                  AvailableSize: whiteboardAvailableSize,
-                  AllocatedSize: whiteboardAllocatedSize,
-                  SlotSize: whiteboardSlotSize,
-              })
+                  AvailableSize: whiteboardVDisk.AvailableSize,
+                  AllocatedSize: whiteboardVDisk.AllocatedSize,
+                  SlotSize: PDisk?.Whiteboard?.EnforcedDynamicSlotSize,
+              }).DisplaySize
             : undefined;
-    const WhiteboardSize = whiteboardSizeFields
-        ? {
-              AllocatedSize:
-                  whiteboardAllocatedSize === undefined
-                      ? undefined
-                      : whiteboardSizeFields.AllocatedSize,
-              SizeLimit:
-                  whiteboardAvailableSize === undefined && whiteboardSlotSize === undefined
-                      ? undefined
-                      : whiteboardSizeFields.SizeLimit,
-          }
-        : undefined;
 
     const preparedDonors = bscVDisk.Donors?.map((donor) => {
         const preparedDonor = prepareGroupsVDisk(donor);
@@ -77,6 +60,8 @@ export function prepareGroupsVDisk(data: TStorageVDisk = {}): PreparedVDisk {
         HasWhiteboardData: hasWhiteboardData,
         ...(WhiteboardSize ? {WhiteboardSize} : {}),
         PDisk: preparedPDisk,
+        PDiskType: preparedPDisk.Type,
+        PDiskPath: preparedPDisk.Path,
         Donors: preparedDonors,
         PDiskId,
         StringifiedId,

package/src/store/reducers/storage/utils.ts

@@ -88,10 +88,14 @@ const prepareStorageNodeData = (
                 pDisk.Realtime !== undefined);
         return prepareWhiteboardPDiskData({...pDisk, NodeId}, hasWhiteboardData ? pDisk : null);
     });
+    const pDisksById = new Map(pDisks?.map((pDisk) => [pDisk.PDiskId, pDisk]));
     const vDisks = VDisks?.map((vDisk) => {
+        const pDisk = vDisk.PDiskId === undefined ? undefined : pDisksById.get(vDisk.PDiskId);
         return {
             ...prepareWhiteboardVDiskData({...vDisk, VDiskId: vDisk.VDiskId}),
             NodeId,
+            PDiskType: pDisk?.Type,
+            PDiskPath: pDisk?.Path,
         };
     });
 

package/src/store/reducers/streamingQuery/streamingQuery.ts

@@ -3,38 +3,63 @@ import {isQueryErrorResponse, parseQueryAPIResponse} from '../../../utils/query'
 import {api} from '../api';
 
 function getStreamingQueryInfoSQL(path: string) {
+    // Select available columns so older backends without lifecycle fields remain supported.
+    const safePath = path.replace(/'/g, "''");
+    return `${QUERY_TECHNICAL_MARK}
+SELECT * WITHOUT Plan, Ast
+FROM \`.sys/streaming_queries\`
+WHERE Path = '${safePath}'
+LIMIT 1`;
+}
+
+function getStreamingQueryPlanSQL(path: string) {
     const safePath = path.replace(/'/g, "''");
     return `${QUERY_TECHNICAL_MARK}
 SELECT
-    Status AS State,
-    Issues AS Error,
-    Text
+    Status,
+    Issues,
+    Plan
 FROM \`.sys/streaming_queries\`
 WHERE Path = '${safePath}'
 LIMIT 1`;
 }
 
+async function execStreamingSQL(
+    sql: string,
+    {database, signal}: {database: string; signal: AbortSignal},
+) {
+    const response = await window.api.viewer.sendQuery(
+        {query: sql, database, action: 'execute-query', internal_call: true},
+        {signal, withRetries: true},
+    );
+    if (isQueryErrorResponse(response)) {
+        return {error: response};
+    }
+    return {data: parseQueryAPIResponse(response)};
+}
+
 export const streamingQueriesApi = api.injectEndpoints({
     endpoints: (build) => ({
         getStreamingQueryInfo: build.query({
             queryFn: async ({database, path}: {database: string; path: string}, {signal}) => {
                 try {
-                    const response = await window.api.viewer.sendQuery(
-                        {
-                            query: getStreamingQueryInfoSQL(path),
-                            database,
-                            action: 'execute-query',
-                            internal_call: true,
-                        },
-                        {signal, withRetries: true},
-                    );
-
-                    if (isQueryErrorResponse(response)) {
-                        return {error: response};
-                    }
-
-                    const data = parseQueryAPIResponse(response);
-                    return {data};
+                    return await execStreamingSQL(getStreamingQueryInfoSQL(path), {
+                        database,
+                        signal,
+                    });
+                } catch (error) {
+                    return {error};
+                }
+            },
+            providesTags: ['All'],
+        }),
+        getStreamingQueryPlan: build.query({
+            queryFn: async ({database, path}: {database: string; path: string}, {signal}) => {
+                try {
+                    return await execStreamingSQL(getStreamingQueryPlanSQL(path), {
+                        database,
+                        signal,
+                    });
                 } catch (error) {
                     return {error};
                 }

package/src/store/reducers/tenant/constants.ts

@@ -37,6 +37,7 @@ export const TENANT_DIAGNOSTICS_TABS_IDS = {
     access: 'access',
     backups: 'backups',
     monitoring: 'monitoring',
+    computationGraph: 'computationGraph',
 } as const;
 
 export const TENANT_SUMMARY_TABS_IDS = {

package/src/styles/mixins.scss

@@ -9,6 +9,28 @@
     }
 }
 
+@mixin capacity-alert-label-colors($color) {
+    background-color: var(--ydb-capacity-alert-label-background);
+
+    @if $color == 'green' {
+        --ydb-capacity-alert-label-background: var(--g-color-base-positive-light);
+
+        color: var(--g-color-text-positive-heavy);
+    } @else if $color == 'yellow' {
+        --ydb-capacity-alert-label-background: var(--g-color-base-warning-light);
+
+        color: var(--g-color-text-warning-heavy);
+    } @else if $color == 'red' {
+        --ydb-capacity-alert-label-background: var(--g-color-base-danger-light);
+
+        color: var(--g-color-base-danger-heavy);
+    } @else {
+        --ydb-capacity-alert-label-background: var(--ydb-space-#{$color}-bg);
+
+        color: var(--ydb-space-#{$color}-text);
+    }
+}
+
 @mixin container() {
     max-width: 1170px;
     margin: 0 auto;

package/src/types/api/pdisk.ts

@@ -56,6 +56,10 @@ export interface TPDiskStateInfo {
     /** float; percent in the 0..100 scale. */
     PDiskUsage?: number;
     PDiskCapacityAlert?: ECapacityAlert | string;
+    /** Added by viewer from the BlobStorage controller system view. */
+    Status?: EDriveStatus;
+    DecommitStatus?: EDecommitStatus;
+    MaintenanceStatus?: EMaintenanceStatus;
 }
 
 export enum TPDiskState {

package/src/types/api/schema/columnEntity.ts

@@ -1,5 +1,5 @@
 import type {EColumnCodec, EUnit, TPathID, TStorageSettings, TTypeInfo} from './shared';
-import type {TFamilyDescription} from './table';
+import type {TFamilyDescription, TTTLTier} from './table';
 
 export interface TColumnTableDescription {
     Name?: string;
@@ -71,6 +71,7 @@ interface TTtl {
     ExpireAfterBytes?: string;
 
     ColumnUnit?: EUnit;
+    Tiers?: TTTLTier[];
 }
 
 interface TColumnTableSchema {