@k8slens/extensions 6.1.9 → 6.2.0-git.19aeda0241.0

package/dist/src/common/app-event-bus/app-event-bus.injectable.d.ts

@@ -1,2 +1,4 @@
-declare const appEventBusInjectable: import("@ogre-tools/injectable").Injectable<import("../event-emitter").EventEmitter<[import("./event-bus").AppEvent]>, unknown, void>;
+import { EventEmitter } from "../event-emitter";
+import type { AppEvent } from "./event-bus";
+declare const appEventBusInjectable: import("@ogre-tools/injectable").Injectable<EventEmitter<[AppEvent]>, unknown, void>;
 export default appEventBusInjectable;

package/dist/src/common/app-event-bus/emit-event.injectable.d.ts

@@ -1,2 +1,4 @@
-declare const emitEventInjectable: import("@ogre-tools/injectable").Injectable<(data_0: import("./event-bus").AppEvent) => void, unknown, void>;
-export default emitEventInjectable;
+import type { AppEvent } from "./event-bus";
+export declare type EmitAppEvent = (event: AppEvent) => void;
+declare const emitAppEventInjectable: import("@ogre-tools/injectable").Injectable<EmitAppEvent, unknown, void>;
+export default emitAppEventInjectable;

package/dist/src/common/app-event-bus/event-bus.d.ts

@@ -2,11 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { EventEmitter } from "../event-emitter";
+/**
+ * Data for telemetry
+ */
 export interface AppEvent {
     name: string;
     action: string;
     destination?: string;
     params?: Record<string, any>;
 }
-export declare const appEventBus: EventEmitter<[AppEvent]>;

package/dist/src/common/app-paths/app-paths-channel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { AppPaths } from "./app-path-injection-token";
+import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
+export declare type AppPathsChannel = RequestChannel<void, AppPaths>;
+export declare const appPathsChannel: AppPathsChannel;

package/dist/src/common/catalog/filtered-categories.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const filteredCategoriesInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<import("./catalog-entity").CatalogCategory[]>, unknown, void>;
+export default filteredCategoriesInjectable;

package/dist/src/common/cluster/cluster.d.ts

@@ -15,6 +15,7 @@ import type { CanI } from "./authorization-review.injectable";
 import type { ListNamespaces } from "./list-namespaces.injectable";
 import type { Logger } from "../logger";
 import type { BroadcastMessage } from "../ipc/broadcast-message.injectable";
+import type { LoadConfigfromFile } from "../kube-helpers/load-config-from-file.injectable";
 export interface ClusterDependencies {
     readonly directoryForKubeConfigs: string;
     readonly logger: Logger;
@@ -26,6 +27,7 @@ export interface ClusterDependencies {
     createListNamespaces: (config: KubeConfig) => ListNamespaces;
     createVersionDetector: (cluster: Cluster) => VersionDetector;
     broadcastMessage: BroadcastMessage;
+    loadConfigfromFile: LoadConfigfromFile;
 }
 /**
  * Cluster
@@ -189,7 +191,7 @@ export declare class Cluster implements ClusterModel, ClusterState {
      * @internal
      */
     get defaultNamespace(): string | undefined;
-    constructor(dependencies: ClusterDependencies, model: ClusterModel, configData: ClusterConfigData);
+    constructor(dependencies: ClusterDependencies, { id, ...model }: ClusterModel, configData: ClusterConfigData);
     /**
      * Update cluster data model
      *

package/dist/src/common/cluster-store/cluster-store.d.ts

@@ -7,15 +7,17 @@ import { Cluster } from "../cluster/cluster";
 import type { ClusterModel, ClusterId } from "../cluster-types";
 import type { CreateCluster } from "../cluster/create-cluster-injection-token";
 import type { ReadClusterConfigSync } from "./read-cluster-config.injectable";
+import type { EmitAppEvent } from "../app-event-bus/emit-event.injectable";
 export interface ClusterStoreModel {
     clusters?: ClusterModel[];
 }
 interface Dependencies {
     createCluster: CreateCluster;
     readClusterConfigSync: ReadClusterConfigSync;
+    emitAppEvent: EmitAppEvent;
 }
 export declare class ClusterStore extends BaseStore<ClusterStoreModel> {
-    private dependencies;
+    private readonly dependencies;
     readonly displayName = "ClusterStore";
     clusters: import("mobx").ObservableMap<string, Cluster>;
     protected disposer: import("../utils").ExtendableDisposer;

package/dist/src/common/cluster-store/get-by-id.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { ClusterId } from "../cluster-types";
+import type { Cluster } from "../cluster/cluster";
+export declare type GetClusterById = (id: ClusterId) => Cluster | undefined;
+declare const getClusterByIdInjectable: import("@ogre-tools/injectable").Injectable<GetClusterById, unknown, void>;
+export default getClusterByIdInjectable;

package/dist/src/common/cluster-types.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
+import Joi from "joi";
 /**
  * JSON serializable metadata type
  */
@@ -22,6 +23,15 @@ export declare type ClusterId = string;
  * The fields that are used for updating a cluster instance
  */
 export declare type UpdateClusterModel = Omit<ClusterModel, "id">;
+/**
+ * A type validator for `UpdateClusterModel` so that only expected types are present
+ */
+export declare const updateClusterModelChecker: Joi.ObjectSchema<UpdateClusterModel>;
+/**
+ * A type validator for just the `id` fields of `ClusterModel`. The rest is
+ * covered by `updateClusterModelChecker`
+ */
+export declare const clusterModelIdChecker: Joi.ObjectSchema<Pick<ClusterModel, "id">>;
 /**
  * The model for passing cluster data around, including to disk
  */

package/dist/src/common/event-emitter.d.ts

@@ -12,6 +12,6 @@ export declare class EventEmitter<D extends [...any[]]> {
     addListener(callback: Callback<D>, options?: Options): void;
     removeListener(callback: Callback<D>): void;
     removeAllListeners(): void;
-    emit: (...data: D) => void;
+    emit(...data: D): void;
 }
 export {};

package/dist/src/common/fetch/download-binary.injectable.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import type { AsyncResult } from "../utils/async-result";
+export interface DownloadBinaryOptions {
+    signal?: AbortSignal | null | undefined;
+}
+export declare type DownloadBinary = (url: string, opts?: DownloadBinaryOptions) => Promise<AsyncResult<Buffer, string>>;
+declare const downloadBinaryInjectable: import("@ogre-tools/injectable").Injectable<DownloadBinary, unknown, void>;
+export default downloadBinaryInjectable;

package/dist/src/common/fetch/download-json.injectable.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue } from "type-fest";
+import type { AsyncResult } from "../utils/async-result";
+export interface DownloadJsonOptions {
+    signal?: AbortSignal | null | undefined;
+}
+export declare type DownloadJson = (url: string, opts?: DownloadJsonOptions) => Promise<AsyncResult<JsonValue, string>>;
+declare const downloadJsonInjectable: import("@ogre-tools/injectable").Injectable<DownloadJson, unknown, void>;
+export default downloadJsonInjectable;

package/dist/src/common/fetch/fetch.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./fetch.injectable").Fetch, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./fetch.injectable").Fetch, void>;
+};
+export default _default;

package/dist/src/common/fetch/fetch.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { RequestInit, Response } from "node-fetch";
+export declare type Fetch = (url: string, init?: RequestInit) => Promise<Response>;
+declare const fetchInjectable: import("@ogre-tools/injectable").Injectable<Fetch, unknown, void>;
+export default fetchInjectable;

package/dist/src/common/fetch/timeout-controller.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+/**
+ * Creates an AbortController with an associated timeout
+ * @param timeout The number of milliseconds before this controller will auto abort
+ */
+export declare function withTimeout(timeout: number): AbortController;

package/dist/src/common/front-end-routing/app-navigation-channel.d.ts

@@ -0,0 +1,3 @@
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+export declare type AppNavigationChannel = MessageChannel<string>;
+export declare const appNavigationChannel: AppNavigationChannel;

package/dist/src/common/front-end-routing/cluster-frame-navigation-channel.d.ts

@@ -0,0 +1,3 @@
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+export declare type ClusterFrameNavigationChannel = MessageChannel<string>;
+export declare const clusterFrameNavigationChannel: ClusterFrameNavigationChannel;

package/dist/src/common/front-end-routing/routes/cluster/config/leases/leases-route.injectable.d.ts

@@ -0,0 +1,6 @@
+declare const leasesRouteInjectable: import("@ogre-tools/injectable").Injectable<{
+    path: string;
+    clusterFrame: boolean;
+    isEnabled: import("mobx").IComputedValue<boolean>;
+}, import("../../../../front-end-route-injection-token").Route<unknown>, void>;
+export default leasesRouteInjectable;

package/dist/src/common/front-end-routing/routes/cluster/config/leases/navigate-to-leases.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const navigateToLeasesInjectable: import("@ogre-tools/injectable").Injectable<() => void, unknown, void>;
+export default navigateToLeasesInjectable;

package/dist/src/common/front-end-routing/routes/cluster/config/runtime-classes/navigate-to-runtime-classes.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const navigateToRuntimeClassesInjectable: import("@ogre-tools/injectable").Injectable<() => void, unknown, void>;
+export default navigateToRuntimeClassesInjectable;

package/dist/src/common/front-end-routing/routes/cluster/config/runtime-classes/runtime-classes-route.injectable.d.ts

@@ -0,0 +1,6 @@
+declare const runtimeClassesRouteInjectable: import("@ogre-tools/injectable").Injectable<{
+    path: string;
+    clusterFrame: boolean;
+    isEnabled: import("mobx").IComputedValue<boolean>;
+}, import("../../../../front-end-route-injection-token").Route<unknown>, void>;
+export default runtimeClassesRouteInjectable;

package/dist/src/common/fs/access-path.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./access-path.injectable").AccessPath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./access-path.injectable").AccessPath, void>;
+};
+export default _default;

package/dist/src/common/fs/access-path.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type AccessPath = (path: string, mode?: number) => Promise<boolean>;
+declare const accessPathInjectable: import("@ogre-tools/injectable").Injectable<AccessPath, unknown, void>;
+export default accessPathInjectable;

package/dist/src/common/fs/copy.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./copy.injectable").Copy, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./copy.injectable").Copy, void>;
+};
+export default _default;

package/dist/src/common/fs/copy.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { CopyOptions } from "fs-extra";
+export declare type Copy = (src: string, dest: string, options?: CopyOptions | undefined) => Promise<void>;
+declare const copyInjectable: import("@ogre-tools/injectable").Injectable<Copy, unknown, void>;
+export default copyInjectable;

package/dist/src/common/fs/create-read-file-stream.injectable.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ReadStream } from "fs";
+export interface CreateReadStreamOptions {
+    mode?: number;
+    end?: number | undefined;
+    flags?: string | undefined;
+    encoding?: BufferEncoding | undefined;
+    autoClose?: boolean | undefined;
+    /**
+     * @default false
+     */
+    emitClose?: boolean | undefined;
+    start?: number | undefined;
+    highWaterMark?: number | undefined;
+}
+export declare type CreateReadFileStream = (filePath: string, options?: CreateReadStreamOptions) => ReadStream;
+declare const createReadFileStreamInjectable: import("@ogre-tools/injectable").Injectable<CreateReadFileStream, unknown, void>;
+export default createReadFileStreamInjectable;

package/dist/src/common/fs/delete-file.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./delete-file.injectable").DeleteFile, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./delete-file.injectable").DeleteFile, void>;
+};
+export default _default;

package/dist/src/common/fs/delete-file.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type DeleteFile = (filePath: string) => Promise<void>;
+declare const deleteFileInjectable: import("@ogre-tools/injectable").Injectable<DeleteFile, unknown, void>;
+export default deleteFileInjectable;

package/dist/src/common/fs/ensure-dir.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./ensure-dir.injectable").EnsureDirectory, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./ensure-dir.injectable").EnsureDirectory, void>;
+};
+export default _default;

package/dist/src/common/fs/ensure-dir.injectable.d.ts

@@ -1,2 +1,3 @@
-declare const ensureDirInjectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").ensureDir, unknown, void>;
+export declare type EnsureDirectory = (dirPath: string) => Promise<void>;
+declare const ensureDirInjectable: import("@ogre-tools/injectable").Injectable<EnsureDirectory, unknown, void>;
 export default ensureDirInjectable;

package/dist/src/common/fs/exec-file.injectable.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="node" />
-import type { ExecFileOptions } from "child_process";
-export declare type ExecFile = (filePath: string, args: string[], options: ExecFileOptions) => Promise<string>;
+import type { ExecFileException, ExecFileOptions } from "child_process";
+import type { AsyncResult } from "../utils/async-result";
+export interface ExecFile {
+    (filePath: string, args: string[], options?: ExecFileOptions): Promise<AsyncResult<string, ExecFileException & {
+        stderr: string;
+    }>>;
+}
 declare const execFileInjectable: import("@ogre-tools/injectable").Injectable<ExecFile, unknown, void>;
 export default execFileInjectable;

package/dist/src/common/fs/extract-tar.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./extract-tar.injectable").ExtractTar, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./extract-tar.injectable").ExtractTar, void>;
+};
+export default _default;

package/dist/src/common/fs/extract-tar.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractOptions } from "tar";
+export declare type ExtractTar = (filePath: string, opts?: ExtractOptions) => Promise<void>;
+declare const extractTarInjectable: import("@ogre-tools/injectable").Injectable<ExtractTar, unknown, void>;
+export default extractTarInjectable;

package/dist/src/common/fs/lstat.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./lstat.injectable").LStat, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./lstat.injectable").LStat, void>;
+};
+export default _default;

package/dist/src/common/fs/lstat.injectable.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { Stats } from "fs";
+export declare type LStat = (path: string) => Promise<Stats>;
+declare const lstatInjectable: import("@ogre-tools/injectable").Injectable<LStat, unknown, void>;
+export default lstatInjectable;

package/dist/src/common/fs/move.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./move.injectable").Move, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./move.injectable").Move, void>;
+};
+export default _default;

package/dist/src/common/fs/move.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { MoveOptions } from "fs-extra";
+export declare type Move = (src: string, dest: string, options?: MoveOptions) => Promise<void>;
+declare const moveInjectable: import("@ogre-tools/injectable").Injectable<Move, unknown, void>;
+export default moveInjectable;

package/dist/src/common/fs/path-exists.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./path-exists.injectable").PathExists, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./path-exists.injectable").PathExists, void>;
+};
+export default _default;

package/dist/src/common/fs/read-directory.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./read-directory.injectable").ReadDirectory, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./read-directory.injectable").ReadDirectory, void>;
+};
+export default _default;

package/dist/src/common/fs/read-directory.injectable.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Dirent } from "fs";
+export interface ReadDirectory {
+    (path: string, options: "buffer" | {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+    }): Promise<Buffer[]>;
+    (path: string, options?: {
+        encoding: BufferEncoding | string | null;
+        withFileTypes?: false | undefined;
+    } | BufferEncoding | string | null): Promise<string[]>;
+    (path: string, options?: {
+        encoding?: BufferEncoding | string | null | undefined;
+        withFileTypes?: false | undefined;
+    }): Promise<string[] | Buffer[]>;
+    (path: string, options: {
+        encoding?: BufferEncoding | string | null | undefined;
+        withFileTypes: true;
+    }): Promise<Dirent[]>;
+}
+declare const readDirectoryInjectable: import("@ogre-tools/injectable").Injectable<ReadDirectory, unknown, void>;
+export default readDirectoryInjectable;

package/dist/src/common/fs/read-file.injectable.d.ts

@@ -1,2 +1,3 @@
-declare const readFileInjectable: import("@ogre-tools/injectable").Injectable<(filePath: string) => Promise<string>, unknown, void>;
+export declare type ReadFile = (filePath: string) => Promise<string>;
+declare const readFileInjectable: import("@ogre-tools/injectable").Injectable<ReadFile, unknown, void>;
 export default readFileInjectable;

package/dist/src/common/fs/remove-path.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./remove-path.injectable").RemovePath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./remove-path.injectable").RemovePath, void>;
+};
+export default _default;

package/dist/src/common/fs/remove-path.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RemovePath = (path: string) => Promise<void>;
+declare const removePathInjectable: import("@ogre-tools/injectable").Injectable<RemovePath, unknown, void>;
+export default removePathInjectable;

package/dist/src/common/fs/stat/stat.global-override-for-injectable.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    injectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").stat, unknown, void>;
-    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<typeof import("fs-extra").stat, void>;
+    injectable: import("@ogre-tools/injectable").Injectable<import("./stat.injectable").Stat, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./stat.injectable").Stat, void>;
 };
 export default _default;

package/dist/src/common/fs/stat/stat.injectable.d.ts

@@ -1,2 +1,5 @@
-declare const statInjectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").stat, unknown, void>;
+/// <reference types="node" />
+import type { Stats } from "fs";
+export declare type Stat = (path: string) => Promise<Stats>;
+declare const statInjectable: import("@ogre-tools/injectable").Injectable<Stat, unknown, void>;
 export default statInjectable;

package/dist/src/common/fs/watch/watch.injectable.d.ts

@@ -1,4 +1,122 @@
-import type { FSWatcher, WatchOptions } from "chokidar";
-export declare type Watch = (path: string, options?: WatchOptions) => FSWatcher;
+/// <reference types="node" />
+import type { Stats } from "fs";
+import type TypedEventEmitter from "typed-emitter";
+import type { SingleOrMany } from "../../utils";
+export interface AlwaysStatWatcherEvents {
+    add: (path: string, stats: Stats) => void;
+    addDir: (path: string, stats: Stats) => void;
+    change: (path: string, stats: Stats) => void;
+}
+export interface MaybeStatWatcherEvents {
+    add: (path: string, stats?: Stats) => void;
+    addDir: (path: string, stats?: Stats) => void;
+    change: (path: string, stats?: Stats) => void;
+}
+export declare type WatcherEvents<AlwaysStat extends boolean> = BaseWatcherEvents & (AlwaysStat extends true ? AlwaysStatWatcherEvents : MaybeStatWatcherEvents);
+export interface BaseWatcherEvents {
+    error: (error: Error) => void;
+    ready: () => void;
+    unlink: (path: string) => void;
+    unlinkDir: (path: string) => void;
+}
+export interface Watcher<AlwaysStat extends boolean> extends TypedEventEmitter<WatcherEvents<AlwaysStat>> {
+    close: () => Promise<void>;
+}
+export declare type WatcherOptions<AlwaysStat extends boolean> = {
+    /**
+     * Indicates whether the process should continue to run as long as files are being watched. If
+     * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+     * even if the process continues to run.
+     */
+    persistent?: boolean;
+    /**
+     * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+     * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+     * with two arguments is provided, it gets called twice per path - once with a single argument
+     * (the path), second time with two arguments (the path and the
+     * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+     */
+    ignored?: SingleOrMany<string | RegExp | ((path: string) => boolean)>;
+    /**
+     * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+     * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+     */
+    ignoreInitial?: boolean;
+    /**
+     * When `false`, only the symlinks themselves will be watched for changes instead of following
+     * the link references and bubbling events through the link's path.
+     */
+    followSymlinks?: boolean;
+    /**
+     * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+     * be relative to this.
+     */
+    cwd?: string;
+    /**
+     *  If set to true then the strings passed to .watch() and .add() are treated as literal path
+     *  names, even if they look like globs. Default: false.
+     */
+    disableGlobbing?: boolean;
+    /**
+     * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+     * utilization, consider setting this to `false`. It is typically necessary to **set this to
+     * `true` to successfully watch files over a network**, and it may be necessary to successfully
+     * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+     * the `useFsEvents` default.
+     */
+    usePolling?: boolean;
+    /**
+     * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+     * and `fsevents` is available this supercedes the `usePolling` setting. When set to `false` on
+     * OS X, `usePolling: true` becomes the default.
+     */
+    useFsEvents?: boolean;
+    /**
+     * If set, limits how many levels of subdirectories will be traversed.
+     */
+    depth?: number;
+    /**
+     * Interval of file system polling.
+     */
+    interval?: number;
+    /**
+     * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+     * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+     */
+    binaryInterval?: number;
+    /**
+     *  Indicates whether to watch files that don't have read permissions if possible. If watching
+     *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+     *  silently.
+     */
+    ignorePermissionErrors?: boolean;
+    /**
+     * `true` if `useFsEvents` and `usePolling` are `false`). Automatically filters out artifacts
+     * that occur when using editors that use "atomic writes" instead of writing directly to the
+     * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
+     * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
+     * you can override it by setting `atomic` to a custom value, in milliseconds.
+     */
+    atomic?: boolean | number;
+    /**
+     * can be set to an object in order to adjust timing params:
+     */
+    awaitWriteFinish?: AwaitWriteFinishOptions | boolean;
+} & (AlwaysStat extends true ? {
+    alwaysStat: true;
+} : {
+    alwaysStat?: false;
+});
+export interface AwaitWriteFinishOptions {
+    /**
+     * Amount of time in milliseconds for a file size to remain constant before emitting its event.
+     */
+    stabilityThreshold?: number;
+    /**
+     * File size polling interval.
+     */
+    pollInterval?: number;
+}
+export declare type Watch = <AlwaysStat extends boolean = false>(path: string, options?: WatcherOptions<AlwaysStat>) => Watcher<AlwaysStat>;
 declare const watchInjectable: import("@ogre-tools/injectable").Injectable<Watch, unknown, void>;
 export default watchInjectable;

package/dist/src/common/fs/write-file.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<import("./write-file.injectable").WriteFile, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./write-file.injectable").WriteFile, void>;
+};
+export default _default;

package/dist/src/common/fs/write-file.injectable.d.ts

@@ -1,3 +1,5 @@
 /// <reference types="node" />
-declare const writeFileInjectable: import("@ogre-tools/injectable").Injectable<(filePath: string, content: string | Buffer) => Promise<void>, unknown, void>;
+import type { WriteFileOptions } from "fs-extra";
+export declare type WriteFile = (filePath: string, content: string | Buffer, opts?: WriteFileOptions) => Promise<void>;
+declare const writeFileInjectable: import("@ogre-tools/injectable").Injectable<WriteFile, unknown, void>;
 export default writeFileInjectable;

package/dist/src/common/helm/add-helm-repository-channel.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { HelmRepo } from "./helm-repo";
+import type { AsyncResult } from "../utils/async-result";
+import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
+export declare type AddHelmRepositoryChannel = RequestChannel<HelmRepo, AsyncResult<void, string>>;
+export declare const addHelmRepositoryChannel: AddHelmRepositoryChannel;

package/dist/src/common/helm/get-active-helm-repositories-channel.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { HelmRepo } from "./helm-repo";
+import type { AsyncResult } from "../utils/async-result";
+import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
+export declare type GetActiveHelmRepositoriesChannel = RequestChannel<void, AsyncResult<HelmRepo[]>>;
+export declare const getActiveHelmRepositoriesChannel: GetActiveHelmRepositoriesChannel;