@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/a-metric-chart/types.d.ts

@@ -0,0 +1,115 @@
+import { TemplateRef } from '@angular/core';
+import { XOR } from 'ts-essentials';
+import { LegendOpt, Options, TooltipOption, TooltipValue } from 'zz-chart';
+import { MonitorMetricResult } from '../api/public-api';
+import { StringMap, WorkspaceParams } from '../core/public-api';
+import { Translation } from '../translate/types';
+export declare enum MetricScope {
+    'CLUSTER' = "cluster",
+    'PROJECT' = "project",
+    'WORKSPACE' = "workspace"
+}
+export type LegendParams = string | ((params: IndicatorParams, result: MonitorMetricResult) => string);
+export type SeriesParams = Partial<XOR<{
+    indicators: string | string[];
+}, {
+    expr: string;
+}> & {
+    invisible?: boolean;
+    color?: string;
+    legend?: LegendParams;
+}>;
+export interface MetricParams {
+    start: number;
+    end: number;
+    step?: number;
+    scope?: MetricScope;
+    scopeValue?: string | WorkspaceParams;
+    dependentData?: boolean;
+    variableSource?: StringMap | StringMap[];
+    isIndex?: boolean;
+}
+export interface FetchParams {
+    indicatorParams: IndicatorParams[];
+    metricParams: MetricParams;
+}
+export interface IndicatorParams {
+    id?: string;
+    expr?: string;
+    indicators?: string;
+    variables: string[];
+    unit?: string;
+    legend?: string;
+    color?: string;
+    invisible?: boolean;
+}
+export declare enum AUnitType {
+    MEMORY = "memory",
+    CAPACITY = "capacity"
+}
+export interface AMatchUnitParams {
+    base?: number;
+    threshold?: number;
+    unitType?: AUnitType;
+    unitRange?: string[];
+    defaultPrefix?: boolean;
+    prefix?: string;
+    baseUnit?: string;
+    groups?: Array<{
+        base: number;
+        range: string[];
+    }>;
+    conversions?: IndicatorUnitConversion[];
+}
+export interface IndicatorUnit {
+    type: string;
+    translation: Translation;
+    conversions: IndicatorUnitConversion[];
+}
+export interface IndicatorUnitConversion {
+    alias: string[];
+    unit: string;
+    scaler: number;
+    translation: Translation;
+}
+export declare enum Orientation {
+    'VERTICAL' = "vertical",
+    'HORIZONTAL' = "horizontal",
+    'AUTO' = "auto"
+}
+export interface LegendOption extends LegendOpt {
+    symbol?: 'circle' | 'square' | 'line';
+    template?: TemplateRef<unknown> | string | 'dropdown';
+    translation?: boolean;
+    selectAll?: boolean;
+    selectAllName?: boolean;
+    direction?: Orientation;
+}
+export interface AMetricChartOptions extends Omit<Options, 'title' | 'legend' | 'tooltip'> {
+    title?: {
+        text?: string | TemplateRef<unknown>;
+        description?: string | TemplateRef<unknown>;
+        descriptionContext?: StringMap;
+        suffix?: string;
+    };
+    legend?: LegendOption | boolean;
+    tooltip?: MetricChartTooltipOption | boolean;
+    table?: TableChartOptions;
+}
+export interface MetricChartTooltipOption extends Omit<TooltipOption, 'itemFormatter'> {
+    itemFormatter?: ((value: TooltipValue[]) => string | TooltipValue[] | Element) | TemplateRef<unknown>;
+    titleFormatter?: string | ((title: string, values: TooltipValue[]) => string) | TemplateRef<unknown>;
+    itemTemplateContext?: Record<string, unknown>;
+    tooltipTitleContext?: Record<string, unknown>;
+}
+export interface TableChartOptions {
+    alignment?: 'left' | 'center' | 'right';
+    pagination?: TablePaginatorChartOptions;
+}
+export interface TablePaginatorChartOptions {
+    layout: string | string[];
+    currentPage?: number;
+    pageIndex?: number;
+    pageSize?: number;
+    total?: number;
+}

package/a-metric-chart/utils/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './range';
+export * from './unit';
+export * from './util';

package/a-metric-chart/utils/range.d.ts

@@ -0,0 +1 @@
+export declare function roundInterval(start: number, end: number, isRich?: boolean): number;

package/a-metric-chart/utils/unit.d.ts

@@ -0,0 +1,48 @@
+import { AChartData } from '../../a-chart/types';
+import { AMatchUnitParams, IndicatorUnit } from '../types';
+export declare const MATCH_UNIT_DEFAULT_BASE = 1024;
+export declare function adaptChartUnit(data: Array<{
+    data?: Array<{
+        x: number;
+        y: number;
+    }>;
+    values?: Array<{
+        x: number;
+        y: number;
+    }>;
+}>, adaptUnitParams: boolean | AMatchUnitParams): {
+    base: number;
+    exponent: number;
+    unit: string;
+};
+export declare function adaptUnit(seriesOrMetrics: Array<{
+    data?: Array<{
+        x: number;
+        y: number;
+    }>;
+    values?: Array<{
+        x: number;
+        y: number;
+    }>;
+}>, params?: AMatchUnitParams): {
+    unit: string;
+    base: number;
+    exponent: number;
+};
+export declare function matchUnit(value: number, params?: AMatchUnitParams): {
+    unit: string;
+    base: number;
+    exponent: number;
+};
+export declare const BASE_UNITS: readonly ["K", "M", "G", "T", "P", "E"];
+export declare const MEMORY_UNITS: string[];
+export declare const UnitMap: {
+    [key: string]: readonly string[];
+};
+export declare function hasNoData(res: AChartData[]): boolean;
+export declare function getIndicatorAdaptUnit(unit: string, unitMapper: IndicatorUnit[]): {
+    defaultPrefix: boolean;
+    base: number;
+    unitRange: string[];
+    conversions: import("../types").IndicatorUnitConversion[];
+};

package/a-metric-chart/utils/util.d.ts

@@ -0,0 +1,40 @@
+import { DataItem, TooltipValue } from 'zz-chart';
+import { AChartData } from '../../a-chart/types';
+import { MonitorMetric, MonitorMetricResult } from '../../api/public-api';
+import { Dictionary, StringMap } from '../../core/public-api';
+import { FetchParams, IndicatorParams, MetricParams } from '../types';
+export declare function handleMetricParams(params: IndicatorParams[], { variableSource, start, end, step, isIndex }: MetricParams): {
+    indicators: {
+        indicators: string;
+        exprs: string[];
+        variables: StringMap[];
+    }[];
+    start: number;
+    end: number;
+    step: number;
+};
+export declare function handleChartData({ indicatorParams, metricParams }: FetchParams, data: MonitorMetric[]): AChartData[];
+export declare function dependOnIndicator(indicatorParams: IndicatorParams[], data: MonitorMetric[]): AChartData[];
+export declare function dependOnData(indicatorParams: IndicatorParams[], data: MonitorMetric[]): AChartData[];
+export declare function handleDataResult(params: IndicatorParams, res: MonitorMetricResult): {
+    name: any;
+    values: {
+        x: number;
+        y: string;
+    }[];
+};
+export declare function handleLegend(params: IndicatorParams, result: MonitorMetricResult): any;
+export declare const LEGEND_TEMPLATE_OPTIONS: Readonly<{
+    interpolate: RegExp;
+}>;
+export declare function getLegendName(metricKey: string, metric: StringMap): string;
+export declare function fillNullData({ start, end, step }: MetricParams, res?: DataItem['values'], isZero?: boolean, stepLine?: boolean): any[];
+export declare function handleDateAxisLabelFormats(params: MetricParams, isRich?: boolean): string;
+export declare function limitMaxTooltipItem(context: TooltipValue[], limit?: number): TooltipValue[];
+export declare const VARIABLE_KEY_CLUSTER = "$cluster";
+export declare const VARIABLE_KEY_NAMESPACE = "$namespace";
+export declare function replaceExprVariable(expr: string | string[], variable: Dictionary<any>): string;
+export declare function findTimeRange(diff: number): {
+    start: number;
+    end: number;
+};

package/abnormal-page/abnormal-page.component.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+export declare class AbnormalPageComponent {
+    reason: {
+        readonly NotSupported: "notSupported";
+        readonly NoPermission: "noPermission";
+        readonly NotDeployed: "notDeployed";
+        readonly Abnormal: "abnormal";
+        readonly NoData: "noData";
+        readonly NoMessage: "noMessage";
+        readonly Disconnected: "disconnected";
+        readonly LicenseAbnormal: "licenseAbnormal";
+        readonly NetworkAbnormal: "networkAbnormal";
+        readonly NotFound: "notFound";
+        readonly NoAlarm: "noAlarm";
+    };
+    retry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbnormalPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AbnormalPageComponent, "acl-abnormal-page", never, {}, {}, never, never, false, never>;
+}

package/abnormal-page/abnormal-page.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./abnormal-page.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../page-guard/module";
+import * as i4 from "../translate/translate.module";
+import * as i5 from "@alauda/ui";
+export declare class AbnormalPageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbnormalPageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AbnormalPageModule, [typeof i1.AbnormalPageComponent], [typeof i2.CommonModule, typeof i3.PageGuardModule, typeof i4.TranslateModule, typeof i5.ButtonModule], [typeof i1.AbnormalPageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AbnormalPageModule>;
+}

package/abnormal-page/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './abnormal-page.component';
+export * from './abnormal-page.module';

package/api/api-compatible.interceptor.d.ts

@@ -0,0 +1,46 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList } from '../core/public-api';
+import { ClusterVersionService } from './cluster-version.service';
+import { K8sResourceDefinition } from './types';
+export declare abstract class ApiCompatibleInterceptor implements HttpInterceptor {
+    abstract matchUrl(req: string): MatchResult;
+    abstract responseAdapters: ResponseAdapter[];
+    abstract requestAdapters: RequestAdapter[];
+    protected clusterVersion: ClusterVersionService;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    private executeRequestDowngrade;
+    private executeRequestBodyDowngrade;
+    private executeResponseBodyUpgrade;
+}
+interface Adapter {
+    clusterVersion: string;
+    httpMethods?: string[];
+}
+export interface ResponseAdapter extends Adapter {
+    bodyUpgrade: (body: unknown) => unknown;
+}
+export interface RequestAdapter extends Adapter {
+    bodyDowngrade?: (body: unknown) => unknown;
+    requestDowngrade?: (req: HttpRequest<unknown>) => HttpRequest<unknown>;
+}
+export interface MatchResult {
+    matched: boolean;
+    cluster?: string;
+}
+export declare function k8sApiMatcher(resourceType: string | K8sResourceDefinition): (url: string) => {
+    matched: boolean;
+    cluster: string;
+} | {
+    matched: boolean;
+    cluster?: undefined;
+};
+export declare function k8sResourceOrList(mapper: (res: KubernetesResource) => KubernetesResource): (res: KubernetesResource | KubernetesResourceList) => KubernetesResource | {
+    items: KubernetesResource[];
+    metadata?: import("../core/public-api").ObjectMeta;
+    spec?: unknown;
+    status?: unknown;
+    kind?: string;
+    apiVersion?: string;
+};
+export {};

package/api/api-gateway.interceptor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { ApiGatewayService } from './api-gateway.service';
+import * as i0 from "@angular/core";
+export declare class ApiGatewayInterceptor implements HttpInterceptor {
+    private readonly apiGateway;
+    constructor(apiGateway: ApiGatewayService);
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiGatewayInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiGatewayInterceptor>;
+}

package/api/api-gateway.service.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export interface ApiGatewayState {
+    apiAddress: string;
+    assetsHostPath: string;
+    assetsURLPath: string;
+}
+export declare class ApiGatewayService {
+    private readonly http;
+    private readonly state$;
+    getApiAddress(): import("rxjs").Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiGatewayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiGatewayService>;
+}

package/api/cluster-version.service.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { K8sApiService } from './k8s-api.service';
+import * as i0 from "@angular/core";
+export declare class ClusterVersionService {
+    private readonly k8sApi;
+    private store;
+    private readonly platformVersion$;
+    constructor(k8sApi: K8sApiService);
+    /**
+     * @deprecated
+     */
+    isPrevLTS(cluster: string): Observable<boolean>;
+    isOldCluster: (cluster: string) => Observable<boolean>;
+    clusterOldThan(cluster: string, version: string): Observable<boolean>;
+    platformVersion(): Observable<string>;
+    getClusterVersion(cluster: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterVersionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClusterVersionService>;
+}

package/api/crypto.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class CryptoInterceptorService implements HttpInterceptor {
+    private readonly extraUrlRegexps;
+    constructor(extraUrlRegexps: RegExp[]);
+    private factoryContentType;
+    private encryptPayload;
+    private factoryReq;
+    /**
+     * 实现方案：
+     * 1. 请求和响应处理分开处理，在请求的header上加上加密标识，根据返回的响应header处理对应的加密策略，而不是使用请求时使用的策略。这样能规避服务端的主动加密策略（前端没有使用加密）
+     * 2. 如果解密失败，将不做任何处理，原样返回，因为理论上解密不应该失败，如果失败可能是不需要解密，最主要的是返回解密失败的信息比原样返回对业务来说更没意义
+     */
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CryptoInterceptorService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CryptoInterceptorService>;
+}

package/api/helpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { DeepReadonly, Keys, KubernetesResource, ValueOf } from '../core/public-api';
+import { K8sResourceDefinition, WatchAPIResponse } from './types';
+export declare const EMPTY_API_PREFIX_PARTS: {
+    readonly apiGroup: "";
+    readonly apiVersion: "";
+};
+export declare const getApiPrefixParts: (apiPrefix: string) => Omit<Required<K8sResourceDefinition>, 'type'>;
+export declare const normalizeApiGroup: (apiGroup?: string) => string;
+export declare const normalizeDefinition: <T extends Readonly<{
+    type: string;
+    apiGroup?: string;
+    apiVersion?: string;
+}>>(definition: T) => Required<T>;
+export declare const createResourceDefinitions: <T extends Readonly<Record<string, Readonly<{
+    type: string;
+    apiGroup?: string;
+    apiVersion?: string;
+}>>>, R extends {
+    readonly RESOURCE_DEFINITIONS: DeepReadonly<T>;
+    readonly RESOURCE_TYPES: DeepReadonly<Keys<T>>;
+    readonly getYamlApiVersion: (definition: ValueOf<T> | keyof T) => string;
+}>(RESOURCE_DEFINITIONS: T) => R;
+export declare const getMetadataHeaders: (isList?: boolean, customAccept?: string) => {
+    Accept: string;
+};
+export declare function reduceWatchEvents<T extends KubernetesResource>(events: Array<WatchAPIResponse<T>>): Array<WatchAPIResponse<T>>;
+export declare function isResourceEvent<T extends KubernetesResource>(event: WatchAPIResponse<T>): boolean;

package/api/k8s-api-resource.service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { APIResourceItem, KubernetesResource } from '../core/public-api';
+import { K8sResourceDefinition, K8sResourceDefinitions } from './types';
+import * as i0 from "@angular/core";
+export declare class K8sApiResourceService {
+    private readonly http;
+    private readonly resourceDefinitions;
+    constructor(http: HttpClient, resourceDefinitions: K8sResourceDefinitions);
+    private _listCaches;
+    private _typeCaches;
+    getDefinition(typeOrDefinition: string | K8sResourceDefinition): Required<K8sResourceDefinition>;
+    getApiPath({ cluster, namespace, name, type, apiGroup, apiVersion, }: {
+        cluster?: string;
+        namespace?: string;
+        name?: string;
+        type?: string;
+        apiGroup?: string;
+        apiVersion?: string;
+    }): string;
+    getResourceList<T extends KubernetesResource>(resource: T, cluster: string): Observable<APIResourceItem[]>;
+    getResourceType<T extends KubernetesResource>(resource: T, cluster: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sApiResourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<K8sApiResourceService>;
+}

package/api/k8s-api.service.d.ts

@@ -0,0 +1,112 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, Status } from '../core/public-api';
+import { K8sApiResourceService } from './k8s-api-resource.service';
+import { PageVisibilityService } from './page-visibility.service';
+import { ErebusResourceDeleteParams, ErebusResourceListParams, ErebusResourceParams, ErebusResourcePatchParams, ErebusResourceWriteParams, GlobalResourceDeleteParams, GlobalResourceListParams, GlobalResourceParams, GlobalResourcePatchParams, GlobalResourceWriteParams, WatchAPIResponse, WatchErebusResourceListParams, WatchErebusResourceParams, WatchGlobalResourceListParams, WatchGlobalResourceParams, ErebusResourceBatchDeleteParams } from './types';
+import * as i0 from "@angular/core";
+export declare const TIMEOUT_SECONDS = 59;
+export declare const SEARCH_URL_PREFIX = "/acp/v1/resources/search";
+export declare class K8sApiService<R extends string = string> {
+    private readonly http;
+    private readonly k8sApiResource;
+    private readonly pageVisibility;
+    private readonly globalNamespace;
+    constructor(http: HttpClient, k8sApiResource: K8sApiResourceService, pageVisibility: PageVisibilityService, globalNamespace: string);
+    /**
+     * 获取 Global 集群单个资源对象
+     */
+    getGlobalResource<T extends KubernetesResource>(params: GlobalResourceParams<R>): Observable<T>;
+    /**
+     * 监听 Global 集群单个资源对象
+     */
+    watchGlobalResource<T extends KubernetesResource>(params: WatchGlobalResourceParams<R>): Observable<T>;
+    /**
+     * 监听 Global 集群资源列表变化
+     */
+    watchGlobalResourceChange<T extends KubernetesResource>(seedVersion: string, params: WatchGlobalResourceListParams<R>): Observable<WatchAPIResponse<T>>;
+    /**
+     * 获取 Global 集群资源对象列表，包含分页信息
+     */
+    getGlobalResourceList<T extends KubernetesResource>(params: GlobalResourceListParams<R>): Observable<KubernetesResourceList<T>>;
+    /**
+     * 创建 Global 集群资源
+     */
+    postGlobalResource<T extends KubernetesResource>(params: GlobalResourceWriteParams<T, R>): Observable<T>;
+    /**
+     * 完整覆盖更新 Global 集群单个资源对象
+     */
+    putGlobalResource<T extends KubernetesResource>(params: GlobalResourceWriteParams<T, R>): Observable<T>;
+    /**
+     * 增量更新 Global 集群单个资源对象的部分属性
+     */
+    patchGlobalResource<T extends KubernetesResource>(params: GlobalResourcePatchParams<T, R>): Observable<T>;
+    /**
+     * 删除 Global 集群单个资源
+     */
+    deleteGlobalResource<S extends KubernetesResource = Status, T extends KubernetesResource = S extends Status ? KubernetesResource : S>(params: GlobalResourceDeleteParams<T, R>): Observable<S>;
+    /**
+     * 获取业务集群单个资源对象
+     */
+    getResource<T extends KubernetesResource>(params: ErebusResourceParams<R>): Observable<T>;
+    /**
+     * 监听业务集群单个资源对象
+     */
+    watchResource<T extends KubernetesResource>(params: WatchErebusResourceParams<R>): Observable<T>;
+    /**
+     * 监听资源列表变化
+     */
+    watchResourceChange<T extends KubernetesResource>(seedVersion: string, params: WatchErebusResourceListParams<R>): Observable<WatchAPIResponse<T>>;
+    /**
+     * 获取业务集群资源对象列表，包含分页信息
+     */
+    getResourceList<T extends KubernetesResource>(params: ErebusResourceListParams<R>): Observable<KubernetesResourceList<T>>;
+    /**
+     * 创建业务集群资源
+     */
+    postResource<T extends KubernetesResource>(params: ErebusResourceWriteParams<T, R>): Observable<T>;
+    /**
+     * 完整覆盖更新业务集群单个资源对象
+     */
+    putResource<T extends KubernetesResource>(params: ErebusResourceWriteParams<T, R>): Observable<T>;
+    /**
+     * 增量更新业务集群单个资源对象的部分属性
+     */
+    patchResource<T extends KubernetesResource>(params: ErebusResourcePatchParams<T, R>): Observable<T>;
+    /**
+     * 删除业务集群单个资源
+     */
+    deleteResource<S extends KubernetesResource = Status, T extends KubernetesResource = S extends Status ? KubernetesResource : S>(params: ErebusResourceDeleteParams<T, R>): Observable<S>;
+    /**
+     * 批量删除业务集群的资源
+     */
+    batchDeleteResource<S extends KubernetesResource = Status, T extends KubernetesResource = S extends Status ? KubernetesResource : S>(params: ErebusResourceBatchDeleteParams<R>): Observable<T>;
+    private _getResourceDefinition;
+    private _getApiPath;
+    private _getNamespace;
+    private _getName;
+    /**
+     * k8s list api 返回的结果里，items 缺失 kind 和 apiVersion 字段
+     * 规则如 Service 类型对应 kind: ServiceList，去掉最后四个字符可得到资源的 kind
+     * @internal
+     */
+    private _getNormalizedList;
+    private _getResource;
+    private _watchResource;
+    private _keepWatchResourceChange;
+    private _watchResourceChange;
+    private _getResourceList;
+    private _postResource;
+    private _putResource;
+    private _patchResource;
+    private _deleteResource;
+    private _batchDeleteResource;
+    private readonly _getHeaders;
+    private _getDowngradePolling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sApiService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<K8sApiService<any>>;
+}

package/api/monitor-api.service.d.ts

@@ -0,0 +1,104 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { XOR } from 'ts-essentials';
+import { IndicatorUnit } from '../a-metric-chart/types';
+import { StringMap, WorkspaceParams } from '../core/public-api';
+import { K8sApiService } from './k8s-api.service';
+import * as i0 from "@angular/core";
+export declare const INDICATOR_PROMETHEUS_NOT_DEPLOYED = "platform.cluster.prometheus.not.deployed";
+export declare const INDICATOR_PROMETHEUS_DOWN = "platform.cluster.prometheus.down";
+export interface VariablesResult {
+    options: string[];
+}
+export declare const LIMITED_OLD_VERSION_3_14 = "3.12";
+export declare class MonitorApiService {
+    private readonly http;
+    private readonly k8sApi;
+    private readonly urlPrefix;
+    constructor(http: HttpClient, k8sApi: K8sApiService);
+    getClusterMetrics: (cluster: string, params?: MonitorMetricParams) => Observable<MonitorMetric[]>;
+    getProjectMetrics: (project: string, params?: MonitorMetricParams) => Observable<MonitorMetric[]>;
+    getNamespaceMetrics: (workspace: WorkspaceParams, params?: MonitorMetricParams) => Observable<MonitorMetric[]>;
+    checkPrometheusStatus(cluster: string, scope?: Partial<WorkspaceParams>): Observable<{
+        notDeployed: boolean;
+        abnormal: boolean;
+    }>;
+    checkPrometheusDeployed(cluster: string, scope?: Partial<WorkspaceParams>): Observable<boolean>;
+    checkPrometheusAbnormal(cluster: string, scope?: Partial<WorkspaceParams>): Observable<boolean>;
+    private getMetrics;
+    private readonly indicatorStore$;
+    private readonly indicatorUnitsStore$;
+    getIndicators(cluster: string, params?: StringMap): Observable<IndicatorType[]>;
+    getIndicatorUnits(): Observable<IndicatorUnit[]>;
+    getClusterVariables: (cluster: string, params?: MonitorVariablesParams) => Observable<VariablesResult>;
+    getProjectVariables: (project: string, params?: MonitorVariablesParams) => Observable<VariablesResult>;
+    getNamespaceVariables: (workspace: WorkspaceParams, params?: MonitorVariablesParams) => Observable<VariablesResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonitorApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonitorApiService>;
+}
+export declare function joinMetricSeparator(indicators: string[]): string;
+export declare function stringifyMetricVariables(variables: Record<string, string>): string;
+export declare function stringifyMetricParams(params: MonitorMetricParams): Record<string, string>;
+export type MonitorMetricParams = Partial<XOR<{
+    start: number;
+    end: number;
+    step: number;
+}, {
+    time: number;
+}> & XOR<{
+    indicators: string | string[];
+}, {
+    expr: string;
+}> & {
+    timeout: number;
+    variables: Record<string, string | string[]>;
+}>;
+export interface MonitorVariablesParams {
+    expr: string;
+    regex?: string;
+}
+export interface MonitorMetric {
+    indicator: string;
+    query: string;
+    result: MonitorMetricResult[];
+}
+export interface CostMetric {
+    indicator: string;
+    result: CostMetricResult[];
+}
+export interface MonitorMetricResult {
+    metric: Record<string, string>;
+    values: Array<[number, string]>;
+}
+export interface CostMetricResult {
+    metric: Record<string, string>;
+    values: Array<[number, string]>;
+}
+export interface IndicatorType {
+    kind: string;
+    name: string;
+    alias: string;
+    unit: string;
+    string?: string;
+    value_type?: string;
+    type?: string;
+    query?: string;
+    alert_enabled?: boolean;
+    alertEnabled?: boolean;
+    aggregation_enabled?: boolean;
+    display_name?: string;
+    displayName?: string;
+    legend?: string;
+    summary?: string;
+    annotations?: IndicatorAnnotations;
+    variables?: string[];
+}
+export interface IndicatorAnnotations {
+    cn: string;
+    en: string;
+    asmExtraFeatures?: string;
+    descriptionEN?: string;
+    descriptionZH?: string;
+    displayNameEN?: string;
+    displayNameZH?: string;
+}

package/api/page-visibility.service.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class PageVisibilityService {
+    private readonly pageVisibility$;
+    getPageVisibility(): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageVisibilityService>;
+}