@k8slens/extensions 6.2.1-git.df99b91d58.0 → 6.3.0-alpha.0

package/dist/src/common/front-end-routing/navigate-to-route-injection-token.d.ts

@@ -1,20 +1,20 @@
 import type { Route } from "./front-end-route-injection-token";
-declare type InferParametersFrom<TRoute> = TRoute extends Route<infer TParameters> ? TParameters : never;
-declare type RequiredKeys<T> = Exclude<{
+type InferParametersFrom<TRoute> = TRoute extends Route<infer TParameters> ? TParameters : never;
+type RequiredKeys<T> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? K : never;
 }[keyof T], undefined>;
-declare type ObjectContainingNoRequired<T> = T extends void ? never : RequiredKeys<T> extends [] ? any : never;
-declare type ObjectContainsNoRequired<T> = T extends ObjectContainingNoRequired<T> ? true : false;
-declare type Parameters<TParameters> = TParameters extends void ? {} : ObjectContainsNoRequired<TParameters> extends true ? {
+type ObjectContainingNoRequired<T> = T extends void ? never : RequiredKeys<T> extends [] ? any : never;
+type ObjectContainsNoRequired<T> = T extends ObjectContainingNoRequired<T> ? true : false;
+type Parameters<TParameters> = TParameters extends void ? {} : ObjectContainsNoRequired<TParameters> extends true ? {
     parameters?: TParameters;
 } : {
     parameters: TParameters;
 };
-export declare type NavigateToRouteOptions<TRoute> = Parameters<InferParametersFrom<TRoute>> & {
+export type NavigateToRouteOptions<TRoute> = Parameters<InferParametersFrom<TRoute>> & {
     query?: Record<string, string>;
     fragment?: string;
     withoutAffectingBackButton?: boolean;
 };
-export declare type NavigateToRoute = <TRoute extends Route<unknown>>(route: TRoute, options?: NavigateToRouteOptions<TRoute>) => void;
+export type NavigateToRoute = <TRoute extends Route<unknown>>(route: TRoute, options?: NavigateToRouteOptions<TRoute>) => void;
 export declare const navigateToRouteInjectionToken: import("@ogre-tools/injectable").InjectionToken<NavigateToRoute, void>;
 export {};

package/dist/src/common/front-end-routing/navigate-to-url-injection-token.d.ts

@@ -2,5 +2,5 @@ export interface NavigateToUrlOptions {
     withoutAffectingBackButton?: boolean;
     forceRootFrame?: boolean;
 }
-export declare type NavigateToUrl = (url: string, options?: NavigateToUrlOptions) => void;
+export type NavigateToUrl = (url: string, options?: NavigateToUrlOptions) => void;
 export declare const navigateToUrlInjectionToken: import("@ogre-tools/injectable").InjectionToken<NavigateToUrl, void>;

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

@@ -1,4 +1,4 @@
 import type { CatalogPathParameters } from "./catalog-route.injectable";
-export declare type NavigateToCatalog = (parameters?: CatalogPathParameters) => void;
+export type NavigateToCatalog = (parameters?: CatalogPathParameters) => void;
 declare const navigateToCatalogInjectable: import("@ogre-tools/injectable").Injectable<NavigateToCatalog, unknown, void>;
 export default navigateToCatalogInjectable;

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

@@ -1,4 +1,4 @@
 import type { HelmChartsPathParameters } from "./helm-charts-route.injectable";
-export declare type NavigateToHelmCharts = (parameters?: HelmChartsPathParameters) => void;
+export type NavigateToHelmCharts = (parameters?: HelmChartsPathParameters) => void;
 declare const navigateToHelmChartsInjectable: import("@ogre-tools/injectable").Injectable<NavigateToHelmCharts, unknown, void>;
 export default navigateToHelmChartsInjectable;

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

@@ -1,4 +1,4 @@
 import type { HelmReleasesPathParameters } from "./helm-releases-route.injectable";
-export declare type NavigateToHelmReleases = (parameters?: HelmReleasesPathParameters) => void;
+export type NavigateToHelmReleases = (parameters?: HelmReleasesPathParameters) => void;
 declare const navigateToHelmReleasesInjectable: import("@ogre-tools/injectable").Injectable<NavigateToHelmReleases, unknown, void>;
 export default navigateToHelmReleasesInjectable;

package/dist/src/common/front-end-routing/routes/cluster/network/port-forwards/navigate-to-port-forwards.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { PortForwardsPathParameters } from "./port-forwards-route.injectable";
-export declare type NavigateToPortForwards = (parameters?: PortForwardsPathParameters) => void;
+export type NavigateToPortForwards = (parameters?: PortForwardsPathParameters) => void;
 declare const navigateToPortForwardsInjectable: import("@ogre-tools/injectable").Injectable<NavigateToPortForwards, unknown, void>;
 export default navigateToPortForwardsInjectable;

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

@@ -1,3 +1,3 @@
-export declare type NavigateToClusterView = (clusterId: string) => void;
+export type NavigateToClusterView = (clusterId: string) => void;
 declare const navigateToClusterViewInjectable: import("@ogre-tools/injectable").Injectable<NavigateToClusterView, unknown, void>;
 export default navigateToClusterViewInjectable;

package/dist/src/common/front-end-routing/routes/entity-settings/navigate-to-entity-settings.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type NavigateToEntitySettings = (entityId: string, targetTabId?: string) => void;
+export type NavigateToEntitySettings = (entityId: string, targetTabId?: string) => void;
 declare const navigateToEntitySettingsInjectable: import("@ogre-tools/injectable").Injectable<NavigateToEntitySettings, unknown, void>;
 export default navigateToEntitySettingsInjectable;

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

@@ -1,3 +1,3 @@
-export declare type AccessPath = (path: string, mode?: number) => Promise<boolean>;
+export 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.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { CopyOptions } from "fs-extra";
-export declare type Copy = (src: string, dest: string, options?: CopyOptions | undefined) => Promise<void>;
+export 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

@@ -14,6 +14,6 @@ export interface CreateReadStreamOptions {
     start?: number | undefined;
     highWaterMark?: number | undefined;
 }
-export declare type CreateReadFileStream = (filePath: string, options?: CreateReadStreamOptions) => ReadStream;
+export 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/ensure-dir.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type EnsureDirectory = (dirPath: string) => Promise<void>;
+export 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.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<Function, any, any>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<Function, any>;
+};
+export default _default;

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

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

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

@@ -1,4 +1,4 @@
 import type { ExtractOptions } from "tar";
-export declare type ExtractTar = (filePath: string, opts?: ExtractOptions) => Promise<void>;
+export 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/fs.injectable.d.ts

@@ -1,3 +1,27 @@
+import type { ReadOptions } from "fs-extra";
 import fse from "fs-extra";
-declare const fsInjectable: import("@ogre-tools/injectable").Injectable<typeof fse, unknown, void>;
+/**
+ * NOTE: Add corrisponding a corrisponding override of this injecable in `src/test-utils/override-fs-with-fakes.ts`
+ */
+declare const fsInjectable: import("@ogre-tools/injectable").Injectable<{
+    readFile: typeof fse.promises.readFile;
+    readJson: (file: string, options?: ReadOptions | BufferEncoding) => Promise<any>;
+    writeFile: typeof fse.promises.writeFile;
+    writeJson: typeof fse.writeJson;
+    pathExists: typeof fse.pathExists;
+    readdir: typeof fse.promises.readdir;
+    readFileSync: typeof fse.readFileSync;
+    readJsonSync: typeof fse.readJsonSync;
+    writeFileSync: typeof fse.writeFileSync;
+    writeJsonSync: typeof fse.writeJsonSync;
+    pathExistsSync: typeof fse.pathExistsSync;
+    lstat: typeof fse.promises.lstat;
+    rm: typeof fse.promises.rm;
+    access: typeof fse.promises.access;
+    copy: (src: string, dest: string, options?: fse.CopyOptions) => Promise<void>;
+    ensureDir: (path: string, options?: number | fse.EnsureOptions) => Promise<void>;
+    ensureDirSync: typeof fse.ensureDirSync;
+    createReadStream: typeof fse.createReadStream;
+    stat: typeof fse.promises.stat;
+}, unknown, void>;
 export default fsInjectable;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import type { Stats } from "fs";
-export declare type LStat = (path: string) => Promise<Stats>;
+export 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/path-exists-sync.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const pathExistsSyncInjectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").pathExistsSync, unknown, void>;
+export default pathExistsSyncInjectable;

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

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

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

@@ -7,15 +7,15 @@ export interface ReadDirectory {
         withFileTypes?: false | undefined;
     }): Promise<Buffer[]>;
     (path: string, options?: {
-        encoding: BufferEncoding | string | null;
+        encoding: BufferEncoding;
         withFileTypes?: false | undefined;
-    } | BufferEncoding | string | null): Promise<string[]>;
+    } | BufferEncoding): Promise<string[]>;
     (path: string, options?: {
-        encoding?: BufferEncoding | string | null | undefined;
+        encoding?: BufferEncoding;
         withFileTypes?: false | undefined;
     }): Promise<string[] | Buffer[]>;
     (path: string, options: {
-        encoding?: BufferEncoding | string | null | undefined;
+        encoding?: BufferEncoding;
         withFileTypes: true;
     }): Promise<Dirent[]>;
 }

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export type ReadFileBufferSync = (filePath: string) => Buffer;
+declare const readFileBufferSyncInjectable: import("@ogre-tools/injectable").Injectable<ReadFileBufferSync, unknown, void>;
+export default readFileBufferSyncInjectable;

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

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

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

@@ -1,3 +1,3 @@
-export declare type ReadFile = (filePath: string) => Promise<string>;
+export 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/read-json-file.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { JsonValue } from "type-fest";
-export declare type ReadJson = (filePath: string) => Promise<JsonValue>;
+export type ReadJson = (filePath: string) => Promise<JsonValue>;
 declare const readJsonFileInjectable: import("@ogre-tools/injectable").Injectable<ReadJson, unknown, void>;
 export default readJsonFileInjectable;

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

@@ -0,0 +1,2 @@
+declare const readJsonSyncInjectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").readJsonSync, unknown, void>;
+export default readJsonSyncInjectable;

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

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

package/dist/src/common/fs/{move.global-override-for-injectable.d.ts → remove.global-override-for-injectable.d.ts}

@@ -3,7 +3,7 @@
  * 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>;
+    injectable: import("@ogre-tools/injectable").Injectable<import("./remove.injectable").RemovePath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./remove.injectable").RemovePath, void>;
 };
 export default _default;

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

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

package/dist/src/common/fs/{stat/stat.injectable.d.ts → stat.injectable.d.ts}

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import type { Stats } from "fs";
-export declare type Stat = (path: string) => Promise<Stats>;
+export 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/validate-directory.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { AsyncResult } from "../utils/async-result";
-export declare type ValidateDirectory = (path: string) => Promise<AsyncResult<undefined>>;
+export type ValidateDirectory = (path: string) => Promise<AsyncResult<undefined>>;
 declare const validateDirectoryInjectable: import("@ogre-tools/injectable").Injectable<ValidateDirectory, unknown, void>;
 export default validateDirectoryInjectable;

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

@@ -12,7 +12,7 @@ export interface MaybeStatWatcherEvents {
     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 type WatcherEvents<AlwaysStat extends boolean> = BaseWatcherEvents & (AlwaysStat extends true ? AlwaysStatWatcherEvents : MaybeStatWatcherEvents);
 export interface BaseWatcherEvents {
     error: (error: Error) => void;
     ready: () => void;
@@ -22,7 +22,7 @@ export interface BaseWatcherEvents {
 export interface Watcher<AlwaysStat extends boolean> extends TypedEventEmitter<WatcherEvents<AlwaysStat>> {
     close: () => Promise<void>;
 }
-export declare type WatcherOptions<AlwaysStat extends boolean> = {
+export 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`,
@@ -117,6 +117,6 @@ export interface AwaitWriteFinishOptions {
      */
     pollInterval?: number;
 }
-export declare type Watch = <AlwaysStat extends boolean = false>(path: string, options?: WatcherOptions<AlwaysStat>) => Watcher<AlwaysStat>;
+export 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-sync.injectable.d.ts

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

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import type { WriteFileOptions } from "fs-extra";
-export declare type WriteFile = (filePath: string, content: string | Buffer, opts?: WriteFileOptions) => Promise<void>;
+export 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/fs/write-json-file.injectable.d.ts

@@ -1,4 +1,3 @@
-import type { JsonValue } from "type-fest";
-export declare type WriteJson = (filePath: string, contents: JsonValue) => Promise<void>;
+export type WriteJson = (filePath: string, contents: unknown) => Promise<void>;
 declare const writeJsonFileInjectable: import("@ogre-tools/injectable").Injectable<WriteJson, unknown, void>;
 export default writeJsonFileInjectable;

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

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

package/dist/src/common/get-configuration-file-model/get-configuration-file-model.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("./get-configuration-file-model.injectable").GetConfigurationFileModel, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./get-configuration-file-model.injectable").GetConfigurationFileModel, void>;
+};
+export default _default;

package/dist/src/common/get-configuration-file-model/get-configuration-file-model.injectable.d.ts

@@ -1,4 +1,5 @@
 import Config from "conf";
-import type { BaseStoreParams } from "../base-store";
-declare const getConfigurationFileModelInjectable: import("@ogre-tools/injectable").Injectable<(<T extends object>(content: BaseStoreParams<T>) => Config<T>), unknown, void>;
+import type { Options as ConfOptions } from "conf/dist/source/types";
+export type GetConfigurationFileModel = <T extends object>(content: ConfOptions<T>) => Config<T>;
+declare const getConfigurationFileModelInjectable: import("@ogre-tools/injectable").Injectable<GetConfigurationFileModel, unknown, void>;
 export default getConfigurationFileModelInjectable;

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

@@ -5,5 +5,5 @@
 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 type AddHelmRepositoryChannel = RequestChannel<HelmRepo, AsyncResult<void, string>>;
 export declare const addHelmRepositoryChannel: AddHelmRepositoryChannel;

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

@@ -5,5 +5,5 @@
 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 type GetActiveHelmRepositoriesChannel = RequestChannel<void, AsyncResult<HelmRepo[]>>;
 export declare const getActiveHelmRepositoriesChannel: GetActiveHelmRepositoriesChannel;

package/dist/src/common/helm/helm-repo.d.ts

@@ -2,14 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-export declare type HelmRepo = {
+export interface HelmRepo {
     name: string;
     url: string;
-    cacheFilePath?: string;
+    cacheFilePath: string;
     caFile?: string;
     certFile?: string;
     insecureSkipTlsVerify?: boolean;
     keyFile?: string;
     username?: string;
     password?: string;
-};
+}

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

@@ -5,5 +5,5 @@
 import type { AsyncResult } from "../utils/async-result";
 import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
 import type { HelmRepo } from "./helm-repo";
-export declare type RemoveHelmRepositoryChannel = RequestChannel<HelmRepo, AsyncResult<void, string>>;
+export type RemoveHelmRepositoryChannel = RequestChannel<HelmRepo, AsyncResult<void, string>>;
 export declare const removeHelmRepositoryChannel: RemoveHelmRepositoryChannel;

package/dist/src/common/hotbars/add-hotbar.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { CreateHotbarData, CreateHotbarOptions } from "./types";
-export declare type AddHotbar = (data: CreateHotbarData, opts?: CreateHotbarOptions) => void;
+export type AddHotbar = (data: CreateHotbarData, opts?: CreateHotbarOptions) => void;
 declare const addHotbarInjectable: import("@ogre-tools/injectable").Injectable<AddHotbar, unknown, void>;
 export default addHotbarInjectable;

package/dist/src/common/hotbars/migrations-token.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { MigrationDeclaration } from "../base-store/migrations.injectable";
+export declare const hotbarStoreMigrationInjectionToken: import("@ogre-tools/injectable").InjectionToken<MigrationDeclaration, void>;

package/dist/src/common/hotbars/store.d.ts

@@ -2,7 +2,8 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { BaseStore } from "../base-store";
+import type { BaseStoreDependencies } from "../base-store/base-store";
+import { BaseStore } from "../base-store/base-store";
 import type { CatalogEntity } from "../catalog";
 import type { Hotbar, CreateHotbarData, CreateHotbarOptions } from "./types";
 import type { GeneralEntity } from "../catalog-entities";
@@ -11,13 +12,12 @@ export interface HotbarStoreModel {
     hotbars: Hotbar[];
     activeHotbarId: string;
 }
-interface Dependencies {
+interface Dependencies extends BaseStoreDependencies {
     readonly catalogCatalogEntity: GeneralEntity;
     readonly logger: Logger;
 }
 export declare class HotbarStore extends BaseStore<HotbarStoreModel> {
-    private readonly dependencies;
-    readonly displayName = "HotbarStore";
+    protected readonly dependencies: Dependencies;
     hotbars: Hotbar[];
     private _activeHotbarId;
     constructor(dependencies: Dependencies);

package/dist/src/common/hotbars/types.d.ts

@@ -13,7 +13,7 @@ export interface HotbarItem {
         [key: string]: string;
     };
 }
-export declare type Hotbar = Required<CreateHotbarData>;
+export type Hotbar = Required<CreateHotbarData>;
 export interface CreateHotbarData {
     id?: string;
     name: string;

package/dist/src/common/ipc/broadcast-message.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type BroadcastMessage = (channel: string, ...args: any[]) => Promise<void>;
+export type BroadcastMessage = (channel: string, ...args: any[]) => Promise<void>;
 declare const broadcastMessageInjectable: import("@ogre-tools/injectable").Injectable<BroadcastMessage, unknown, void>;
 export default broadcastMessageInjectable;

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

@@ -5,15 +5,12 @@
 export declare const clusterActivateHandler = "cluster:activate";
 export declare const clusterSetFrameIdHandler = "cluster:set-frame-id";
 export declare const clusterVisibilityHandler = "cluster:visibility";
-export declare const clusterRefreshHandler = "cluster:refresh";
 export declare const clusterDisconnectHandler = "cluster:disconnect";
-export declare const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all";
-export declare const clusterKubectlDeleteAllHandler = "cluster:kubectl-delete-all";
 export declare const clusterStates = "cluster:states";
 /**
  * This channel is broadcast on whenever the cluster fails to list namespaces
  * during a refresh and no `accessibleNamespaces` have been set.
  */
 export declare const clusterListNamespaceForbiddenChannel = "cluster:list-namespace-forbidden";
-export declare type ListNamespaceForbiddenArgs = [clusterId: string];
+export type ListNamespaceForbiddenArgs = [clusterId: string];
 export declare function isListNamespaceForbiddenArgs(args: unknown[]): args is ListNamespaceForbiddenArgs;

package/dist/src/common/ipc/invalid-kubeconfig/index.d.ts

@@ -3,4 +3,4 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 export declare const InvalidKubeconfigChannel = "invalid-kubeconfig";
-export declare type InvalidKubeConfigArgs = [clusterId: string];
+export type InvalidKubeConfigArgs = [clusterId: string];

package/dist/src/common/k8s/create-resource-stack.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { KubernetesCluster } from "../catalog-entities";
+import type { ResourceApplyingStack } from "./resource-stack";
+export type CreateResourceStack = (cluster: KubernetesCluster, name: string) => ResourceApplyingStack;
+declare const createResourceStackInjectable: import("@ogre-tools/injectable").Injectable<CreateResourceStack, unknown, void>;
+export default createResourceStackInjectable;

package/dist/src/common/k8s/resource-stack.d.ts

@@ -1,8 +1,27 @@
 import type { KubernetesCluster } from "../catalog-entities";
+import type { AsyncResult } from "../utils/async-result";
+import type { Logger } from "../logger";
+import type { KubectlApplyAll, KubectlDeleteAll } from "../kube-helpers/channels";
+import type { ReadDirectory } from "../fs/read-directory.injectable";
+import type { JoinPaths } from "../path/join-paths.injectable";
+import type { ReadFile } from "../fs/read-file.injectable";
+export interface ResourceApplyingStack {
+    kubectlApplyFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
+    kubectlDeleteFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
+}
+export interface ResourceStackDependencies {
+    readonly logger: Logger;
+    kubectlApplyAll: KubectlApplyAll;
+    kubectlDeleteAll: KubectlDeleteAll;
+    readDirectory: ReadDirectory;
+    joinPaths: JoinPaths;
+    readFile: ReadFile;
+}
 export declare class ResourceStack {
-    protected cluster: KubernetesCluster;
-    protected name: string;
-    constructor(cluster: KubernetesCluster, name: string);
+    protected readonly dependencies: ResourceStackDependencies;
+    protected readonly cluster: KubernetesCluster;
+    protected readonly name: string;
+    constructor(dependencies: ResourceStackDependencies, cluster: KubernetesCluster, name: string);
     /**
      *
      * @param folderPath folder path that is searched for files defining kubernetes resources.
@@ -15,8 +34,8 @@ export declare class ResourceStack {
      * @param templateContext sets the template parameters that are to be applied to any templated kubernetes resources that are to be applied.
      */
     kubectlDeleteFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
-    protected applyResources(resources: string[], extraArgs?: string[]): Promise<string>;
-    protected deleteResources(resources: string[], extraArgs?: string[]): Promise<string>;
-    protected appendKubectlArgs(kubectlArgs: string[]): string[];
+    protected applyResources(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    protected deleteResources(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    protected getAdditionalArgs(kubectlArgs: string[]): string[];
     protected renderTemplates(folderPath: string, templateContext: any): Promise<string[]>;
 }

package/dist/src/common/k8s-api/api-manager/api-manager.d.ts

@@ -5,9 +5,9 @@
 import type { KubeObjectStore } from "../kube-object.store";
 import type { KubeApi } from "../kube-api";
 import type { KubeJsonApiDataFor, KubeObject, ObjectReference } from "../kube-object";
-export declare type RegisterableStore<Store> = Store extends KubeObjectStore<any, any, any> ? Store : never;
-export declare type RegisterableApi<Api> = Api extends KubeApi<any, any> ? Api : never;
-export declare type KubeObjectStoreFrom<Api> = Api extends KubeApi<infer KubeObj, infer ApiData> ? KubeObjectStore<KubeObj, Api, ApiData> : never;
+export type RegisterableStore<Store> = Store extends KubeObjectStore<any, any, any> ? Store : never;
+export type RegisterableApi<Api> = Api extends KubeApi<any, any> ? Api : never;
+export type KubeObjectStoreFrom<Api> = Api extends KubeApi<infer KubeObj, infer ApiData> ? KubeObjectStore<KubeObj, Api, ApiData> : never;
 export declare class ApiManager {
     private readonly apis;
     private readonly stores;

package/dist/src/common/k8s-api/create-json-api.injectable.d.ts

@@ -1,6 +1,6 @@
 import type { RequestInit } from "node-fetch";
 import type { JsonApiConfig, JsonApiData, JsonApiParams } from "./json-api";
 import { JsonApi } from "./json-api";
-export declare type CreateJsonApi = <Data = JsonApiData, Params extends JsonApiParams<Data> = JsonApiParams<Data>>(config: JsonApiConfig, reqInit?: RequestInit) => JsonApi<Data, Params>;
+export type CreateJsonApi = <Data = JsonApiData, Params extends JsonApiParams<Data> = JsonApiParams<Data>>(config: JsonApiConfig, reqInit?: RequestInit) => JsonApi<Data, Params>;
 declare const createJsonApiInjectable: import("@ogre-tools/injectable").Injectable<CreateJsonApi, unknown, void>;
 export default createJsonApiInjectable;

package/dist/src/common/k8s-api/create-kube-json-api-for-cluster.injectable.d.ts

@@ -1,4 +1,4 @@
 import type { KubeJsonApi } from "./kube-json-api";
-export declare type CreateKubeJsonApiForCluster = (clusterId: string) => KubeJsonApi;
+export type CreateKubeJsonApiForCluster = (clusterId: string) => KubeJsonApi;
 declare const createKubeJsonApiForClusterInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeJsonApiForCluster, unknown, void>;
 export default createKubeJsonApiForClusterInjectable;

package/dist/src/common/k8s-api/create-kube-json-api.injectable.d.ts

@@ -1,6 +1,6 @@
 import type { RequestInit } from "node-fetch";
 import type { JsonApiConfig } from "./json-api";
 import { KubeJsonApi } from "./kube-json-api";
-export declare type CreateKubeJsonApi = (config: JsonApiConfig, reqInit?: RequestInit) => KubeJsonApi;
+export type CreateKubeJsonApi = (config: JsonApiConfig, reqInit?: RequestInit) => KubeJsonApi;
 declare const createKubeJsonApiInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeJsonApi, unknown, void>;
 export default createKubeJsonApiInjectable;

package/dist/src/common/k8s-api/endpoints/custom-resource-definition.api.d.ts

@@ -14,10 +14,10 @@ interface AdditionalPrinterColumnsCommon {
     format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password";
     description?: string;
 }
-export declare type AdditionalPrinterColumnsV1 = AdditionalPrinterColumnsCommon & {
+export type AdditionalPrinterColumnsV1 = AdditionalPrinterColumnsCommon & {
     jsonPath: string;
 };
-declare type AdditionalPrinterColumnsV1Beta = AdditionalPrinterColumnsCommon & {
+type AdditionalPrinterColumnsV1Beta = AdditionalPrinterColumnsCommon & {
     JSONPath: string;
 };
 export interface CustomResourceValidation {