@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/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/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/utils/cache-store.d.ts

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

package/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/utils/common.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Sort } from '@alauda/ui';
+import { UnionToIntersection } from 'ts-essentials';
+import { Callback, Keys, KubernetesResource, Nullable, Readonlyable } from '../types';
+/**
+ * 保证任何语言环境下将数字转换为非科学计数法且不带千位分隔符并保留三位有效小数的数字字符串
+ *
+ * @example
+ * numToStr(123123.3456) // "123123.346"
+ * numToStr(123.12) // "123.12"
+ */
+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 | Nullable<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: Array<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 buildImageAddress: (url: string, tagOrDigest: string) => string;
+export declare const parseImageAddress: (addr: string) => {
+    digest?: string;
+    tag?: string;
+    url: string;
+};
+export declare const clearWindowsXtermTools: () => void;
+export declare const buildUrl: (baseUri: string, params?: Record<string, string | boolean>) => string;

package/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/utils/decorators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DebounceSettings, DebouncedFunc } from 'lodash-es';
+import { ObservableType } from '../types';
+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/utils/disabled-state.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+export type DisabledResult = {
+    disabled: boolean;
+    tooltip?: string;
+} | boolean;
+export type QueryDisabledFunc = () => DisabledResult | Observable<DisabledResult>;
+/**
+ * @description 获取同步状态
+ */
+export declare function getDisabledState(...judgeFns: QueryDisabledFunc[]): {
+    disabled: boolean;
+    tooltip?: string;
+};
+/**
+ * @description 获取异步状态
+ */
+export declare function getDisabledState$(...judgeFns: QueryDisabledFunc[]): Observable<{
+    disabled: boolean;
+    tooltip?: string;
+}>;

package/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/utils/index.d.ts

@@ -0,0 +1,23 @@
+export * from './observable';
+export * from './operators';
+export * from './decorators';
+export * from './browser';
+export * from './cache-store';
+export * from './color-helpers';
+export * from './common';
+export * from './cron-util';
+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';
+export * from './workload';
+export * from './router';
+export * from './disabled-state';

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

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

package/utils/node.d.ts

@@ -0,0 +1,8 @@
+import { Node } from '../types';
+/**
+ * 从 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/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/utils/operators.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DestroyRef } from '@angular/core';
+import { MonoTypeOperatorFunction, 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>) => 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 declare const safePluck: (...properties: Array<string | number>) => import("rxjs").UnaryFunction<Observable<unknown>, Observable<any>>;
+export declare function switchTap<T, R>(next: (x: T) => Observable<R>): MonoTypeOperatorFunction<T>;
+export declare function switchTap<R>(observable: Observable<R>): MonoTypeOperatorFunction<R>;
+export {};

package/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/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/utils/router.d.ts

@@ -0,0 +1,3 @@
+import { ActivatedRouteSnapshot } from '@angular/router';
+export declare function getParamFromParent(key: string, snapshot: ActivatedRouteSnapshot): string;
+export declare function initParamFromParent$(key: string): import("rxjs").Observable<string>;

package/utils/sort-fn.d.ts

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

package/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/utils/unit.d.ts

@@ -0,0 +1,21 @@
+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 const parseValueAndUnit: (str: string) => 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/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) => 1 | 0 | -1;

package/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/utils/workload.d.ts

@@ -0,0 +1,66 @@
+import { GenericStatusColor, GenericStatusIcon } from '../constants/status-icons';
+import { DaemonSet, Deployment, Job, Pod, StatefulSet } from '../types';
+export type Workload = Deployment | StatefulSet | DaemonSet;
+export declare enum WorkloadKind {
+    Deployment = "Deployment",
+    StatefulSet = "StatefulSet",
+    DaemonSet = "DaemonSet"
+}
+export declare enum JobStatusEnum {
+    EXECUTING = "executing",
+    EXECUTE_SUCCEEDED = "execute_succeeded",
+    EXECUTE_FAILED = "execute_failed",
+    UNKNOWN = "unknown"
+}
+export declare const JobStatusColorMapper: {
+    executing: GenericStatusColor;
+    execute_succeeded: GenericStatusColor;
+    execute_failed: GenericStatusColor;
+    unknown: GenericStatusColor;
+};
+export declare const JobStatusIconMapper: {
+    executing: GenericStatusIcon;
+    execute_succeeded: GenericStatusIcon;
+    execute_failed: GenericStatusIcon;
+    unknown: GenericStatusIcon;
+};
+export declare enum WorkloadStatusEnum {
+    running = "running",
+    stopped = "stopped",
+    pending = "pending",
+    killed = "killed"
+}
+export interface GenericWorkloadStatus {
+    status?: WorkloadStatusEnum;
+    desired?: number;
+    current?: number;
+}
+export interface WorkloadStatus extends GenericWorkloadStatus {
+    name?: string;
+    group?: string;
+    kind?: string;
+    messages?: Array<{
+        message: string;
+        reason?: string;
+    }>;
+}
+export declare const WorkloadStatusColorMapper: {
+    running: GenericStatusColor;
+    pending: GenericStatusColor;
+    stopped: GenericStatusColor;
+    killed: GenericStatusColor;
+};
+export declare const WorkloadStatusIconMapper: {
+    running: GenericStatusIcon;
+    pending: GenericStatusIcon;
+    stopped: GenericStatusIcon;
+    killed: GenericStatusIcon;
+};
+export declare const STATUS = "status";
+export declare function parseDeploymentStatus(res: Deployment): WorkloadStatusEnum.running | WorkloadStatusEnum.stopped | WorkloadStatusEnum.pending;
+export declare function parseDaemonSetStatus(res: DaemonSet): WorkloadStatusEnum.running | WorkloadStatusEnum.stopped | WorkloadStatusEnum.pending;
+export declare function parseStatefulSetStatus(res: StatefulSet): WorkloadStatusEnum.running | WorkloadStatusEnum.stopped | WorkloadStatusEnum.pending;
+export declare function parseToWorkloadStatus(data: Deployment): GenericWorkloadStatus;
+export declare function getJobStatus(data: Job): JobStatusEnum;
+export declare function getWorkloadStatus(status: GenericWorkloadStatus): WorkloadStatusEnum;
+export declare function getPodIPs(pod: Pod): string[];

package/utils/workspace.d.ts

@@ -0,0 +1,28 @@
+import { ActivatedRoute, ActivatedRouteSnapshot, ParamMap, Params } from '@angular/router';
+import { WorkspaceParams } from '../types';
+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/utils/yaml.d.ts

@@ -0,0 +1,11 @@
+import { DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions } from 'yaml';
+import { KubernetesResource } from '../types';
+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[];