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

package/page-scaffold/navigation/navconfig-loader/public-api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * [[include:navconfig-loader/README.md]]
+ * @module navconfig-loader
+ * @preferred
+ */
+/** imports */
+export * from './navconfig-loader.service';

package/page-scaffold/navigation/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './breadcrumb/public-api';
+export * from './lottie-icons/public-api';
+export * from './nav-menu/public-api';
+export * from './navconfig-loader/public-api';
+export * from './module';
+export * from './utils';

package/page-scaffold/navigation/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module navconfig-loader
+ */
+import { NavItemConfig } from './nav-menu/nav-menu.types';
+export declare const reduceNavTrees: <T extends import("../../core/utils/tree").Tree, R>(fn: import("../../core/utils/tree").TreeReducer<T, R>) => (seed: R) => (trees: T[]) => R;
+export declare const mapNavTrees: <T extends import("../../core/utils/tree").Tree, R extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeMapper<T, R>) => (trees: T[]) => R[];
+export declare const filterNavTrees: <T extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeFilter<T>) => (trees: T[]) => T[];
+export declare const findNavPath: <T extends import("../../core/utils/tree").Tree>(fn: import("../../core/utils/tree").TreeFilter<T>) => (trees: T[]) => T[];
+export declare const firstNavPath: <T extends import("../../core/utils/tree").Tree>(trees: T[]) => T[];
+export declare const filterEmptyNode: (trees: NavItemConfig[]) => NavItemConfig[];

package/page-scaffold/page/context.service.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PageContextService {
+    showToolbar$: BehaviorSubject<boolean>;
+    showToolbar(): void;
+    hideToolbar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PageContextService>;
+}

package/page-scaffold/page/helper-directives.d.ts

@@ -0,0 +1,30 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PageHeaderDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderDirective, "[aclPageHeader]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageContentDirective, "[aclPageContent]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageSiderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageSiderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageSiderDirective, "[aclPageSider]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageToolbarDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageToolbarDirective, "[aclPageToolbar]", never, {}, {}, never, never, false, never>;
+}
+export declare class PageHeaderAppendDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderAppendDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderAppendDirective, "[aclPageHeaderAppend]", never, {}, {}, never, never, true, never>;
+}

package/page-scaffold/page/notices/maintenance.component.d.ts

@@ -0,0 +1,26 @@
+import { DialogService } from '@alauda/ui';
+import { TemplateRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { K8sApiService } from '../../../api/k8s-api.service';
+import { AuthorizationStateService } from '../../../authorization/state.service';
+import { K8sPermissionService } from '../../../permission/public-api';
+import { TranslateService } from '../../../translate/public-api';
+import { NoticeComponent } from './notice.component';
+import * as i0 from "@angular/core";
+export declare class MaintenanceComponent {
+    readonly notice: NoticeComponent;
+    private readonly k8sApi;
+    private readonly k8sPermission;
+    private readonly translate;
+    private readonly auth;
+    private readonly dialog;
+    maintenance: TemplateRef<any>;
+    announcement: TemplateRef<any>;
+    isDevMode: boolean;
+    noticeId: string;
+    announcement$: BehaviorSubject<string>;
+    hasConfirm: boolean;
+    constructor(notice: NoticeComponent, k8sApi: K8sApiService, k8sPermission: K8sPermissionService, translate: TranslateService, auth: AuthorizationStateService, dialog: DialogService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaintenanceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MaintenanceComponent, "acl-page-header-notice-maintenance", never, {}, {}, never, never, true, never>;
+}

package/page-scaffold/page/notices/notice.component.d.ts

@@ -0,0 +1,22 @@
+import { InlineAlertType } from '@alauda/ui';
+import { ComponentType } from '@angular/cdk/portal';
+import { ChangeDetectorRef, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NoticeComponent {
+    private readonly cdr;
+    pageHeaderAppend: ComponentType<any>;
+    messages: Message[];
+    constructor(cdr: ChangeDetectorRef);
+    open: (message: Message) => () => void;
+    close: (id?: string) => void;
+    iconMap(type: InlineAlertType): "check_circle_s" | "exclamation_circle_s" | "exclamation_triangle_s" | "info_circle_s";
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoticeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NoticeComponent, "acl-page-notice", never, {}, {}, ["pageHeaderAppend"], never, true, never>;
+}
+export interface Message {
+    content: string;
+    id?: string;
+    suffix?: TemplateRef<any>;
+    type?: InlineAlertType;
+    closable?: boolean;
+}

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

@@ -0,0 +1,24 @@
+import { TemplateRef, ElementRef, AfterViewInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { IframeConfigService } from '../../iframe-config/config.service';
+import * as i0 from "@angular/core";
+export declare class PageComponent implements AfterViewInit {
+    private readonly iframeConfigService;
+    showAlerts: boolean;
+    pageHeader: TemplateRef<any>;
+    pageContent: TemplateRef<any>;
+    pageSider: TemplateRef<any>;
+    pageToolbar: TemplateRef<any>;
+    header?: ElementRef<HTMLElement>;
+    private readonly classes;
+    classes$$: BehaviorSubject<Set<string>>;
+    showToolbar$: BehaviorSubject<boolean>;
+    isHideMenu: boolean;
+    isHideHeader: boolean;
+    constructor(iframeConfigService: IframeConfigService);
+    ngAfterViewInit(): void;
+    addClass(cls: string): void;
+    removeClass(cls: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageComponent, "acl-page", never, { "showAlerts": { "alias": "showAlerts"; "required": false; }; }, {}, ["pageHeader", "pageContent", "pageSider", "pageToolbar"], never, false, never>;
+}

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./page.component";
+import * as i2 from "./helper-directives";
+import * as i3 from "@angular/common";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../../skeleton/module";
+import * as i6 from "../../translate/translate.module";
+import * as i7 from "./notices/notice.component";
+import * as i8 from "@angular/cdk/overlay";
+export declare class PageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PageModule, [typeof i1.PageComponent, typeof i2.PageHeaderDirective, typeof i2.PageContentDirective, typeof i2.PageSiderDirective, typeof i2.PageToolbarDirective], [typeof i3.CommonModule, typeof i4.IconModule, typeof i5.SkeletonModule, typeof i4.InlineAlertModule, typeof i6.TranslateModule, typeof i7.NoticeComponent, typeof i8.CdkScrollable], [typeof i1.PageComponent, typeof i2.PageHeaderDirective, typeof i2.PageContentDirective, typeof i2.PageSiderDirective, typeof i2.PageToolbarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PageModule>;
+}

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

@@ -0,0 +1,4 @@
+export * from './helper-directives';
+export * from './context.service';
+export * from './page.component';
+export * from './page.module';

package/page-scaffold/page-header/account-menu/component/component.d.ts

@@ -0,0 +1,38 @@
+import { AlaudaMonacoProviderService } from '@alauda/code-editor';
+import { ThemeMode, ThemeService } from '@alauda/ui';
+import { AuthorizationStateService } from '../../../../authorization/public-api';
+import { TranslateService } from '../../../../translate/public-api';
+import * as i0 from "@angular/core";
+export interface AccountInfo {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    iat?: number;
+    azp?: string;
+    at_hash?: string;
+    email?: string;
+    email_verified?: true;
+    name?: string;
+    token?: string;
+    ext?: {
+        is_admin?: boolean;
+        conn_id?: boolean;
+    };
+}
+export declare class AccountMenuComponent {
+    private readonly auth;
+    private readonly translate;
+    private readonly theme;
+    displayName$: import("rxjs").Observable<string>;
+    themeMode: string;
+    get icon(): "lang_en" | "lang_zh";
+    constructor(auth: AuthorizationStateService, translate: TranslateService, theme: ThemeService, monacoService: AlaudaMonacoProviderService);
+    logout(): void;
+    changeLanguage(): void;
+    navigateToLink(): void;
+    setThemeMode(v: ThemeMode): void;
+    private initThemeMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountMenuComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccountMenuComponent, "acl-account-menu", never, {}, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/account-menu/module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component/component";
+import * as i2 from "@angular/common";
+import * as i3 from "@alauda/ui";
+import * as i4 from "../../../translate/translate.module";
+export declare class AccountMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AccountMenuModule, [typeof i1.AccountMenuComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i4.TranslateModule, typeof i3.DropdownModule, typeof i3.RadioModule], [typeof i1.AccountMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AccountMenuModule>;
+}

package/page-scaffold/page-header/account-menu/public-api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @packageDocumentation
+ * @module account-menu
+ * @preferred
+ */
+export * from './component/component';
+export * from './module';

package/page-scaffold/page-header/common-layout/common-layout.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./product-select/component";
+import * as i2 from "./namespace-select/component";
+import * as i3 from "@alauda/ui";
+import * as i4 from "@angular/common";
+import * as i5 from "../../../translate/translate.module";
+import * as i6 from "../../../scm/pure-pipe/module";
+import * as i7 from "../../../core/pipes/img-header.pipe";
+import * as i8 from "../../../core/pipes/safe.pipe";
+import * as i9 from "../../../widget/loading-mask/loading-mask.component";
+import * as i10 from "../../../core/pipes/k8s-util.pipe.module";
+export declare class CommonLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonLayoutModule, [typeof i1.ProductSelectComponent, typeof i2.NamespaceSelectComponent], [typeof i3.DialogModule, typeof i4.CommonModule, typeof i3.DropdownModule, typeof i3.InputModule, typeof i3.IconModule, typeof i5.TranslateModule, typeof i3.TooltipModule, typeof i3.StepsModule, typeof i6.PurePipeModule, typeof i7.ImgHeaderPipe, typeof i8.SafePipe, typeof i9.LoadingMaskComponent, typeof i10.K8sUtilPipeModule], [typeof i1.ProductSelectComponent, typeof i2.NamespaceSelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CommonLayoutModule>;
+}

package/page-scaffold/page-header/common-layout/context.service.d.ts

@@ -0,0 +1,51 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { K8sApiService } from '../../../api/k8s-api.service';
+import { ProjectService } from '../../../business/resource-select/project.service';
+import { KubernetesResource, ValueOf, Project, ProductEntry } from '../../../core/public-api';
+import { TranslateKey } from '../../../translate/types';
+import * as i0 from "@angular/core";
+export interface Production extends KubernetesResource {
+    kind: 'Production';
+    spec: {
+        group: 'production' | 'others';
+        index: number;
+        logoURL?: string;
+        title: TranslateKey;
+        version?: string;
+        description?: string;
+        openInBlank?: boolean;
+        homepage: string;
+    };
+}
+export interface NamespaceIdentity {
+    cluster: string;
+    name: string;
+}
+export declare const ProductEntryName: {
+    readonly ACP: "acp";
+    readonly DevOps: "devops";
+    readonly ASM: "asm";
+    readonly AML: "aml";
+    readonly AAM: "e-aam";
+    readonly SECURITY: "security";
+    readonly PLATFORM: "platform";
+    readonly PROJECT: "project";
+    readonly DATA_SERVICES: "dataservices";
+    readonly CEC: "cec";
+};
+export type ProductEntryName = ValueOf<typeof ProductEntryName>;
+export declare class CommonLayoutContextService {
+    private readonly k8sApi;
+    private readonly httpClient;
+    private readonly globalNamespace;
+    private readonly projectService;
+    constructor(k8sApi: K8sApiService, httpClient: HttpClient, globalNamespace: string, projectService: ProjectService);
+    getProjects(): Observable<Project[]>;
+    getProducts(): Observable<ProductEntry[]>;
+    getProduct(name: string): Observable<ProductEntry>;
+    getProjectClusters(_projectName: string): Observable<KubernetesResource[]>;
+    getClusterNamespaces(_projectName: string, _clusterName: string): Observable<KubernetesResource[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonLayoutContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonLayoutContextService>;
+}

package/page-scaffold/page-header/common-layout/namespace-select/component.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @packageDocumentation
+ * @module common-layout
+ */
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { KubernetesResource, K8sUtilService } from '../../../../core/public-api';
+import { NamespaceIdentity } from '../context.service';
+import { BaseSelection } from '../project-select/base-selection';
+import { CommonLayoutStoreService, Group } from '../store.service';
+import * as i0 from "@angular/core";
+export declare class NamespaceSelectComponent extends BaseSelection {
+    private readonly store;
+    private readonly k8sUtil;
+    private readonly projectName$$;
+    set projectName(projectName: string);
+    selected?: NamespaceIdentity;
+    selectedChange: EventEmitter<NamespaceIdentity>;
+    availableGroups$: import("rxjs").Observable<[KubernetesResource, KubernetesResource[]][]>;
+    hasNamespace$: import("rxjs").Observable<boolean>;
+    groups$: import("rxjs").Observable<{
+        cluster: KubernetesResource;
+        namespaces: KubernetesResource[];
+    }[]>;
+    constructor(store: CommonLayoutStoreService, k8sUtil: K8sUtilService, cdr: ChangeDetectorRef);
+    name: (item: KubernetesResource) => string;
+    isActive: (item: KubernetesResource, selected: NamespaceIdentity, { group: { cluster }, groups, i, j, focusedMenuItemIndex, }: {
+        group: {
+            cluster: KubernetesResource;
+        };
+        groups: Array<{
+            namespaces: unknown[];
+        }>;
+        i: number;
+        j: number;
+        focusedMenuItemIndex: number;
+    }) => boolean;
+    trackFn: (_: number, item: KubernetesResource) => string;
+    groupTrackFn: (_: number, { cluster, }: {
+        cluster: KubernetesResource;
+        namespaces: KubernetesResource[];
+    }) => string;
+    hasResult(groups: Group[]): boolean;
+    onSelect({ cluster }: {
+        cluster: KubernetesResource;
+    }, namespace: KubernetesResource): void;
+    selectByIndex(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamespaceSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamespaceSelectComponent, "acl-namespace-select", never, { "projectName": { "alias": "projectName"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, false, never>;
+}

package/page-scaffold/page-header/common-layout/product-select/component.d.ts

@@ -0,0 +1,38 @@
+import { OnInit } from '@angular/core';
+import { Router } from '@angular/router';
+import { AuthorizationStateService } from '../../../../authorization/public-api';
+import { StringMap, ProductEntry } from '../../../../core/public-api';
+import { K8sPermissionService } from '../../../../permission/k8s-permission.service';
+import { ProductEntryName } from '../context.service';
+import { CommonLayoutStoreService } from '../store.service';
+import { ProductSelectService } from './service';
+import * as i0 from "@angular/core";
+export declare const PRODUCT_ICON_MAP: StringMap;
+export declare class ProductSelectComponent implements OnInit {
+    private readonly store;
+    private readonly router;
+    private readonly k8sPermission;
+    private readonly productSelectService;
+    private readonly authState;
+    platformPath: string;
+    current?: ProductEntryName;
+    title?: string;
+    PRODUCT_ICON_MAP: StringMap;
+    allProducts$: import("rxjs").Observable<ProductEntry[]>;
+    selectableProducts$: import("rxjs").Observable<ProductEntry[]>;
+    portalProduct$: import("rxjs").Observable<ProductEntry>;
+    disabled$: import("rxjs").Observable<boolean>;
+    isPortal: boolean;
+    constructor(store: CommonLayoutStoreService, router: Router, k8sPermission: K8sPermissionService, productSelectService: ProductSelectService, authState: AuthorizationStateService);
+    ngOnInit(): void;
+    jump(entrypoint: string, ssoEnabled: boolean, target?: string): void;
+    navigateToPortal(event: MouseEvent): void;
+    navigateToProduct(item: ProductEntry, event: MouseEvent): void;
+    trackFn: (_: number, item: ProductEntry) => string;
+    navigateToPlatform(item: ProductEntry): void;
+    isProductActive(item: ProductEntry, current: ProductEntryName): boolean;
+    isPortalProduct(item: ProductEntry): boolean;
+    getProductTitle: (products: ProductEntry[], title: string, current: ProductEntryName) => string | import("../../../../core/public-api").LocaleDisplay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductSelectComponent, "acl-product-select", never, { "platformPath": { "alias": "platformPath"; "required": false; }; "current": { "alias": "current"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/common-layout/product-select/service.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ProductSelectService {
+    reload$$: BehaviorSubject<boolean>;
+    reload$: import("rxjs").Observable<boolean>;
+    reload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSelectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductSelectService>;
+}

package/page-scaffold/page-header/common-layout/project-select/base-selection.d.ts

@@ -0,0 +1,24 @@
+import { DropdownDirective } from '@alauda/ui';
+import { ChangeDetectorRef, ElementRef, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class BaseSelection {
+    protected cdr: ChangeDetectorRef;
+    protected inputContainer: ElementRef<HTMLDivElement>;
+    protected menuItems: QueryList<ElementRef>;
+    protected menuItemsContainer: ElementRef;
+    protected dropdown: DropdownDirective;
+    focusedMenuItemIndex: number;
+    keyword$$: Subject<string>;
+    constructor(cdr: ChangeDetectorRef);
+    handleMenuVisible(visible: boolean): Promise<void>;
+    private getInputEl;
+    private readonly onKeyDown;
+    private closeDropdown;
+    private focusMenuItem;
+    private resetFocusedItem;
+    private scrollToOption;
+    abstract selectByIndex(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSelection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSelection, never, never, {}, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/common-layout/public-api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [[include:common-layout/README.md]]
+ * @module common-layout
+ * @preferred
+ */
+/** imports */
+export * from './common-layout.module';
+export * from './context.service';
+export * from './namespace-select/component';
+export * from './product-select/component';
+export * from './store.service';
+export * from './utils';
+export * from './product-select/service';

package/page-scaffold/page-header/common-layout/store.service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @packageDocumentation
+ * @module common-layout
+ */
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { KubernetesResource, K8sUtilService, ProductEntry } from '../../../core/public-api';
+import { CommonLayoutContextService } from './context.service';
+import * as i0 from "@angular/core";
+export interface Group {
+    cluster: KubernetesResource;
+    namespaces: KubernetesResource[];
+}
+export declare class CommonLayoutStoreService implements OnDestroy {
+    private readonly context;
+    private readonly k8sUtil;
+    private readonly fetch$;
+    private readonly projects$;
+    private readonly products$;
+    private readonly subscriptions;
+    constructor(context: CommonLayoutContextService, k8sUtil: K8sUtilService);
+    ngOnDestroy(): void;
+    refetch(): void;
+    selectAllProducts(): Observable<ProductEntry[]>;
+    selectProductByName(name: string): Observable<ProductEntry>;
+    selectAllProjects(): Observable<KubernetesResource[]>;
+    selectProjectByName(name: string): Observable<KubernetesResource>;
+    selectNamespacesByProjectName(name: string): Observable<Array<[KubernetesResource, KubernetesResource[]]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonLayoutStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommonLayoutStoreService>;
+}

package/page-scaffold/page-header/common-layout/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function writeSelectedProject(value: string): void;
+export declare function readSelectedProject(): string;

package/page-scaffold/page-header/component.d.ts

@@ -0,0 +1,21 @@
+import { DocsOption } from '../../help-document/directive';
+import { TranslateService } from '../../translate/public-api';
+import { ProductEntryName } from './common-layout/public-api';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_PLATFORM_PATH = "/console-platform";
+export declare class PageHeaderComponent {
+    logoUrl: string;
+    private readonly translate;
+    DEFAULT_PLATFORM_PATH: string;
+    logoSrc: string;
+    locale$: import("rxjs").Observable<"zh" | "en">;
+    title: string;
+    currentProduct: ProductEntryName;
+    docsOption: DocsOption;
+    isPlatform: boolean;
+    menuActions: boolean;
+    menuSeparator: boolean;
+    constructor(logoUrl: string, translate: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageHeaderComponent, "acl-page-header", never, { "title": { "alias": "title"; "required": false; }; "currentProduct": { "alias": "currentProduct"; "required": false; }; "docsOption": { "alias": "docsOption"; "required": false; }; "isPlatform": { "alias": "isPlatform"; "required": false; }; "menuActions": { "alias": "menuActions"; "required": false; }; "menuSeparator": { "alias": "menuSeparator"; "required": false; }; }, {}, never, ["*", "[customActions]"], false, never>;
+}

package/page-scaffold/page-header/enterprise-support-status/component.d.ts

@@ -0,0 +1,24 @@
+import { TagType } from '@alauda/ui';
+import { Observable } from 'rxjs';
+import { TimeService } from '../../../core/public-api';
+import { LicenseApiService } from '../../../license/license-api';
+import { ProductEntryName } from '../common-layout/public-api';
+import * as i0 from "@angular/core";
+export declare class EnterpriseSupportStatusComponent {
+    private readonly licenseApiService;
+    private readonly timeService;
+    product: ProductEntryName;
+    product$: Observable<ProductEntryName>;
+    constructor(licenseApiService: LicenseApiService, timeService: TimeService);
+    data$: Observable<{
+        tooltips: {
+            content: string;
+            data: {};
+        }[];
+        title: string;
+        status: TagType;
+    }>;
+    formatDate(date: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnterpriseSupportStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EnterpriseSupportStatusComponent, "acl-enterprise-support-status", never, { "product": { "alias": "product"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/header-notify/component/header-notify.component.d.ts

@@ -0,0 +1,27 @@
+import { ThemeService } from '@alauda/ui';
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { NotifyService } from '../notify.service';
+import { Message } from '../utils';
+import * as i0 from "@angular/core";
+export declare class HeaderNotifyComponent implements OnInit, OnDestroy {
+    private readonly notifyService;
+    private readonly theme;
+    private readonly cdr;
+    active: boolean;
+    visible: boolean;
+    push: boolean;
+    pushEnabled: boolean;
+    list: Message[];
+    beforeUnloadHandle(): void;
+    noDataSrc$: import("rxjs").Observable<string>;
+    constructor(notifyService: NotifyService, theme: ThemeService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    watchMessageConfigMap(): void;
+    getNotifyList(): void;
+    openNotify(): void;
+    closeNotify(): void;
+    switchPush(enabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNotifyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderNotifyComponent, "acl-header-notify", never, {}, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/header-notify/component/notification-list/notification-list.component.d.ts

@@ -0,0 +1,19 @@
+import { K8sUtilService } from '../../../../../core/public-api';
+import { Message } from '../../utils';
+import * as i0 from "@angular/core";
+export declare class NotificationListComponent {
+    private readonly k8sUtil;
+    list: Message[];
+    constructor(k8sUtil: K8sUtilService);
+    trackBy(_index: number, res: Message): string;
+    expandedChange(expanded: boolean, item: Message): void;
+    expired(item: Message): boolean;
+    formatUtcStr(utcStr: string): string;
+    getTagOption: (value: Message) => {
+        type?: import("@alauda/ui").TagType;
+        title: string;
+        color?: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationListComponent, "acl-notification-list", never, { "list": { "alias": "list"; "required": false; }; }, {}, never, never, false, never>;
+}

package/page-scaffold/page-header/header-notify/header-notify.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component/header-notify.component";
+import * as i2 from "./component/notification-list/notification-list.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../../../translate/translate.module";
+import * as i6 from "@angular/forms";
+import * as i7 from "../../../k8s-resource-list/k8s-resource-list.module";
+import * as i8 from "../../../core/module";
+export declare class HeaderNotifyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderNotifyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeaderNotifyModule, [typeof i1.HeaderNotifyComponent, typeof i2.NotificationListComponent], [typeof i3.CommonModule, typeof i4.IconModule, typeof i4.DrawerModule, typeof i5.TranslateModule, typeof i4.SwitchModule, typeof i6.FormsModule, typeof i7.K8SResourceListModule, typeof i8.CoreModule, typeof i4.TagModule, typeof i4.AccordionModule, typeof i4.NotificationModule, typeof i4.TooltipModule], [typeof i1.HeaderNotifyComponent, typeof i2.NotificationListComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeaderNotifyModule>;
+}