@alauda-fe/common 1.0.0-next.0

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,38 @@
+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 }: MetricParams): {
+    start: number;
+    end: number;
+    step: number;
+    indicators: any[];
+    exprs: any[];
+    variables: any[];
+};
+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'], 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-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,23 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient } from '@angular/common/http';
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ApiGatewayState {
+    apiAddress: string;
+    assetsHostPath: string;
+    assetsURLPath: string;
+}
+export declare class ApiGatewayService implements OnDestroy {
+    private readonly http;
+    private readonly modulesApi;
+    private readonly destroy$$;
+    private readonly state$;
+    constructor(http: HttpClient, modulesApi: string);
+    ngOnDestroy(): void;
+    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,22 @@
+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 version;
+    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>;
+    set clusterVersion(version: string);
+    get clusterVersion(): 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';
+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';
+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';
+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,103 @@
+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';
+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;
+    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>;
+}

package/api/platform-ui.service.d.ts

@@ -0,0 +1,45 @@
+import { ProductDocsEntry, ProductEntry } from '../core';
+import * as i0 from "@angular/core";
+export declare const PLATFORM_INFO_CM_NAME = "platform-info";
+export declare const PLATFORM_NAME_ZH_KEY = "platformNameZH";
+export declare const PLATFORM_NAME_EN_KEY = "platformNameEN";
+export declare const DEFAULT_PLATFORM_NAME_ZH_KEY = "originPlatformNameZH";
+export declare const DEFAULT_PLATFORM_NAME_EN_KEY = "originPlatformNameEN";
+export declare const PORTAL_MAIN_TITLE_EN_KEY = "portalMainTitleEN";
+export declare const PORTAL_MAIN_TITLE_ZH_KEY = "portalMainTitleZH";
+export declare const PORTAL_SUB_TITLE_ZH_KEY = "portalSubTitleZH";
+export declare const PORTAL_SUB_TITLE_EN_KEY = "portalSubTitleEN";
+export declare const PORTAL_UI_CM_NAME = "ui-portal";
+export declare const PORTAL_UI_CM_NAME_DEFAULT = "ui-portal-default";
+export declare const PORTAL_TOP_IMAGE_KEY = "top-bg";
+export declare const PORTAL_BOTTOM_IMAGE_KEY = "bottom-bg";
+export declare const DEFAULT_PORTAL_TOP_RESOURCE_NAME = "portal-top.png";
+export declare const DEFAULT_PORTAL_BOTTOM_RESOURCE_NAME = "portal-bottom.png";
+export declare const DEFAULT_PORTAL_TOP_RESOURCE_URL = "images/light/portal-top.png";
+export declare const DEFAULT_PORTAL_BOTTOM_RESOURCE_URL = "images/light/portal-bottom.png";
+export declare class PlatformUIService {
+    private readonly k8sApi;
+    private readonly theme;
+    getEntries(): import("rxjs").Observable<ProductEntry[]>;
+    getDocsEntry(): import("rxjs").Observable<ProductDocsEntry>;
+    getPlatformInfo(): import("rxjs").Observable<{
+        name: {
+            zh: string;
+            en: string;
+        };
+        mainTitle: {
+            zh: string;
+            en: string;
+        };
+        subTitle: {
+            zh: string;
+            en: string;
+        };
+    }>;
+    getBackgroundImages(): import("rxjs").Observable<{
+        topImage: string;
+        bottomImage: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformUIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformUIService>;
+}

package/api/product.service.d.ts

@@ -0,0 +1,13 @@
+import { ProductBase, ProductKey } from '../core';
+import { K8sApiService } from './k8s-api.service';
+import * as i0 from "@angular/core";
+export declare class ProductService {
+    private readonly k8sApi;
+    settings: Record<string, boolean>;
+    productBase$: import("rxjs").Observable<ProductBase>;
+    constructor(k8sApi: K8sApiService);
+    filterDeployedProduct<T>(data: T[], accessor: (arg: T) => string, filterFn: (arg: T[], fn: (a: T) => boolean) => T[]): import("rxjs").Observable<T[]>;
+    isProductDeployed(product: ProductKey): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductService>;
+}

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

@@ -0,0 +1,16 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { KubernetesResourceList, Namespace, Project, ResourceListParams } from '../core';
+import * as i0 from "@angular/core";
+export declare class ProjectApiService {
+    private readonly http;
+    constructor(http: HttpClient);
+    getProjects(params?: ResourceListParams): Observable<Project[]>;
+    getNamespaces({ project, cluster }: {
+        project: string;
+        cluster: string;
+    }): Observable<KubernetesResourceList<Namespace>>;
+    getClusterNamespaces(project: string, cluster: string): Observable<Namespace[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectApiService>;
+}

package/api/public-api.d.ts

@@ -0,0 +1,20 @@
+/**
+ * [[include:api/README.md]]
+ * @module api
+ * @preferred
+ */
+/** imports */
+export * from './api-gateway.interceptor';
+export * from './api-gateway.service';
+export * from './cluster-version.service';
+export * from './helpers';
+export * from './k8s-api.service';
+export * from './k8s-api-resource.service';
+export * from './page-visibility.service';
+export * from './resource-update.service';
+export * from './types';
+export * from './monitor-api.service';
+export * from './crypto.interceptor';
+export * from './product.service';
+export * from './project-api.service';
+export * from './platform-ui.service';

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

@@ -0,0 +1,31 @@
+import { DialogService } from '@alauda/ui';
+import { Observable } from 'rxjs';
+import { KubernetesResource } from '../core';
+import { TranslateService } from '../translate/public-api';
+import { K8sApiService } from './k8s-api.service';
+import { ApiDefinitionBaseParams, ApiTypeBaseParams } from './types';
+import * as i0 from "@angular/core";
+export declare class ResourceUpdateService<R extends string = string> {
+    private readonly k8sApi;
+    private readonly dialog;
+    private readonly translate;
+    constructor(k8sApi: K8sApiService, dialog: DialogService, translate: TranslateService);
+    /**
+     * ! 只应在完整更新资源时使用，部分更新时应该使用 patch
+     */
+    retryPutResource<T extends KubernetesResource>(params: {
+        cluster: string;
+        resource: T;
+    } & (ApiDefinitionBaseParams | ApiTypeBaseParams<R>)): Observable<T>;
+    /**
+     * ! 只应在完整更新资源时使用，部分更新时应该使用 patch
+     */
+    retryPutGlobalResource<T extends KubernetesResource>(params: {
+        type: R;
+        namespaced: boolean;
+        resource: T;
+    }): Observable<T>;
+    private retryUpdate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceUpdateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceUpdateService<any>>;
+}