@alauda-fe/common 1.0.0-next.0

package/permission/admin.guard.d.ts

@@ -0,0 +1,14 @@
+import { CanActivate, CanActivateChild, Router } from '@angular/router';
+import { AuthorizationStateService } from '../authorization/public-api';
+import * as i0 from "@angular/core";
+export declare class AdminGuardService implements CanActivate, CanActivateChild {
+    private readonly router;
+    private readonly auth;
+    private readonly nonAdminRedirectPath;
+    isAdmin$: import("rxjs").Observable<boolean>;
+    constructor(router: Router, auth: AuthorizationStateService, nonAdminRedirectPath: string);
+    canActivate(): import("rxjs").Observable<boolean>;
+    canActivateChild(): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdminGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdminGuardService>;
+}

package/permission/constants.d.ts

@@ -0,0 +1 @@
+export declare const NO_PERMISSION = "no-permission";

package/permission/helpers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module permission
+ */
+import { Arrayable, IfEqual, SelfSubjectAccessReview, UnaryObservableFunction } from '../core';
+export declare const isAdmin: UnaryObservableFunction<{
+    ext?: {
+        admin: boolean;
+    };
+}, boolean>;
+export declare function isAllowed<T extends Arrayable<SelfSubjectAccessReview>, K extends boolean = true>(transform?: K): UnaryObservableFunction<T, IfEqual<K, false, T extends SelfSubjectAccessReview | Readonly<SelfSubjectAccessReview> ? boolean : boolean[], Record<T extends Arrayable<SelfSubjectAccessReview<infer R>> ? R : never, boolean>>>;

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

@@ -0,0 +1,80 @@
+/**
+ * @packageDocumentation
+ * @module permission
+ */
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { K8sApiResourceService } from '../api/public-api';
+import { IfEqual, K8sResourceAction, KubernetesResource, SelfSubjectAccessReview } from '../core';
+import { AllPermissions, K8sPermissionTransformable, K8sResourcePermissionMultiParams, K8sResourcePermissionNoneParams, K8sResourcePermissionSingleParams, K8sTypePermissionActionsParams, K8sTypePermissionMatrixParams, K8sTypePermissionMultiParams, K8sTypePermissionNamesParams, K8sTypePermissionNoneParams, K8sTypePermissionSingleParams } from './types';
+import * as i0 from "@angular/core";
+export declare class K8sPermissionService {
+    private readonly http;
+    private readonly k8sApiResource;
+    constructor(http: HttpClient, k8sApiResource: K8sApiResourceService);
+    /**
+     * 获取对 K8s 资源的操作权限，一般和 isAllowed 配合使用
+     */
+    /**
+     * 根据已有 K8s 资源，不传入 action 或为 null 时默认取 get 操作权限
+     */
+    getAccess<K extends KubernetesResource, T extends K8sResourceAction = K8sResourceAction.GET>(params: K8sResourcePermissionNoneParams<K>): Observable<SelfSubjectAccessReview<T>>;
+    /**
+     * 根据已有 K8s 资源，进行单个指定 action 操作权限
+     */
+    getAccess<T extends K8sResourceAction, K extends KubernetesResource>(params: K8sResourcePermissionSingleParams<K, T>): Observable<SelfSubjectAccessReview<T>>;
+    /**
+     * 根据已有 K8s 资源，进行多个指定 action 操作权限列表
+     */
+    getAccess<T extends K8sResourceAction, K extends KubernetesResource>(params: K8sResourcePermissionMultiParams<K, T>): Observable<Array<SelfSubjectAccessReview<T>>>;
+    /**
+     * 根据 K8s 资源类型，不传入 action 或为 null 时默认取 list 操作权限
+     */
+    getAccess(params: K8sTypePermissionNoneParams): Observable<SelfSubjectAccessReview<K8sResourceAction.LIST>>;
+    /**
+     * 根据 K8s 资源类型和名称进行单个指定 action 操作权限，默认取 get 操作权限
+     */
+    getAccess<T extends K8sResourceAction = K8sResourceAction.GET>(params: K8sTypePermissionSingleParams<T>): Observable<SelfSubjectAccessReview<T>>;
+    /**
+     * 根据 K8s 资源类型，进行多个指定 action 操作或者多个名称的权限列表
+     */
+    getAccess<T extends K8sResourceAction>(params: K8sTypePermissionMultiParams<T>): Observable<Array<SelfSubjectAccessReview<T>>>;
+    /**
+     * 根据 K8s 资源类型，进行多个指定 action 操作和多个名称的权限二位数组列表
+     */
+    getAccess<T extends K8sResourceAction>(params: K8sTypePermissionMatrixParams<T>): Observable<Array<Array<SelfSubjectAccessReview<T>>>>;
+    /**
+     * 根据已经获取到的操作权限对象或列表转化为更方便使用的权限 record 或数组
+     */
+    /**
+     * 根据已有 K8s 资源，不传入 action 或为 null 时转化为 boolean
+     */
+    isAllowed<T extends K8sResourceAction, K extends KubernetesResource>(params: K8sResourcePermissionNoneParams<K> | K8sResourcePermissionSingleParams<K, T>): Observable<boolean>;
+    /**
+     * 根据已有 K8s 资源，多个 action 默认转为 record，`transform === false` 时转为 `boolean[]`
+     */
+    isAllowed<T extends K8sResourceAction, K extends KubernetesResource, R extends boolean = true>(params: K8sResourcePermissionMultiParams<K, T> & Partial<K8sPermissionTransformable<R>>): Observable<IfEqual<R, false, boolean[], Record<T, boolean>>>;
+    /**
+     * 根据 K8s 资源类型，不传入 action/name 或为 null 时，默认取 get 权限，自动转化为 boolean，`transform !== false` 时转化为 record
+     */
+    isAllowed<T extends K8sResourceAction = K8sResourceAction.GET, K extends boolean = false>(params: K8sTypePermissionNoneParams & Partial<K8sPermissionTransformable<K>>): Observable<IfEqual<K, false, boolean, Record<T, boolean>>>;
+    /**
+     * 根据 K8s 资源类型，传入单个 action 或 name 时，`action === ALL(*)` 时自动转化为所有权限的 record，否则转化为 `boolean`
+     */
+    isAllowed<T extends K8sResourceAction>(params: K8sTypePermissionSingleParams<T>): Observable<IfEqual<T, K8sResourceAction.ALL, AllPermissions, boolean>>;
+    /**
+     * 根据 K8s 资源类型，传入单个 action 或 name 时，自动转化为 record，`transform === false` 时转化为 `boolean`
+     */
+    isAllowed<T extends K8sResourceAction, K extends boolean>(params: K8sTypePermissionSingleParams<T> & K8sPermissionTransformable<K>): Observable<IfEqual<K, false, boolean, IfEqual<T, K8sResourceAction.ALL, AllPermissions, Record<T, boolean>>>>;
+    /**
+     * 根据 K8s 资源类型，传入多个 action 时，自动转化为 record，`transform === false` 时转化为 `boolean[]`
+     */
+    isAllowed<T extends K8sResourceAction, K extends boolean = true>(params: K8sTypePermissionActionsParams<T> & Partial<K8sPermissionTransformable<K>>): Observable<IfEqual<K, false, boolean[], Record<T, boolean>>>;
+    /**
+     * 根据 K8s 资源类型，传入多个 name 时，自动转化为 `boolean[]`
+     */
+    isAllowed<T extends K8sResourceAction>(params: K8sTypePermissionNamesParams<T>): Observable<boolean[]>;
+    private _getAccess;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sPermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<K8sPermissionService>;
+}

package/permission/permission.guard.d.ts

@@ -0,0 +1,22 @@
+import { OnDestroy } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, RouterStateSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import { StringMap, SilentlyNavigateService } from '../core';
+import { K8sPermissionService } from './k8s-permission.service';
+import * as i0 from "@angular/core";
+/**
+ * @see https://confluence.alauda.cn/pages/viewpage.action?pageId=115520649
+ */
+export declare class PermissionGuardService implements CanActivate, CanActivateChild, OnDestroy {
+    private readonly k8sPermission;
+    private readonly silentlyNavigate;
+    private readonly destroy$$;
+    private readonly cache;
+    constructor(k8sPermission: K8sPermissionService, silentlyNavigate: SilentlyNavigateService);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): true | Observable<boolean>;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): true | Observable<boolean>;
+    ngOnDestroy(): void;
+    getParams(route: ActivatedRouteSnapshot, childFirst?: boolean): StringMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionGuardService>;
+}

package/permission/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * [[include:permission/README.md]]
+ * @module permission
+ * @preferred
+ */
+/** imports */
+export * from './admin.guard';
+export * from './constants';
+export * from './helpers';
+export * from './k8s-permission.service';
+export * from './permission.guard';
+export * from './types';

package/permission/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @packageDocumentation
+ * @module permission
+ */
+import { K8sResourceDefinition } from '../api/types';
+import { AnyArray, K8sResourceAction, KubernetesResource } from '../core/types';
+export declare const READABLE_ACTIONS: readonly [K8sResourceAction.GET, K8sResourceAction.LIST, K8sResourceAction.PROXY, K8sResourceAction.REDIRECT, K8sResourceAction.WATCH];
+export declare const WRITABLE_ACTIONS: readonly [K8sResourceAction.CREATE, K8sResourceAction.DELETE, K8sResourceAction.DELETE_COLLECTION, K8sResourceAction.PATCH, K8sResourceAction.UPDATE];
+export declare const COMMON_READABLE_ACTIONS: readonly [K8sResourceAction.GET];
+export declare const COMMON_WRITABLE_ACTIONS: readonly [K8sResourceAction.CREATE, K8sResourceAction.DELETE, K8sResourceAction.UPDATE];
+export declare const ALL_ACTIONS: readonly [K8sResourceAction.CREATE, K8sResourceAction.DELETE, K8sResourceAction.DELETE_COLLECTION, K8sResourceAction.GET, K8sResourceAction.LIST, K8sResourceAction.PATCH, K8sResourceAction.PROXY, K8sResourceAction.REDIRECT, K8sResourceAction.UPDATE, K8sResourceAction.WATCH];
+export type ReadablePermissions = Readonly<Record<(typeof READABLE_ACTIONS)[number], boolean>>;
+export type WritablePermissions = Readonly<Record<(typeof WRITABLE_ACTIONS)[number], boolean>>;
+export type CommonReadablePermissions = Readonly<Record<(typeof COMMON_READABLE_ACTIONS)[number], boolean>>;
+export type CommonWritablePermissions = Readonly<Record<(typeof COMMON_WRITABLE_ACTIONS)[number], boolean>>;
+export type AllPermissions = Readonly<Record<(typeof ALL_ACTIONS)[number] | 'all', boolean>>;
+export interface K8sPermissionBaseParams {
+    advanced?: boolean;
+    project?: string;
+}
+export interface K8sTypePermissionBaseParams extends K8sPermissionBaseParams {
+    type: string | K8sResourceDefinition;
+    subResource?: string;
+    cluster?: string;
+    namespace?: string;
+}
+export type K8sTypePermissionNoneParams = K8sTypePermissionBaseParams & {
+    action?: null;
+    name?: null;
+};
+export type K8sTypePermissionSingleParams<T extends K8sResourceAction> = K8sTypePermissionBaseParams & ({
+    action: T;
+    name?: string;
+} | {
+    action?: T;
+    name: string;
+});
+export interface K8sTypePermissionActionsParams<T extends K8sResourceAction> extends K8sTypePermissionBaseParams {
+    action: AnyArray<T>;
+    name?: string;
+}
+export interface K8sTypePermissionNamesParams<T extends K8sResourceAction> extends K8sTypePermissionBaseParams {
+    action?: T;
+    name: AnyArray<string>;
+}
+export type K8sTypePermissionMultiParams<T extends K8sResourceAction> = K8sTypePermissionActionsParams<T> | K8sTypePermissionNamesParams<T>;
+export interface K8sTypePermissionMatrixParams<T extends K8sResourceAction> extends K8sTypePermissionBaseParams {
+    action: AnyArray<T>;
+    name: AnyArray<string>;
+}
+export type K8sTypePermissionParams<T extends K8sResourceAction> = K8sTypePermissionNoneParams | K8sTypePermissionSingleParams<T> | K8sTypePermissionMultiParams<T> | K8sTypePermissionMatrixParams<T>;
+export interface K8sPermissionTransformable<T extends boolean> {
+    transform: T;
+}
+export type K8sTypePermissionWithTransformParams<T extends K8sResourceAction, K extends boolean> = K8sTypePermissionParams<T> & Partial<K8sPermissionTransformable<K>>;
+export interface K8sResourcePermissionBaseParams<T extends KubernetesResource> extends K8sPermissionBaseParams {
+    cluster: string;
+    resource: T;
+}
+export interface K8sResourcePermissionNoneParams<T extends KubernetesResource> extends K8sResourcePermissionBaseParams<T> {
+    action?: null;
+}
+export interface K8sResourcePermissionSingleParams<T extends KubernetesResource, K extends K8sResourceAction> extends K8sResourcePermissionBaseParams<T> {
+    action: K;
+}
+export interface K8sResourcePermissionMultiParams<T extends KubernetesResource, K extends K8sResourceAction> extends K8sResourcePermissionBaseParams<T> {
+    action: AnyArray<K>;
+}
+export type K8sResourcePermissionParams<T extends KubernetesResource, K extends K8sResourceAction> = K8sResourcePermissionNoneParams<T> | K8sResourcePermissionSingleParams<T, K> | K8sResourcePermissionMultiParams<T, K>;
+export type K8sResourcePermissionWithTransformParams<T extends KubernetesResource, K extends K8sResourceAction, R extends boolean> = K8sResourcePermissionParams<T, K> & Partial<K8sPermissionTransformable<R>>;
+export interface PermissionGuardData {
+    /** 参数的读取是否优先读取子级路由(递归) */
+    childFirst?: boolean;
+}

package/pie-derivative-chart/donut-status/component.d.ts

@@ -0,0 +1,79 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ContextItem } from '../../chart/common';
+import * as i0 from "@angular/core";
+export declare const CHART_COLORS: {
+    running: string;
+    partial_running: string;
+    pending: string;
+    failed: string;
+    fail_or_abnormal: string;
+    stopped: string;
+    empty: string;
+    error: string;
+    no_workload: string;
+    nil: string;
+    completed: string;
+    done: string;
+};
+export interface DonutStatusItem {
+    name: string;
+    value: number;
+    color?: string;
+    type?: string;
+    index?: number;
+}
+export declare class DonutStatusChartComponent {
+    data: DonutStatusItem[];
+    data$: Observable<DonutStatusItem[]>;
+    loading: boolean;
+    loading$: Observable<boolean>;
+    failed: boolean;
+    pieLabelText: string | TemplateRef<unknown>;
+    failed$: Observable<boolean>;
+    layout: 'row' | 'column';
+    size: number;
+    customText: string;
+    customTextSize: string;
+    unit: string;
+    hideUnit: boolean;
+    hideLegend: boolean;
+    decimal: boolean;
+    width: number;
+    guideLabel: string;
+    tooltipTrigger: 'axis' | 'item' | 'none';
+    tooltipHideTitle: boolean;
+    tooltipTranslation: boolean;
+    tooltipPointFormat: (d: ContextItem) => number | string;
+    refresh: EventEmitter<any>;
+    get layoutColumn(): boolean;
+    status$: Observable<{
+        loading: boolean;
+        failed: boolean;
+    }>;
+    pieData$: Observable<{
+        color: string;
+        name: string;
+        value: number;
+        type?: string;
+        index?: number;
+    }[]>;
+    total$: Observable<number>;
+    CHART_COLORS: {
+        running: string;
+        partial_running: string;
+        pending: string;
+        failed: string;
+        fail_or_abnormal: string;
+        stopped: string;
+        empty: string;
+        error: string;
+        no_workload: string;
+        nil: string;
+        completed: string;
+        done: string;
+    };
+    color(item: DonutStatusItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DonutStatusChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DonutStatusChartComponent, "acl-donut-status-chart", never, { "data": { "alias": "data"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "failed": { "alias": "failed"; "required": false; }; "pieLabelText": { "alias": "pieLabelText"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "size": { "alias": "size"; "required": false; }; "customText": { "alias": "customText"; "required": false; }; "customTextSize": { "alias": "customTextSize"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "hideUnit": { "alias": "hideUnit"; "required": false; }; "hideLegend": { "alias": "hideLegend"; "required": false; }; "decimal": { "alias": "decimal"; "required": false; }; "width": { "alias": "width"; "required": false; }; "guideLabel": { "alias": "guideLabel"; "required": false; }; "tooltipTrigger": { "alias": "tooltipTrigger"; "required": false; }; "tooltipHideTitle": { "alias": "tooltipHideTitle"; "required": false; }; "tooltipTranslation": { "alias": "tooltipTranslation"; "required": false; }; "tooltipPointFormat": { "alias": "tooltipPointFormat"; "required": false; }; }, { "refresh": "refresh"; }, never, never, false, never>;
+}

package/pie-derivative-chart/indicator-color.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IndicatorColorDirective implements OnInit {
+    private readonly el;
+    indicator: string | number;
+    constructor(el: ElementRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndicatorColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IndicatorColorDirective, "[aclIndicatorColor]", never, { "indicator": { "alias": "indicator"; "required": false; }; }, {}, never, never, false, never>;
+}

package/pie-derivative-chart/numerical-limit.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NumericalLimitPipe implements PipeTransform {
+    transform(value: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumericalLimitPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumericalLimitPipe, "aclNumericalLimit", false>;
+}

package/pie-derivative-chart/pie-derivative-chart.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./radial-bar/radial-bar-chart.component";
+import * as i2 from "./donut-status/component";
+import * as i3 from "./numerical-limit.pipe";
+import * as i4 from "./indicator-color.directive";
+import * as i5 from "@angular/common";
+import * as i6 from "../core/module";
+import * as i7 from "@alauda/ui";
+import * as i8 from "../view-chart/view-chart.module";
+import * as i9 from "../translate/translate.module";
+export declare class PieDerivativeChartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PieDerivativeChartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PieDerivativeChartModule, [typeof i1.RadialBarChartComponent, typeof i2.DonutStatusChartComponent, typeof i3.NumericalLimitPipe, typeof i4.IndicatorColorDirective], [typeof i5.CommonModule, typeof i6.CoreModule, typeof i7.TooltipModule, typeof i8.ViewChartModule, typeof i9.TranslateModule, typeof i7.IconModule, typeof i7.ButtonModule], [typeof i1.RadialBarChartComponent, typeof i2.DonutStatusChartComponent, typeof i3.NumericalLimitPipe, typeof i4.IndicatorColorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PieDerivativeChartModule>;
+}

package/pie-derivative-chart/public-api.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module pieDerivativeChart
+ * @preferred
+ */
+/** imports */
+export * from './donut-status/component';
+export * from './radial-bar/radial-bar-chart.component';
+export * from './pie-derivative-chart.module';
+export * from './indicator-color.directive';
+export * from './numerical-limit.pipe';

package/pie-derivative-chart/radial-bar/radial-bar-chart.component.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+interface NodeFractionArc {
+    backgroundArcPath: any;
+    fractionArcPath: any;
+    labels: string[];
+    labelCoord: any;
+    fractionArcOpacity: number;
+    fraction: any;
+    color: string;
+    value: string;
+    hideIndicator?: boolean;
+}
+export declare class RadialBarChartComponent implements OnChanges {
+    limitsFraction: number;
+    requestsFraction: number;
+    capacity: number;
+    data: Array<{
+        title: string;
+        value: string;
+        fraction: number;
+        hideIndicator: boolean;
+        color?: string;
+    }>;
+    unit: string;
+    color: string;
+    usage: string;
+    request: string;
+    loading: boolean;
+    failed: boolean;
+    refresh: EventEmitter<any>;
+    readonly size = 160;
+    readonly offset = 120;
+    private readonly pieSize;
+    private readonly margin;
+    private readonly innerShrink;
+    readonly maxValue = 999999;
+    readonly decimalMaxValue = 999.99;
+    arcs: NodeFractionArc[];
+    ngOnChanges(): void;
+    get transform(): string;
+    get outerRadius(): number;
+    get innerRadius(): number;
+    arcTrackByFn(index: number): number;
+    private getArcs;
+    getArc: (level: number, fraction: number, label: string, opacity: number, value: string, hideIndicator?: boolean, color?: string) => NodeFractionArc;
+    handelData(): NodeFractionArc[];
+    getBackgroundArcPath(level?: number): string;
+    onRefresh(): void;
+    private getFractionArcPath;
+    private getTextCoord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadialBarChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadialBarChartComponent, "acl-radial-bar-chart", never, { "limitsFraction": { "alias": "limitsFraction"; "required": false; }; "requestsFraction": { "alias": "requestsFraction"; "required": false; }; "capacity": { "alias": "capacity"; "required": false; }; "data": { "alias": "data"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "color": { "alias": "color"; "required": false; }; "usage": { "alias": "usage"; "required": false; }; "request": { "alias": "request"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "failed": { "alias": "failed"; "required": false; }; }, { "refresh": "refresh"; }, never, never, false, never>;
+}
+export {};

package/public-api.d.ts

@@ -0,0 +1,43 @@
+export * from './api/public-api';
+export * from './async-data/public-api';
+export * from './authorization/public-api';
+export * from './business/public-api';
+export * from './code/public-api';
+export * from './disabled-container/public-api';
+export * from './k8s-resource-list/public-api';
+export * from './license/public-api';
+export * from './notification/public-api';
+export * from './permission/public-api';
+export * from './translate/public-api';
+export * from './core/public-api';
+export * from './help-document/public-api';
+export * from './array-form-table/public-api';
+export * from './widget/public-api';
+export * from './abnormal-page/public-api';
+export * from './view-chart/public-api';
+export * from './view-zchart/public-api';
+export * from './metric-chart/public-api';
+export * from './mutable/public-api';
+export * from './pie-derivative-chart/public-api';
+export * from './overview-banner/public-api';
+export * from './errors-mapper/public-api';
+export * from './graph-canvas/public-api';
+export * from './skeleton/public-api';
+export * from './form';
+export * from './page-guard/public-api';
+export * from './page-scaffold';
+export * from './table/public-api';
+export * from './feature-gate-forbidden';
+export * from './scm';
+export * from './multi-search';
+export * from './exec';
+export * from './searchable-selector/public-api';
+export * from './grid-layout';
+export * from './editable-text';
+export * from './window-channel';
+export * from './a-chart/public-api';
+export * from './a-metric-chart/public-api';
+export * from './custom-columns-setting/public-api';
+export * from './iframe-config/public-api';
+export * from './effect-directive/public-api';
+export * from './xterm/public-api';

package/scm/index.d.ts

@@ -0,0 +1,8 @@
+export * from './password-input';
+export * from './pure-pipe';
+export * from './text-ellipsis/component';
+export { ResourceMultiSelectComponent } from './resource-multi-select/component';
+export { isSelectAll, ALL_VALUE, checkValueExit, } from './resource-multi-select/util';
+export { SearchItemComponent } from './search-panel/search-item/component';
+export { SearchPanelComponent } from './search-panel/component';
+export { SearchItemLabelDirective } from './search-panel/helper.directive';

package/scm/password-input/component.d.ts

@@ -0,0 +1,35 @@
+import { FormItemWidth } from '@alauda/ui';
+import { OnInit, TemplateRef } from '@angular/core';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { BaseNestedFormControlPure } from '../../core/public-api';
+import * as i0 from "@angular/core";
+export interface Encoding {
+    decode: (v: string) => string;
+    encode: (v: string) => string;
+}
+export declare class PasswordInputComponent extends BaseNestedFormControlPure<string> implements OnInit {
+    initPassword: string;
+    label: string;
+    hint: string | TemplateRef<any>;
+    specialChars: string;
+    strongPassword: boolean | '';
+    enableConfirm: boolean | '';
+    width: FormItemWidth;
+    toggleable: boolean;
+    pattern: string;
+    encoding: Encoding;
+    placeholder: string;
+    set required(required: boolean | '');
+    get required(): boolean;
+    showPassword: boolean;
+    confirmPassword: string;
+    isTemplateRef: (label: any) => label is TemplateRef<unknown>;
+    private _required;
+    ngOnInit(): void;
+    valueIn(v: string): string;
+    modelOut(v: string): string;
+    validate(): ValidationErrors;
+    validateConfirmPassword(password: string): (control: AbstractControl) => ValidationErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordInputComponent, "acl-password-input", never, { "initPassword": { "alias": "initPassword"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "specialChars": { "alias": "specialChars"; "required": false; }; "strongPassword": { "alias": "strongPassword"; "required": false; }; "enableConfirm": { "alias": "enableConfirm"; "required": false; }; "width": { "alias": "width"; "required": false; }; "toggleable": { "alias": "toggleable"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "encoding": { "alias": "encoding"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
+}

package/scm/password-input/index.d.ts

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

package/scm/password-input/module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../../errors-mapper/errors-mapper.module";
+import * as i6 from "../../translate/translate.module";
+import * as i7 from "../../form/validators/module";
+import * as i8 from "../pure-pipe/module";
+export declare class PasswordInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PasswordInputModule, [typeof i1.PasswordInputComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule, typeof i4.FormModule, typeof i4.IconModule, typeof i4.InputModule, typeof i5.ErrorsMapperModule, typeof i6.TranslateModule, typeof i7.ValidatorsModule, typeof i8.PurePipeModule], [typeof i1.PasswordInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PasswordInputModule>;
+}

package/scm/pure-pipe/calc.pipe.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CalcPipe implements PipeTransform {
+    transform<T extends (...args: unknown[]) => unknown>(calc: T, ...args: Parameters<T>): ReturnType<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalcPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CalcPipe, "calc", false>;
+}

package/scm/pure-pipe/index.d.ts

@@ -0,0 +1,3 @@
+export * from './module';
+export * from './pure.pipe';
+export * from './calc.pipe';

package/scm/pure-pipe/module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./calc.pipe";
+import * as i2 from "./pure.pipe";
+export declare class PurePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PurePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PurePipeModule, [typeof i1.CalcPipe], [typeof i2.PurePipe], [typeof i2.PurePipe, typeof i1.CalcPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PurePipeModule>;
+}

package/scm/pure-pipe/pure.pipe.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { PipeTransform } from '@angular/core';
+import { IfEqual } from '../../core';
+import * as i0 from "@angular/core";
+export type OmitFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];
+export declare class PurePipe implements PipeTransform {
+    /**
+     * ! Notice: function overload is not supported for `mapper`,
+     * you may have to use `$any` to workaround in template.
+     */
+    transform<T extends (...args: unknown[]) => unknown>(value: Parameters<T>[0], mapper: T, ...args: IfEqual<T, any, unknown[], OmitFirst<Parameters<T>>>): ReturnType<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PurePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PurePipe, "pure", true>;
+}

package/scm/resource-multi-select/component.d.ts

@@ -0,0 +1,40 @@
+import { OptionFilterFn, SelectFilterOption, StringMap, TrackFn } from '@alauda/ui';
+import { EventEmitter, TemplateRef, ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ResourceMultiSelectComponent implements ControlValueAccessor {
+    private readonly cdr;
+    list: string[];
+    limit: number;
+    prefixLabel: string;
+    disabled: boolean;
+    required: boolean;
+    readonly: boolean;
+    allOptionTemplate: TemplateRef<any>;
+    allOptionTemplateContext: StringMap;
+    optionTemplate: TemplateRef<any>;
+    placeholder: string;
+    countLimited: boolean;
+    filter: OptionFilterFn<string>;
+    trackBy: TrackFn<string>;
+    allowEmpty: boolean;
+    valueChange: EventEmitter<string[]>;
+    values$$: BehaviorSubject<string[]>;
+    values: string[];
+    isSelectAllOption: boolean;
+    isPartial: boolean;
+    ALL_VALUE: string;
+    constructor(cdr: ChangeDetectorRef);
+    writeValue(values: string[]): void;
+    onChange: import("../../core").Callback;
+    onTouched: import("../../core").Callback;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => void): void;
+    disableOption: (checkedValue: string, values: string[]) => boolean;
+    onValueChange(values: string[]): void;
+    filterFn: (filter: string, option: SelectFilterOption<string>) => boolean;
+    trackByFn: (value: string) => unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceMultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceMultiSelectComponent, "acl-resource-multi-select", never, { "list": { "alias": "list"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "prefixLabel": { "alias": "prefixLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "allOptionTemplate": { "alias": "allOptionTemplate"; "required": false; }; "allOptionTemplateContext": { "alias": "allOptionTemplateContext"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "countLimited": { "alias": "countLimited"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/scm/resource-multi-select/util.d.ts

@@ -0,0 +1,10 @@
+import { KubernetesResource } from '../../core';
+export declare const DEFAULT_LIMIT_COUNT = 30;
+export declare const ALL_VALUE = "All";
+export declare enum OptionAction {
+    Active = "active",
+    Disabled = "disabled",
+    Partial = "partial"
+}
+export declare const checkValueExit: <T extends string | KubernetesResource>(checkedValue: T, values: T[]) => boolean;
+export declare const isSelectAll: <T extends string | KubernetesResource>(values: T[], allVal?: string) => boolean;

package/scm/search-panel/component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, QueryList, AfterViewInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { SearchItemComponent } from './search-item/component';
+import * as i0 from "@angular/core";
+export declare class SearchPanelComponent implements AfterViewInit {
+    enableEnterHandler: boolean | '';
+    search: EventEmitter<void>;
+    resetSearch: EventEmitter<void>;
+    items: QueryList<SearchItemComponent>;
+    enter(): void;
+    isFulWidth$$: Subject<boolean>;
+    ngAfterViewInit(): void;
+    private checkItemLength;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchPanelComponent, "acl-search-panel", never, { "enableEnterHandler": { "alias": "enableEnterHandler"; "required": false; }; }, { "search": "search"; "resetSearch": "resetSearch"; }, ["items"], ["*", "[additional]"], true, never>;
+}