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

package/async-data/error-page/component.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class ErrorStateComponent {
+    private readonly router;
+    private readonly route;
+    errorCode: number;
+    autoRedirect: boolean;
+    showBackButton: boolean;
+    backLink: string;
+    reload: EventEmitter<void>;
+    redirect: EventEmitter<void>;
+    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";
+    };
+    constructor(router: Router, route: ActivatedRoute);
+    backToList(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorStateComponent, "acl-error-state", never, { "errorCode": { "alias": "errorCode"; "required": false; }; "autoRedirect": { "alias": "autoRedirect"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "backLink": { "alias": "backLink"; "required": false; }; }, { "reload": "reload"; "redirect": "redirect"; }, never, never, true, never>;
+}

package/async-data/page-state/component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataStateAdapter } from '../types';
+import * as i0 from "@angular/core";
+export declare class PageStateComponent<T = unknown> implements OnInit {
+    adapter: DataStateAdapter<T>;
+    autoRedirect: boolean;
+    showBackButton: boolean;
+    backLink: string;
+    set top(top: number | string);
+    redirect: EventEmitter<void>;
+    template: TemplateRef<unknown>;
+    marginTop: string;
+    context$: Observable<{
+        $implicit: T;
+    } & T>;
+    errorCode$: Observable<number>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageStateComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageStateComponent<any>, "acl-page-state", never, { "adapter": { "alias": "adapter"; "required": false; }; "autoRedirect": { "alias": "autoRedirect"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "backLink": { "alias": "backLink"; "required": false; }; "top": { "alias": "top"; "required": false; }; }, { "redirect": "redirect"; }, ["template"], never, true, never>;
+}

package/async-data/public-api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * [[include:async-data/README.md]]
+ * @module async-data
+ * @preferred
+ */
+/** imports */
+export * from './async-data.module';
+export * from './async-data-loader';
+export * from './page-state/component';
+export * from './types';
+export { ErrorStateComponent } from './error-page/component';

package/async-data/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @packageDocumentation
+ * @module async-data
+ */
+import { HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Status } from '../core/public-api';
+export interface DataStateAdapter<D> {
+    rawData$: Observable<D>;
+    data$: Observable<D>;
+    loading$: Observable<boolean>;
+    error$: Observable<DataError>;
+    reload: () => void;
+}
+export type Fetcher<D, P> = (params: P) => Observable<D>;
+export interface LoaderConfig<D, P> {
+    fetcher: Fetcher<D, P>;
+    params$?: Observable<P>;
+    params?: P;
+    dataFilter?: (data: D, index: number) => boolean;
+    silent?: boolean;
+}
+export interface LoaderConfigWithInterval<D, P> extends LoaderConfig<D, P> {
+    interval: number;
+    intervalFilter?: (index: number) => boolean;
+    compare: string[] | ((a: D, b: D) => boolean);
+}
+export type DataError = Partial<HttpErrorResponse & Status>;
+export type DataMapper<D> = (data: D) => D;

package/authorization/app-init-url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+export declare function recordInitUrl(): void;
+export declare function getInitUrl(): string;

package/authorization/guard.service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { InjectionToken } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, CanActivateChild, RouterStateSnapshot } from '@angular/router';
+import { SilentlyNavigateService } from '../core/services/public-api';
+import { AuthorizationStateService } from './state.service';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_ABNORMAL_EMPTY_URL = "system-abnormal";
+export declare function abnormalEmptyUrlFactory(): string;
+export declare const ABNORMAL_EMPTY_URL_TOKEN: InjectionToken<string>;
+export declare class AuthorizationGuardService implements CanActivate, CanActivateChild {
+    private readonly emptyUrl;
+    private readonly auth;
+    private readonly silentlyNavigate;
+    constructor(emptyUrl: string, auth: AuthorizationStateService, silentlyNavigate: SilentlyNavigateService);
+    canActivate(_route: ActivatedRouteSnapshot, state: RouterStateSnapshot): import("rxjs").Observable<boolean>;
+    canActivateChild(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationGuardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationGuardService>;
+}

package/authorization/interceptor.service.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { DialogService } from '@alauda/ui';
+import { HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { ApiGatewayService } from '../api/public-api';
+import { SessionManageService } from './session-manage.service';
+import * as i0 from "@angular/core";
+export declare class AuthorizationInterceptorService implements HttpInterceptor {
+    private readonly anonymousApis;
+    private readonly apiGateway;
+    private readonly injector;
+    private readonly dialog;
+    private readonly sessionManage;
+    private auth;
+    constructor(anonymousApis: Array<string | RegExp>, apiGateway: ApiGatewayService, injector: Injector, dialog: DialogService, sessionManage: SessionManageService);
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
+    isConsoleRelative(url: string): boolean;
+    private retryAuth;
+    private cloneReq;
+    private getAuth;
+    private needAuthorization;
+    private is401;
+    private isSessionInvalid;
+    private handleSessionInvalid;
+    private isUnauthorized;
+    private isInvalidUser;
+    private isStatus;
+    private isWatchReq;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationInterceptorService>;
+}

package/authorization/public-api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * [[include:authorization/README.md]]
+ * @module authorization
+ * @preferred
+ */
+/** imports */
+export * from './guard.service';
+export * from './interceptor.service';
+export * from './app-init-url';
+export * from './session-manage.service';
+export * from './state.service';

package/authorization/session-manage.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { PageVisibilityService } from '../api/page-visibility.service';
+import { K8sApiService } from '../public-api';
+import * as i0 from "@angular/core";
+export declare const SESSION_MANAGE_KEY = "session-manage-construct-time";
+export declare class SessionManageService {
+    private readonly http;
+    private readonly pageVisibility;
+    private readonly k8sApi;
+    private readonly subscription;
+    private readonly visibility$;
+    private readonly policy$;
+    private readonly userAction$;
+    constructor(http: HttpClient, pageVisibility: PageVisibilityService, k8sApi: K8sApiService, disabled: boolean);
+    complete(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SessionManageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SessionManageService>;
+}

package/authorization/state.service.d.ts

@@ -0,0 +1,45 @@
+import { Observable } from 'rxjs';
+import { AccountInfo } from '../page-scaffold/public-api';
+import * as i0 from "@angular/core";
+export interface AuthorizationState {
+    idToken?: string;
+    refreshToken?: string;
+    state?: string;
+    authUrl?: string;
+    logoutUrl?: string;
+}
+export interface TokenResponse {
+    token_storage: StorageType;
+    id_token: string;
+    refresh_token: string;
+}
+export type StorageType = 'local' | 'session';
+export declare const STORAGE_TYPE_KEY = "token_storage";
+export declare const ID_TOKEN_KEY = "id_token";
+export declare const REFRESH_TOKEN_KEY = "refresh_token";
+export declare const CODE_KEY = "code";
+export declare class AuthorizationStateService {
+    private readonly http;
+    private readonly refreshToken$$;
+    private readonly state$;
+    private checkTokenCache;
+    private refreshTokenCache$;
+    stateSnapshot: AuthorizationState;
+    payloadSnapshot: AccountInfo;
+    logout(specificUrl?: boolean): void;
+    logoutAudit(): Observable<Object>;
+    redirectToDex(redirectUrl?: string): Promise<void>;
+    refreshToken(): Observable<string>;
+    checkToken(token: string): Observable<unknown>;
+    getToken(): Observable<string>;
+    getTokenPayload<T>(): Observable<T>;
+    getAccountInfo(): Observable<AccountInfo>;
+    private getAuthConfiguration;
+    private getExistedToken;
+    private getTokenFromLocal;
+    private getTokenByRefreshToken;
+    private getTokenByCode;
+    private getParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationStateService>;
+}

package/authorization/storage-token.d.ts

@@ -0,0 +1,11 @@
+import { StorageType } from './state.service';
+export interface StorageToken {
+    storageType: StorageType;
+    idToken: string;
+    refreshToken: string;
+}
+export declare function readStorageType(): StorageType;
+export declare function cleanStorageToken(): void;
+export declare function writeStorageToken(token: StorageToken): void;
+export declare function readStorageToken(): Partial<StorageToken>;
+export declare function asyncReadStorageToken(): Promise<Partial<StorageToken>>;

package/business/module-info/api.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { K8sApiService } from '../../api/k8s-api.service';
+import { ModuleInfo } from '../../core/public-api';
+import { K8sUtilService } from '../../core/services/public-api';
+import * as i0 from "@angular/core";
+export interface ModuleInfoGetParams {
+    cluster: string;
+    module: string;
+    single?: boolean;
+}
+export declare class ModuleInfoApiService {
+    private readonly k8sUtil;
+    private readonly k8sApi;
+    constructor(k8sUtil: K8sUtilService, k8sApi: K8sApiService);
+    getModuleInfo({ cluster, module, }: Omit<ModuleInfoGetParams, 'single'> | (ModuleInfoGetParams & {
+        single: true;
+    })): Observable<ModuleInfo>;
+    getModuleInfo({ cluster, module, }: ModuleInfoGetParams & {
+        single: false;
+    }): Observable<ModuleInfo[]>;
+    isModuleEnabled({ cluster, module }: Omit<ModuleInfoGetParams, 'single'>): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModuleInfoApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModuleInfoApiService>;
+}

package/business/module-info/public-api.d.ts

@@ -0,0 +1 @@
+export * from './api.service';

package/business/notification-disabled-container/component.d.ts

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { K8sApiService } from '../../api/public-api';
+import * as i0 from "@angular/core";
+export declare class NotificationDisabledContainerComponent {
+    private readonly k8sApi;
+    enableToSetNotification: boolean;
+    enableToSetNotification$: Observable<boolean>;
+    inputRef: TemplateRef<unknown>;
+    notificationServerOn$: Observable<boolean>;
+    constructor(k8sApi: K8sApiService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationDisabledContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationDisabledContainerComponent, "acl-notification-disabled-container", never, { "enableToSetNotification": { "alias": "enableToSetNotification"; "required": false; }; }, {}, ["inputRef"], never, true, never>;
+}

package/business/notification-disabled-container/public-api.d.ts

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

package/business/public-api.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @packageDocumentation
+ * @module business
+ * @preferred
+ */
+export * from './resource-select/public-api';
+export * from './module-info/public-api';
+export * from './notification-disabled-container/public-api';

package/business/resource-select/base-list.d.ts

@@ -0,0 +1,32 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { AuthorizationStateService } from '../../authorization/state.service';
+import { K8sUtilService } from '../../core/services/public-api';
+import { KubernetesResource } from './../../core/public-api';
+import { ResourceSelectContextService } from './context.service';
+import { ConfigurableField, DataItemBase, ResourceDataNumbers } from './types';
+import * as i0 from "@angular/core";
+export type UsageContext = 'page' | 'popup';
+export declare abstract class ResourceListBase implements OnDestroy {
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly k8sUtil: K8sUtilService;
+    protected readonly contextService: ResourceSelectContextService;
+    context: UsageContext;
+    popupLite: boolean;
+    fields: ConfigurableField[];
+    fields$: Observable<ConfigurableField[]>;
+    selectItem: EventEmitter<DataItemBase>;
+    load: EventEmitter<ResourceDataNumbers>;
+    reload$$: Subject<void>;
+    destroy$$: Subject<void>;
+    loading: boolean;
+    forceLoading: boolean;
+    auth: AuthorizationStateService;
+    constructor(cdr: ChangeDetectorRef, k8sUtil: K8sUtilService, contextService: ResourceSelectContextService);
+    reload(): void;
+    onSelect(selected: DataItemBase): void;
+    abstract mapResource(res: KubernetesResource[], params?: unknown): DataItemBase[];
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceListBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResourceListBase, never, never, { "context": { "alias": "context"; "required": false; }; "popupLite": { "alias": "popupLite"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; }, { "selectItem": "selectItem"; "load": "load"; }, never, never, false, never>;
+}

package/business/resource-select/context.service.d.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { Subject } from 'rxjs';
+import { K8sUtilService } from '../../core/services/public-api';
+import { KubernetesResource, Project, ServiceMeshGroup } from './../../core/public-api';
+import { ClusterDataItem, DataItemBase, NamespaceDataItem, ProjectDataItem } from './types';
+import * as i0 from "@angular/core";
+export interface User extends KubernetesResource {
+    spec: {
+        account: string;
+        connector_name: string;
+        connector_type: string;
+        email: string;
+        groups: string[];
+        is_admin: boolean;
+        last_login_time: string;
+        username: string;
+        valid: boolean;
+    };
+}
+export declare class ResourceSelectContextService {
+    private readonly http;
+    private readonly k8sUtil;
+    userEmail: string;
+    reload$$: Subject<void>;
+    private _cachedServiceMeshes;
+    private _cachedClusters;
+    private _cachedProjects;
+    private _cachedProjectResources;
+    private _cachedServiceMeshGroupResources;
+    set cachedServiceMeshes(value: DataItemBase[]);
+    get cachedServiceMeshes(): DataItemBase[];
+    set cachedClusters(value: ClusterDataItem[]);
+    get cachedClusters(): ClusterDataItem[];
+    get cachedProjects(): ProjectDataItem[];
+    set cachedProjects(value: ProjectDataItem[]);
+    set cachedProjectResources(projects: Project[]);
+    get cachedProjectResources(): Project[];
+    set cachedServiceMeshGroupResources(meshes: ServiceMeshGroup[]);
+    get cachedServiceMeshGroupResources(): ServiceMeshGroup[];
+    private cachedNamespaces;
+    constructor(http: HttpClient, k8sUtil: K8sUtilService);
+    storeNamespaces(project: string, cluster: string, namespaces: NamespaceDataItem[]): void;
+    getCachedNamespaces(project: string, cluster: string): NamespaceDataItem[];
+    getUser(email: string): import("rxjs").Observable<User>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceSelectContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceSelectContextService>;
+}

package/business/resource-select/exports/cluster-selector/component.d.ts

@@ -0,0 +1,23 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { ResourceSelectorPopupRef } from '../../internals/selector-popup/ref';
+import { ResourceSelectorPopupService } from '../../internals/selector-popup/service';
+import { ConfigurableField, DataItemBase } from './../../types';
+import * as i0 from "@angular/core";
+export declare class ClusterSelectorComponent {
+    private readonly popupService;
+    private readonly cdr;
+    private readonly elementRef;
+    popupTemplate: TemplateRef<any>;
+    value: string;
+    fields: ConfigurableField[];
+    valueChange: EventEmitter<string>;
+    displayFields: ConfigurableField[];
+    isActive: boolean;
+    popupRef: ResourceSelectorPopupRef;
+    constructor(popupService: ResourceSelectorPopupService, cdr: ChangeDetectorRef, elementRef: ElementRef);
+    openPopup(): void;
+    closePopup(): void;
+    onSelect(item: DataItemBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClusterSelectorComponent, "acl-cluster-selector", never, { "value": { "alias": "value"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/business/resource-select/exports/mesh-group-selector/component.d.ts

@@ -0,0 +1,23 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { ResourceSelectorPopupRef } from '../../internals/selector-popup/ref';
+import { ResourceSelectorPopupService } from '../../internals/selector-popup/service';
+import { ConfigurableField, DataItemBase } from '../../types';
+import * as i0 from "@angular/core";
+export declare class ServiceMeshGroupSelectorComponent {
+    private readonly popupService;
+    private readonly cdr;
+    private readonly elementRef;
+    popupTemplate: TemplateRef<any>;
+    value: string;
+    fields: ConfigurableField[];
+    valueChange: EventEmitter<string>;
+    displayFields: ConfigurableField[];
+    isActive: boolean;
+    popupRef: ResourceSelectorPopupRef;
+    constructor(popupService: ResourceSelectorPopupService, cdr: ChangeDetectorRef, elementRef: ElementRef);
+    openPopup(): void;
+    closePopup(): void;
+    onSelect(item: DataItemBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceMeshGroupSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceMeshGroupSelectorComponent, "acl-servicemesh-selector", never, { "value": { "alias": "value"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/business/resource-select/exports/namespace-page/component.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { K8sUtilService } from '../../../../core/services/public-api';
+import { ResourceSelectContextService } from './../../context.service';
+import { ConfigurableField, DataItemBase, DisableFn, ResourceDataNumbers, SelectedNamespaceValue } from './../../types';
+import * as i0 from "@angular/core";
+export declare class NamespacePageComponent {
+    private readonly k8sUtil;
+    private readonly contextService;
+    fields: ConfigurableField[];
+    disableFn: DisableFn;
+    value: SelectedNamespaceValue;
+    actionTemplateRef: TemplateRef<any>;
+    displayServiceMesh: boolean;
+    valueChange: EventEmitter<SelectedNamespaceValue>;
+    clusterChange: EventEmitter<string>;
+    projectChange: EventEmitter<string>;
+    numbers: ResourceDataNumbers;
+    displayFields: ConfigurableField[];
+    constructor(k8sUtil: K8sUtilService, contextService: ResourceSelectContextService);
+    dataLoad(numbers: ResourceDataNumbers): void;
+    onSelect(item: DataItemBase): void;
+    reload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamespacePageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamespacePageComponent, "acl-namespace-page", never, { "fields": { "alias": "fields"; "required": false; }; "disableFn": { "alias": "disableFn"; "required": false; }; "value": { "alias": "value"; "required": false; }; "actionTemplateRef": { "alias": "actionTemplateRef"; "required": false; }; "displayServiceMesh": { "alias": "displayServiceMesh"; "required": false; }; }, { "valueChange": "valueChange"; "clusterChange": "clusterChange"; "projectChange": "projectChange"; }, never, ["[aclResourceGridHeader]"], false, never>;
+}

package/business/resource-select/exports/namespace-selector/component.d.ts

@@ -0,0 +1,33 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { AuthorizationStateService } from '../../../../authorization/public-api';
+import { K8sUtilService } from '../../../../core/services/public-api';
+import { ResourceSelectorPopupRef } from '../../internals/selector-popup/ref';
+import { ResourceSelectorPopupService } from '../../internals/selector-popup/service';
+import { ConfigurableField, DataItemBase, DisableFn, SelectedNamespaceValue } from './../../types';
+import * as i0 from "@angular/core";
+export declare class NamespaceSelectorComponent implements AfterViewInit {
+    private readonly popupService;
+    private readonly cdr;
+    private readonly elementRef;
+    private readonly k8sUtil;
+    private readonly auth;
+    popupTemplate: TemplateRef<any>;
+    disableFn: DisableFn;
+    value: SelectedNamespaceValue;
+    fields: ConfigurableField[];
+    displayServiceMesh: boolean;
+    clusterChange: EventEmitter<string>;
+    projectChange: EventEmitter<string>;
+    valueChange: EventEmitter<SelectedNamespaceValue>;
+    displayFields: ConfigurableField[];
+    isActive: boolean;
+    popupRef: ResourceSelectorPopupRef;
+    loading: boolean;
+    constructor(popupService: ResourceSelectorPopupService, cdr: ChangeDetectorRef, elementRef: ElementRef, k8sUtil: K8sUtilService, auth: AuthorizationStateService);
+    ngAfterViewInit(): void;
+    openPopup(): void;
+    closePopup(): void;
+    onSelect(item: DataItemBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NamespaceSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NamespaceSelectorComponent, "acl-namespace-selector", never, { "disableFn": { "alias": "disableFn"; "required": false; }; "value": { "alias": "value"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "displayServiceMesh": { "alias": "displayServiceMesh"; "required": false; }; }, { "clusterChange": "clusterChange"; "projectChange": "projectChange"; "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/business/resource-select/exports/project-page/component.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from '@angular/core';
+import { ResourceSelectContextService } from '../../context.service';
+import { ConfigurableField, DataItemBase, ResourceDataNumbers } from './../../types';
+import * as i0 from "@angular/core";
+export declare class ProjectPageComponent {
+    private readonly contextService;
+    value: string;
+    fields: ConfigurableField[];
+    valueChange: EventEmitter<string>;
+    constructor(contextService: ResourceSelectContextService);
+    numbers: ResourceDataNumbers;
+    displayFields: ConfigurableField[];
+    dataLoad(numbers: ResourceDataNumbers): void;
+    onSelect(item: DataItemBase): void;
+    reload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectPageComponent, "acl-project-page", never, { "value": { "alias": "value"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/business/resource-select/exports/project-selector/component.d.ts

@@ -0,0 +1,27 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { AuthorizationStateService } from '../../../../authorization/public-api';
+import { ResourceSelectorPopupRef } from './../../internals/selector-popup/ref';
+import { ResourceSelectorPopupService } from './../../internals/selector-popup/service';
+import { ConfigurableField, DataItemBase } from './../../types';
+import * as i0 from "@angular/core";
+export declare class ProjectSelectorComponent implements AfterViewInit {
+    private readonly popupService;
+    private readonly cdr;
+    private readonly elementRef;
+    private readonly auth;
+    popupTemplate: TemplateRef<any>;
+    value: string;
+    popupLite: boolean;
+    fields: ConfigurableField[];
+    valueChange: EventEmitter<string>;
+    displayFields: ConfigurableField[];
+    isActive: boolean;
+    popupRef: ResourceSelectorPopupRef;
+    constructor(popupService: ResourceSelectorPopupService, cdr: ChangeDetectorRef, elementRef: ElementRef, auth: AuthorizationStateService);
+    ngAfterViewInit(): void;
+    openPopup(): void;
+    closePopup(): void;
+    onSelect(item: DataItemBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectSelectorComponent, "acl-project-selector", never, { "value": { "alias": "value"; "required": false; }; "popupLite": { "alias": "popupLite"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/business/resource-select/helpers.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ResourceGridHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceGridHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResourceGridHeaderDirective, "[aclResourceGridHeader]", never, {}, {}, never, never, false, never>;
+}

package/business/resource-select/internals/cluster-list/component.d.ts

@@ -0,0 +1,25 @@
+import { HttpClient } from '@angular/common/http';
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Cluster, K8sUtilService } from '../../../../core/public-api';
+import { ResourceListBase } from '../../base-list';
+import { ResourceSelectContextService } from '../../context.service';
+import { ClusterDataItem } from '../../types';
+import * as i0 from "@angular/core";
+export declare class ClusterListComponent extends ResourceListBase implements OnInit, OnDestroy {
+    private readonly http;
+    value: string;
+    type: "cluster";
+    selectedCluster: ClusterDataItem;
+    clusters: ClusterDataItem[];
+    clusters$: import("rxjs").Observable<Cluster[]>;
+    loadClusterInfo$$: Subject<Cluster[]>;
+    constructor(http: HttpClient, contextService: ResourceSelectContextService, cdr: ChangeDetectorRef, k8sUtil: K8sUtilService);
+    ngOnInit(): void;
+    private setSelected;
+    ngOnDestroy(): void;
+    mapResource(list: Cluster[]): ClusterDataItem[];
+    getClusterStatus(cluster?: Cluster): "normal" | "abnormal";
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClusterListComponent, "acl-cluster-list", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}

package/business/resource-select/internals/data-grid/component.d.ts

@@ -0,0 +1,42 @@
+import { ElementRef, EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { UsageContext } from '../../base-list';
+import { ConfigurableField, DataItem, DataItemBase, DataType, DisplayMode } from '../../types';
+import * as i0 from "@angular/core";
+export declare class ResourceDataGridComponent implements OnInit {
+    set grid(grid: ElementRef<HTMLElement>);
+    context: UsageContext;
+    popupLite: boolean;
+    data: DataItemBase[];
+    data$: Observable<DataItemBase[]>;
+    type: DataType;
+    fields: ConfigurableField[];
+    actionTemplateRef: TemplateRef<any>;
+    selectedUid: string;
+    loading: boolean;
+    selectItem: EventEmitter<DataItemBase>;
+    filter: EventEmitter<string>;
+    reload: EventEmitter<void>;
+    keyword: string;
+    fieldsDef: typeof ConfigurableField;
+    displayMode: DisplayMode;
+    filter$: ReplaySubject<string>;
+    private readonly displayModeKey;
+    displayData$: Observable<DataItemBase[]>;
+    private scrollInitialized;
+    statusIcon: Record<string, string>;
+    ngOnInit(): void;
+    private initScroll;
+    getHighlightedNameStrs: (item: DataItemBase) => {
+        text: string;
+        isHighlighted?: boolean;
+    }[];
+    onSelect(item: DataItemBase): void;
+    setDisplayMode(mode: DisplayMode): void;
+    keywordChange(keyword: string): void;
+    filterDisabledData(data: DataItemBase[], context: UsageContext): DataItem[];
+    sortWithoutIstio: (data: DataItemBase[]) => DataItemBase[];
+    pluralForm(type: DataType): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceDataGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceDataGridComponent, "acl-resource-data-grid", never, { "context": { "alias": "context"; "required": false; }; "popupLite": { "alias": "popupLite"; "required": false; }; "data": { "alias": "data"; "required": false; }; "type": { "alias": "type"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "actionTemplateRef": { "alias": "actionTemplateRef"; "required": false; }; "selectedUid": { "alias": "selectedUid"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "selectItem": "selectItem"; "filter": "filter"; "reload": "reload"; }, never, ["[aclResourceGridHeader]"], false, never>;
+}