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

package/core/types/schema.d.ts

@@ -0,0 +1,14 @@
+export interface OpenAPIV3SchemaObject {
+    type: JSONSchema6TypeName;
+    description?: string;
+    enum?: string[];
+    properties?: {
+        [key: string]: OpenAPIV3SchemaObject;
+    };
+    required?: string[];
+    items?: OpenAPIV3SchemaObject;
+    title?: string;
+    default?: any;
+    additionalProperties?: OpenAPIV3SchemaObject;
+}
+export type JSONSchema6TypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null' | 'any';

package/core/utils/browser.d.ts

@@ -0,0 +1,4 @@
+export declare const saveAs: (data: Blob | File | string, filename: string) => void;
+export declare function isMac(): boolean;
+export declare function isWindows(): boolean;
+export declare const getTopWindow: () => Window;

package/core/utils/cache-store.d.ts

@@ -0,0 +1,33 @@
+import { MonoTypeOperatorFunction, Observable } from 'rxjs';
+export declare class CacheStore<V, P, K extends keyof any = string> {
+    private readonly fetcher;
+    private readonly idGenerator;
+    private readonly share;
+    private readonly store;
+    constructor({ idGenerator, fetcher, share }: CacheStoreOptions<V, P, K>);
+    fetchState(params: P): Observable<CacheLoadState<V>>;
+    fetch(params: P): Observable<V>;
+    refetch(params: P): void;
+    refetchAll(): void;
+    delete(params: P): void;
+    has(params: P): boolean;
+    clear: () => void;
+    forEach: (callbackfn: (value: Cache<P, V>, key: K, map: Map<K, Cache<P, V>>) => void, thisArg?: any) => void;
+    entries: () => IterableIterator<[K, Cache<P, V>]>;
+    values: () => IterableIterator<Cache<P, V>>;
+}
+export interface CacheStoreOptions<V, P, K> {
+    fetcher: (params: P) => Observable<V>;
+    idGenerator?: (params: P) => K;
+    share?: <T>() => MonoTypeOperatorFunction<T>;
+}
+export interface CacheLoadState<V> {
+    state: 'loading' | 'loaded' | 'loadFailed';
+    result?: V;
+    error?: unknown;
+}
+export interface Cache<P, V> {
+    params: P;
+    refetch: () => void;
+    loadState: Observable<CacheLoadState<V>>;
+}

package/core/utils/color-helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const primaryColor: string;
+export declare const errorColor: string;
+export declare const successColor: string;
+export declare const warnColor: string;

package/core/utils/common.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Sort } from '@alauda/ui';
+import { UnionToIntersection } from 'ts-essentials';
+import { Terminal } from 'xterm';
+import { Callback, Keys, KubernetesResource, Nullable, Readonlyable } from '../types/public-api';
+export declare const numToStr: (num?: number) => string;
+export declare const shortNum: (num?: number | string, digits?: number) => string;
+export declare const isBlank: (str?: unknown) => boolean;
+export declare const getBaseHref: () => string;
+export declare const ifExist: <T>(toCheck: boolean | T, truthyValue: T, fallback?: T) => T;
+export declare const isAbsoluteUrl: (url: string) => boolean;
+export declare const noop: Callback;
+export declare const toKeys: <T extends object>(source: T) => Keys<T>;
+export declare const wrapText: (text?: string, wrapper?: Readonlyable<[
+    string,
+    string
+]>, fallback?: string) => string;
+export declare function parseJSONStream<T>(text: string): T[];
+export declare const trackByUid: <T extends KubernetesResource>(_: number, resource: T) => string;
+export declare const isK8sResource: <T extends KubernetesResource = KubernetesResource>(value: object) => value is T;
+export declare const arrayify: <T, R = T extends (infer S)[] ? NonNullable<S> : NonNullable<T>>(...args: (R | R[])[]) => R[];
+export declare function sleep(ms?: number): Promise<unknown>;
+export declare const delay: typeof sleep;
+export declare function scrollIntoView(container: HTMLElement, selected: HTMLElement): void;
+export declare const isEqual: <T, V = T>(a: T, b: V) => boolean;
+export declare const parseJson: <T>(str: string, defaultValue?: T) => any;
+export declare function isJsonObjectString(str: string): boolean;
+export declare const parseValidImageName: (image: string) => string;
+export declare const atobWithFallback: (str: string, fallbackValue?: string) => string;
+export interface SafeAssignOptions {
+    notice: (duplicates: string[]) => any;
+}
+/**
+ * 带重复检查的assign，只做一级key的重复检查
+ * 如果有重复项默认会throw error，如果你明确这不是一个关键性错误，则可以通过指定notice函数修改该默认行为
+ * @param sources
+ * @param optionsOrNotice
+ * @return object 一个全新的对象
+ */
+export declare const safeAssign: <T extends Record<string, any>>(sources: T[], optionsOrNotice?: SafeAssignOptions['notice'] | SafeAssignOptions) => UnionToIntersection<T>;
+export declare const toLowerFirstLetter: (text: string) => string;
+export declare const loadEnv: (envText: string) => Array<[
+    string,
+    string
+]>;
+export declare function filterEmptyValue<T extends Record<string, unknown>>(obj: T): Partial<T>;
+export declare function parseBase64Type(base64Str: string): string;
+export declare function appendImageHeader(value: string, prefix?: string): string;
+export declare const getRelativePath: (from: string, to: string) => string;
+export declare const getToPath: (from: string, relative: string) => string;
+export declare const trackByName: <T extends KubernetesResource>(_: number, resource: T) => string;
+export declare function tableSort<T>(list: T[], sort: Sort, sortActiveValueFn: (item: T, name: string) => string | number): T[];
+export declare function tableSortAdvance<T>(list: T[], sort: Sort, sortActiveValueFn: (item: T, name: string) => string | number): T[];
+export declare const nodeName2Address: (name: string) => string;
+export declare const buildImageAddress: (url: string, tagOrDigest: string) => string;
+export declare const parseImageAddress: (addr: string) => {
+    digest?: string;
+    tag?: string;
+    url: string;
+};
+export declare const setWindowsXtermTools: (xterm: Terminal) => void;
+export declare const clearWindowsXtermTools: () => void;

package/core/utils/create-recursive-filter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+/** Recursive filter without presume data structure
+ *
+ * @example 1. Nested Tree
+ *
+ * ```
+ * interface Node {
+ *   ...,
+ *   children: Node[]
+ * }
+ *
+ * const filter = createRecursiveFilter(
+ *   (node: Node) => node.children,
+ *   (node: Node, children: Node[]) => ({ ...node, children }),
+ *  );
+ * ```
+ *
+ * @example 2. Normalized Tree
+ *
+ * ```
+ * interface Node {
+ *   id: string;
+ *   children: string[];
+ * }
+ *
+ * interface NodeEntities {
+ *   [id: string]: Node;
+ * }
+ *
+ * const nodes: NodeEntities;
+ *
+ * const filter = createRecursiveFilter(
+ *   (node: Node) => node.children.map(id => nodes[id]),
+ *   (node: Node, children: Node[]) => ({ ...node, children: children.map(child => child.id) }),
+ * );
+ * ```
+ */
+export declare const createRecursiveFilter: <T>(pickChildren?: (item: T) => T[], mergeChildren?: (item: T, children: T[]) => T) => (items: T[], condition: (item: T) => boolean) => T[];

package/core/utils/cron-util.d.ts

@@ -0,0 +1,8 @@
+export declare const CRON_ENABLE_7_FOR_SUNDAY = false;
+export type CronWeekDay = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+export declare const CronWeekDays: CronWeekDay[];
+export declare const WEEK_DAYS: CronWeekDay[];
+export declare function getCronWeekDayNumbers(schedule: string): number[];
+export declare function isCronWeekDayCorrect(schedule: string): boolean;
+export declare function isCronWeekDaysContinuous(days: number[]): boolean;
+export declare function isCronFieldCountCorrect(exp: string): boolean;

package/core/utils/decorators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DebounceSettings, DebouncedFunc } from 'lodash-es';
+import { ObservableType } from '../types/public-api';
+export declare function ValueHook<T = any, K extends keyof T = any>(setter?: (this: T, value?: T[K]) => boolean | void, getter?: (this: T, value?: T[K]) => T[K], afterSetter?: (this: T, value?: T[K]) => void): (target: T, propertyKey: K) => void;
+export type ObservableInputPropertyKey<T> = T extends `${infer R}$` ? ObservableInputPropertyKey<R> : T;
+export declare function ObservableInput<T = any, OK extends keyof T = any, K extends keyof T = ObservableInputPropertyKey<OK> & keyof T>(propertyKey?: K | boolean, initialValue?: ObservableType<T[OK]>): (target: T, oPropertyKey: OK) => void;
+/**
+ * @see https://github.com/NoHomey/bind-decorator
+ */
+export declare function bind<T extends Function>(_target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
+export declare function debounceFn<T extends (...args: any) => any>(delay?: number, options?: DebounceSettings): (_target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<DebouncedFunc<T>> | void;

package/core/utils/format-number.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @ngModule CommonModule
+ *
+ * Formats a number as text. Group sizing and separator and other locale-specific
+ * configurations are based on the locale.
+ *
+ * Where:
+ * - `value` is a number.
+ * - `digitInfo` See {@link DecimalPipe} for more details.
+ */
+export declare function formatNumber(value: number, digitsInfo?: number[]): string;

package/core/utils/k8s-util.d.ts

@@ -0,0 +1,30 @@
+import { KubernetesResource, OwnerReference } from '../types/public-api';
+export declare const assemble: (subdomain: string, domain: string, type: string) => string;
+export declare const k8sSubGroup: import("ts-toolbelt/out/Function/Curry").Curry<(subdomain: string, type: string) => string>;
+export declare const k8sGroup: import("ts-toolbelt/out/Function/Curry").Curry<(type: string) => string>;
+export declare const subdomainGroup: import("ts-toolbelt/out/Function/Curry").Curry<(subdomain: string, type: string) => string>;
+export declare const domainGroup: import("ts-toolbelt/out/Function/Curry").Curry<(type: string) => string>;
+export declare const getSubdomainLabel: import("ts-toolbelt/out/Function/Curry").Curry<(subdomain: string, type: string, resource: KubernetesResource) => string>;
+export declare const getDomainLabel: import("ts-toolbelt/out/Function/Curry").Curry<(type: string, resource: KubernetesResource) => string>;
+export declare const getLabel: import("ts-toolbelt/out/Function/Curry").Curry<(key: string, resource: KubernetesResource) => string>;
+export declare const getSubdomainAnnotation: import("ts-toolbelt/out/Function/Curry").Curry<(subdomain: string, type: string, resource: KubernetesResource) => string>;
+export declare const getDomainAnnotation: import("ts-toolbelt/out/Function/Curry").Curry<(type: string, resource: KubernetesResource) => string>;
+export declare const getAnnotation: import("ts-toolbelt/out/Function/Curry").Curry<(key: string, resource: KubernetesResource) => string>;
+export declare const assignLabels: (value: Record<string, string>) => <R extends KubernetesResource>(resource: R) => R;
+export declare const assignAnnotations: (value: Record<string, string>) => <R extends KubernetesResource>(resource: R) => R;
+export declare function getGlobalNs(): string;
+export declare function createOwnerReference(owner: KubernetesResource, { blockOwnerDeletion, controller, }?: Partial<{
+    blockOwnerDeletion: boolean;
+    controller: boolean;
+}>): OwnerReference;
+export declare const K8S_BINARY_UNITS: readonly ["Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"];
+export declare const K8S_DECIMAL_UNITS: readonly ["m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+export declare function parseQuantity(value: string): Quantity;
+export declare function convertQuantityUnit(targetUnit: QuantityUnit): (source: Quantity) => Quantity;
+export declare function convertQuantityUnit(targetUnit: QuantityUnit, source: Quantity): Quantity;
+export declare function getProjectNs(project: string, cluster: string): string;
+export interface Quantity {
+    value: number;
+    unit: QuantityUnit;
+}
+export type QuantityUnit = (typeof K8S_BINARY_UNITS)[number] | (typeof K8S_DECIMAL_UNITS)[number];

package/core/utils/local-storage-constants.d.ts

@@ -0,0 +1 @@
+export declare const LOCAL_STORAGE_KEY_THEME_MODE = "theme-mode";

package/core/utils/node.d.ts

@@ -0,0 +1,8 @@
+import { Node } from '../../core/public-api';
+/**
+ * 从 underlord 节点 utils 中抽离出来，作为通用的内部IP、内部IPv6、hostname 获取方式
+ */
+export declare function getPrivateIPv4(node: Node): string;
+export declare function getPrivateIPv6(node: Node): string;
+export declare function getPrivateIP(node: Node): string;
+export declare function getHostname(node: Node): string;

package/core/utils/observable.d.ts

@@ -0,0 +1,5 @@
+import { DestroyRef } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare const createPollObservable: <TResult>(fetch$: Observable<TResult>, pollIn: number | Observable<number>) => Observable<TResult>;
+export declare function onDestroy(destroyRef?: DestroyRef): Observable<void>;
+export declare const tapSkip: <T>(nEmissions: number, callback: (args: T) => void) => (source$: Observable<T>) => Observable<T>;

package/core/utils/operators.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DestroyRef } from '@angular/core';
+import { Observable, SchedulerLike, TimestampProvider } from 'rxjs';
+export type PublishRefConfig<T> = number | (import('rxjs/internal/operators/share').ShareConfig<T> & {
+    bufferSize?: number;
+    windowTime?: number;
+    timestampProvider?: TimestampProvider;
+});
+export declare const publishRef: <T>(bufferSizeOrConfig?: PublishRefConfig<T>) => import("rxjs").MonoTypeOperatorFunction<T>;
+export declare const shareUntil: <T>(destroy$: Observable<unknown>, bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike) => import("rxjs").UnaryFunction<Observable<T>, Observable<T>>;
+export declare const skipError: <T, R = never>(mapped?: R | Observable<R>, debug?: boolean) => import("rxjs").OperatorFunction<T, T | R>;
+export declare const catchPromise: <T, R = never>(promise: Promise<T>, mapped?: R | Observable<R>) => Observable<T | R>;
+declare const NULL: unique symbol;
+export declare const startWithCondition: <T>(condition: boolean, value: T) => (source: Observable<T>) => Observable<typeof NULL | T>;
+export declare const shareUntilDestroyed: <T>(destroyRef?: DestroyRef, bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike) => import("rxjs").UnaryFunction<Observable<T>, Observable<T>>;
+export {};

package/core/utils/public-api.d.ts

@@ -0,0 +1,22 @@
+export * from './browser';
+export * from './cache-store';
+export * from './color-helpers';
+export * from './common';
+export * from './create-recursive-filter';
+export * from './cron-util';
+export * from './decorators';
+export * from './k8s-util';
+export * from './observable';
+export * from './operators';
+export * from './request-pool';
+export * from './tree';
+export * from './with-load-state';
+export * from './workspace';
+export * from './unit';
+export * from './yaml';
+export * from './version';
+export * from './resources';
+export * from './local-storage-constants';
+export * from './format-number';
+export * from './node';
+export * from './sort-fn';

package/core/utils/request-pool.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+export declare class RequestPool {
+    private readonly maxParallel;
+    private readonly runnerQueue;
+    private runningCount;
+    constructor({ maxParallel }: {
+        maxParallel: number;
+    });
+    queue<T>(request: Observable<T>): Observable<T>;
+    private flushQueue;
+}
+export declare function maxParallelByHttpVersion(http_2?: number, http_1?: number): number;

package/core/utils/resources.d.ts

@@ -0,0 +1,19 @@
+import { ResourceControl } from '../../form/validators/resource-limit';
+export declare const RESOURCE_MAC_TYPES: readonly ["cpu", "memory"];
+export declare const RESOURCE_REQUIREMENT_KEYS: readonly ["requests", "limits"];
+export type ResourceMacKey = (typeof RESOURCE_MAC_TYPES)[number];
+export type ResourceMacs = Record<ResourceMacKey, string>;
+export type ResourceMacFormModal = Record<ResourceMacKey, ResourceControl>;
+export type ResourceRequirementKey = (typeof RESOURCE_REQUIREMENT_KEYS)[number];
+export type ResourceRequirementStrict = Record<ResourceRequirementKey, ResourceMacs>;
+export type ResourceRequirementFormModal = Record<ResourceRequirementKey, ResourceMacFormModal>;
+export declare function getResourceViewModel(data: string, type: 'cpu' | 'memory', preferEmptyOrC?: boolean): ResourceControl;
+export declare const resourceUnits: {
+    cpu: {
+        value: string;
+        label: string;
+    }[];
+    memory: string[];
+};
+export declare function getResourceValue(data: ResourceControl | string): string;
+export declare function transferResource(resource: ResourceMacFormModal): ResourceMacs;

package/core/utils/sort-fn.d.ts

@@ -0,0 +1,2 @@
+import { KubernetesResource } from '../types/k8s/core';
+export declare function sortByCreationTimestamp<T extends KubernetesResource>(list: T[]): T[];

package/core/utils/tree.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+export declare const reduceTrees: (subtreeKey: string) => <T extends Tree, R>(fn: TreeReducer<T, R>) => (seed: R) => (trees: T[]) => R;
+export declare const mapTrees: (subtreeKey: string) => <T extends Tree, R extends Tree>(fn: TreeMapper<T, R>) => (trees: T[]) => R[];
+export declare const filterTrees: (subtreeKey: string) => <T extends Tree>(fn: TreeFilter<T>) => (trees: T[]) => T[];
+export declare const findPath: (subtreeKey: string) => <T extends Tree>(fn: TreeFilter<T>) => (trees: T[]) => T[];
+export declare const firstPath: (subtreeKey: string) => <T extends Tree>(trees: T[]) => T[];
+export declare function setNode<T extends Tree>(subtreeKey: string, path: number[], source: T[], target: T): T[];
+export interface Tree {
+    [key: string]: Tree[];
+}
+export type TreeReducer<T extends Tree, R> = (acc: R, currentNode: T, parents: T[], path: number[]) => R;
+export type TreeMapper<T extends Tree, R extends Tree> = (tree: T, parents: T[], path: number[]) => R;
+export type TreeFilter<T extends Tree> = (tree: T, parents: T[], path: number[]) => boolean;

package/core/utils/unit.d.ts

@@ -0,0 +1,20 @@
+export declare const CORE_UNITS: string[];
+export declare const CORE_UNIT_REG: RegExp;
+export declare const toUnitNumM: (coreStr?: string | number) => string;
+export declare const toUnitNum: (coreStr?: string | number) => string;
+export declare const UNITS: string[];
+export declare const UNIT_REG: RegExp;
+export declare const toUnitI: (str?: string | number, negative?: boolean) => string;
+export declare const toUnitMi: (str?: string | number, negative?: boolean) => string;
+export declare const toUnitGi: (str?: string | number, negative?: boolean) => string;
+export declare const addUnitCoreM: (coreStr?: string | number) => string;
+export declare const addUnitMi: (miStr?: string | number) => string;
+export declare const addUnitGi: (giStr?: string | number) => string;
+export declare function getAppropriateMemory(base: number): {
+    value: number;
+    unit: string;
+};
+export declare function formatMemory(mem: string): number;
+export declare function getMemory(base: number, unit: string): number;
+export declare function getCpu(base: number, unit: string): number;
+export declare function formatCPU(cpu: string): number;

package/core/utils/version.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 基于相对严格的版本号规则，规范可以参考https://semver.org/
+ * 但在比较版本号时使用相对宽松的规则，具体可以查看compare-versions库的实现
+ * 自测用例：https://stackblitz.com/edit/typescript-jqszbj
+ */
+import { CompareOperator } from 'compare-versions';
+export { CompareOperator as VersionCompareOperator, compareVersions as compareVersionToNum, satisfies as satisfiesVersion, } from 'compare-versions';
+export interface VersionObject {
+    version: string;
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: Array<number | string>;
+}
+export declare const versionRegex: RegExp;
+/**
+ * 获取有效的版本号，如果符合规范则返回，否则返回null
+ * eg: getValidVersion('v1.2.3') // '1.2.3'
+ */
+export declare const getValidVersion: (version: string) => string;
+/**
+ * 解析版本号，如果符合规范则返回一个包含版本信息的对象
+ */
+export declare const parseVersion: (version: string) => VersionObject;
+/**
+ * 使用给定规则比较两个版本
+ * lt: v1小于v2;  gt: v1大于v2;  lte: v1小于等于v2;  gte: v1大于等于v2;
+ * eg: compareVersion.lt('1.2.3', '9.8.7') // true
+ *     compareVersion.cmp('1.2.3', '9.8.7', '<') // true
+ */
+export declare const compareVersion: {
+    lt: (v1: string, v2: string) => boolean;
+    gt: (v1: string, v2: string) => boolean;
+    eq: (v1: string, v2: string) => boolean;
+    lte: (v1: string, v2: string) => boolean;
+    gte: (v1: string, v2: string) => boolean;
+    cmp: (v1: string, v2: string, operator: CompareOperator) => boolean;
+};
+export declare const compareMinorVersion: (v1: string, v2: string) => 0 | 1 | -1;

package/core/utils/with-load-state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Observable } from 'rxjs';
+export interface WithLoadState<T, E = unknown> {
+    loading: boolean;
+    data: T;
+    error: E;
+}
+export declare function withLoadState<T>(input: Observable<T>, defaultValue?: T): Observable<WithLoadState<T>>;

package/core/utils/workspace.d.ts

@@ -0,0 +1,28 @@
+import { ActivatedRoute, ActivatedRouteSnapshot, ParamMap, Params } from '@angular/router';
+import { WorkspaceParams } from '../types/public-api';
+export type Workspace = Readonly<{
+    project: string;
+    cluster: string;
+    namespace: string;
+}>;
+export interface ResourceIdentifier extends Workspace {
+    name: string;
+}
+export declare function parseWorkspace(workspace: string): Workspace;
+export declare function stringifyWorkspace(workspace: WorkspaceParams, strict?: boolean): string;
+export declare function isValidWorkspace(obj: any): obj is Workspace;
+export declare function parseRID(rid: string): ResourceIdentifier;
+export declare function stringifyRID(rid: ResourceIdentifier): string;
+export declare function stringifyRID(workspace: Workspace, name: string): string;
+export declare function isValidRID(obj: any): obj is ResourceIdentifier;
+export declare function extractWorkspace(params: Params | ParamMap): Readonly<{
+    project: string;
+    cluster: string;
+    namespace: string;
+}>;
+export declare function extractWorkspaceFromRoute(route: ActivatedRoute | ActivatedRouteSnapshot): Readonly<{
+    project: string;
+    cluster: string;
+    namespace: string;
+}>;
+export declare const workspaceToPath: (workspace: Partial<Workspace>) => string;

package/core/utils/yaml.d.ts

@@ -0,0 +1,11 @@
+import { DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions } from 'yaml';
+import { KubernetesResource } from '../types/public-api';
+export { stringify } from 'yaml';
+export declare const parse: <T>(yaml: string, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions) => T;
+export declare const safeParseYaml: <T>(yaml: string, defaultValue?: T, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions) => T;
+export declare const parseAll: <T>(yaml: string) => T[];
+export type YamlFilterItem = string | ((resource: KubernetesResource) => string[]);
+export declare function yamlFilterField<T extends KubernetesResource>(resource: T, filterList: YamlFilterItem[], deepClone?: boolean): T;
+export declare const removeDirtyFieldsBeforeUpdate: <T extends KubernetesResource>(resource: T) => T;
+export declare function prefixFilterRuleFactory(prefix: string, path: string[], includeOrStartsWith?: Extract<keyof string, 'includes' | 'startsWith'>): <T extends KubernetesResource>(resource: T) => string[];
+export declare function emptyObjectRemoveRuleFactory(path: string[]): <T extends KubernetesResource>(resource: T) => string[];

package/custom-columns-setting/component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { StringMap } from '../core/public-api';
+import * as i0 from "@angular/core";
+export declare class TableCustomColumnsComponent implements OnInit {
+    options: string[];
+    ignoreOptions: string[];
+    columns?: string[];
+    marginLeft: string;
+    id: string;
+    columnsChange: EventEmitter<string[]>;
+    storage: StringMap;
+    ngOnInit(): void;
+    selectedChanged(event: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomColumnsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCustomColumnsComponent, "acl-table-column-setting", never, { "options": { "alias": "options"; "required": false; }; "ignoreOptions": { "alias": "ignoreOptions"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "marginLeft": { "alias": "marginLeft"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "columnsChange": "columnsChange"; }, never, never, true, never>;
+}

package/custom-columns-setting/public-api.d.ts

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

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

@@ -0,0 +1,21 @@
+import { AfterViewInit, ElementRef, OnDestroy, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DisabledContainerComponent implements AfterViewInit, OnDestroy {
+    private readonly elementRef;
+    tooltip: string | TemplateRef<unknown>;
+    tooltipPosition: string;
+    tooltipType: string;
+    isAllowed: boolean;
+    isDisabled: boolean;
+    readonly isAllowed$: Observable<boolean>;
+    readonly isDisabled$: Observable<boolean>;
+    readonly tooltip$: Observable<string | TemplateRef<unknown>>;
+    private disabledSubscription;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setButtonStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DisabledContainerComponent, "acl-disabled-container", never, { "tooltip": { "alias": "tooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "isAllowed": { "alias": "isAllowed"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/disabled-container/disabled-container.module.d.ts

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

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

@@ -0,0 +1,8 @@
+/**
+ * [[include:disabled-container/README.md]]
+ * @module disabled-container
+ * @preferred
+ */
+/** imports */
+export * from './disabled-container.component';
+export * from './disabled-container.module';

package/editable-text/component.d.ts

@@ -0,0 +1,24 @@
+import { InputComponent } from '@alauda/ui';
+import { AfterViewChecked, ChangeDetectorRef, ElementRef, EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class EditableTextComponent implements AfterViewChecked {
+    private readonly cdr;
+    textInput: InputComponent;
+    textPlaceholder: ElementRef<HTMLDivElement>;
+    set value(val: string);
+    isAllowed: boolean;
+    textChange: EventEmitter<string>;
+    editMode: boolean;
+    inputEl: HTMLInputElement;
+    inputHeight$$: BehaviorSubject<string>;
+    focused: boolean;
+    textModel: string;
+    constructor(cdr: ChangeDetectorRef);
+    modelChange(text: string): void;
+    edit(): void;
+    blur(): void;
+    ngAfterViewChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditableTextComponent, "acl-editable-text", never, { "value": { "alias": "value"; "required": false; }; "isAllowed": { "alias": "isAllowed"; "required": false; }; }, { "textChange": "textChange"; }, never, never, false, never>;
+}

package/editable-text/module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component";
+import * as i2 from "@angular/common";
+import * as i3 from "@alauda/ui";
+import * as i4 from "@angular/forms";
+import * as i5 from "../disabled-container/disabled-container.module";
+export declare class EditableTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EditableTextModule, [typeof i1.EditableTextComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.ButtonModule, typeof i3.InputModule, typeof i4.FormsModule, typeof i5.DisabledContainerModule], [typeof i1.EditableTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EditableTextModule>;
+}

package/editable-text/public-api.d.ts

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

package/effect-directive/coerce-number.directive.d.ts

@@ -0,0 +1,8 @@
+import { DefaultValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class CoerceNumberDirective extends DefaultValueAccessor {
+    aclCoerceNumberEnabled: boolean | '';
+    _handleInput(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoerceNumberDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoerceNumberDirective, "input[formControlName][aclCoerceNumber],input[ngModel][aclCoerceNumber],input[formControl][aclCoerceNumber]", never, { "aclCoerceNumberEnabled": { "alias": "aclCoerceNumber"; "required": false; }; }, {}, never, never, true, never>;
+}

package/effect-directive/e2e-attribute-binding.directive.d.ts

@@ -0,0 +1,10 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class E2eAttributeBindingDirective implements AfterViewInit {
+    private readonly el;
+    constructor(el: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    setDataTestId(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<E2eAttributeBindingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<E2eAttributeBindingDirective, "[click],[routerLink],a[href],[auiTooltip],[auiDropdown]", never, {}, {}, never, never, true, never>;
+}

package/effect-directive/event.directive.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class PreventDirective {
+    prevent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventDirective, "[prevent]", never, { "prevent": { "alias": "prevent"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class StopDirective {
+    stop: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StopDirective, "[stop]", never, { "stop": { "alias": "stop"; "required": false; }; }, {}, never, never, true, never>;
+}