@k8slens/extensions 6.3.0-git.fe0c13424a.0 → 6.3.1-git.6aee907dc5.0

package/dist/src/extensions/extension-discovery/bundled-extension-token.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { LensExtensionConstructor, LensExtensionManifest } from "../lens-extension";
+export interface BundledExtension {
+    readonly manifest: LensExtensionManifest;
+    main: () => LensExtensionConstructor | null;
+    renderer: () => LensExtensionConstructor | null;
+}
+export declare const bundledExtensionInjectionToken: import("@ogre-tools/injectable").InjectionToken<BundledExtension, void>;

package/dist/src/extensions/extension-discovery/extension-discovery.d.ts

@@ -6,7 +6,6 @@ import type { ExtensionsStore } from "../extensions-store/extensions-store";
 import type { ExtensionLoader } from "../extension-loader";
 import type { LensExtensionId, LensExtensionManifest } from "../lens-extension";
 import type { ExtensionInstallationStateStore } from "../extension-installation-state-store/extension-installation-state-store";
-import type { PackageJson } from "type-fest";
 import type { ReadJson } from "../../common/fs/read-json-file.injectable";
 import type { Logger } from "../../common/logger";
 import type { PathExists } from "../../common/fs/path-exists.injectable";
@@ -20,21 +19,20 @@ import type { JoinPaths } from "../../common/path/join-paths.injectable";
 import type { GetBasenameOfPath } from "../../common/path/get-basename.injectable";
 import type { GetDirnameOfPath } from "../../common/path/get-dirname.injectable";
 import type { GetRelativePath } from "../../common/path/get-relative-path.injectable";
-import type { RemovePath } from "../../common/fs/remove-path.injectable";
+import type { RemovePath } from "../../common/fs/remove.injectable";
 import type TypedEventEmitter from "typed-emitter";
 interface Dependencies {
     readonly extensionLoader: ExtensionLoader;
     readonly extensionsStore: ExtensionsStore;
     readonly extensionInstallationStateStore: ExtensionInstallationStateStore;
     readonly extensionPackageRootDirectory: string;
-    readonly staticFilesDirectory: string;
+    readonly resourcesDirectory: string;
     readonly logger: Logger;
     readonly isProduction: boolean;
     readonly fileSystemSeparator: string;
     readonly homeDirectoryPath: string;
     isCompatibleExtension: (manifest: LensExtensionManifest) => boolean;
     installExtension: (name: string) => Promise<void>;
-    installExtensions: (packageJsonPath: string, packagesJson: PackageJson) => Promise<void>;
     readJsonFile: ReadJson;
     pathExists: PathExists;
     removePath: RemovePath;
@@ -92,8 +90,6 @@ export declare class ExtensionDiscovery {
     constructor(dependencies: Dependencies);
     get localFolderPath(): string;
     get packageJsonPath(): string;
-    get inTreeTargetPath(): string;
-    get inTreeFolderPath(): string;
     get nodeModulesPath(): string;
     /**
      * Initializes the class and setups the file watcher for added/removed local extensions.
@@ -145,12 +141,7 @@ export declare class ExtensionDiscovery {
         isBundled?: boolean | undefined;
     }): Promise<InstalledExtension | null>;
     ensureExtensions(): Promise<Map<LensExtensionId, InstalledExtension>>;
-    /**
-     * Write package.json to file system and install dependencies.
-     */
-    installBundledPackages(packageJsonPath: string, extensions: InstalledExtension[]): Promise<void>;
-    loadBundledExtensions(): Promise<InstalledExtension[]>;
-    loadFromFolder(folderPath: string, bundledExtensions: string[]): Promise<InstalledExtension[]>;
+    loadFromFolder(folderPath: string): Promise<InstalledExtension[]>;
     /**
      * Loads extension from absolute path, updates this.packagesJson to include it and returns the extension.
      * @param folderPath Folder path to extension

package/dist/src/extensions/extension-installer/extension-installer.d.ts

@@ -2,7 +2,6 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { PackageJson } from "type-fest";
 interface Dependencies {
     extensionPackageRootDirectory: string;
 }
@@ -14,10 +13,6 @@ export declare class ExtensionInstaller {
     private installLock;
     constructor(dependencies: Dependencies);
     get npmPath(): any;
-    /**
-     * Write package.json to the file system and execute npm install for it.
-     */
-    installPackages: (packageJsonPath: string, packagesJson: PackageJson) => Promise<void>;
     /**
      * Install single package using npm
      */

package/dist/src/{migrations/cluster-store/3.6.0-beta.1.d.ts → extensions/extension-loader/entry-point-name.d.ts}

@@ -2,6 +2,4 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { MigrationDeclaration } from "../helpers";
-declare const _default: MigrationDeclaration;
-export default _default;
+export declare const extensionEntryPointNameInjectionToken: import("@ogre-tools/injectable").InjectionToken<"main" | "renderer", void>;

package/dist/src/extensions/extension-loader/extension-loader.d.ts

@@ -11,15 +11,23 @@ import type { Extension } from "./extension/extension.injectable";
 import type { Logger } from "../../common/logger";
 import type { JoinPaths } from "../../common/path/join-paths.injectable";
 import type { GetDirnameOfPath } from "../../common/path/get-dirname.injectable";
+import type { BundledExtension } from "../extension-discovery/bundled-extension-token";
 interface Dependencies {
     readonly extensionInstances: ObservableMap<LensExtensionId, LensExtension>;
+    readonly bundledExtensions: BundledExtension[];
     readonly logger: Logger;
+    readonly extensionEntryPointName: "main" | "renderer";
     updateExtensionsState: (extensionsState: Record<LensExtensionId, LensExtensionState>) => void;
     createExtensionInstance: CreateExtensionInstance;
     getExtension: (instance: LensExtension) => Extension;
     joinPaths: JoinPaths;
     getDirnameOfPath: GetDirnameOfPath;
 }
+interface ExtensionBeingActivated {
+    instance: LensExtension;
+    installedExtension: InstalledExtension;
+    activated: Promise<void>;
+}
 export interface ExtensionLoading {
     isBundled: boolean;
     loaded: Promise<void>;
@@ -73,14 +81,10 @@ export declare class ExtensionLoader {
     protected initRenderer(): Promise<void>;
     broadcastExtensions(): void;
     syncExtensions(extensions: [LensExtensionId, InstalledExtension][]): void;
-    protected loadExtensions(installedExtensions: Map<string, InstalledExtension>): Promise<{
-        isBundled: boolean;
-        loaded: Promise<void>;
-    }[]>;
-    autoInitExtensions(): Promise<{
-        isBundled: boolean;
-        loaded: Promise<void>;
-    }[]>;
+    protected loadBundledExtensions(): Promise<ExtensionBeingActivated[]>;
+    protected loadExtensions(extensions: ExtensionBeingActivated[]): Promise<ExtensionLoading[]>;
+    protected loadUserExtensions(installedExtensions: Map<string, InstalledExtension>): Promise<ExtensionBeingActivated[]>;
+    autoInitExtensions(): Promise<ExtensionLoading[]>;
     protected requireExtension(extension: InstalledExtension): LensExtensionConstructor | null;
     getExtension(extId: LensExtensionId): InstalledExtension | undefined;
     getInstanceById(extId: LensExtensionId): LensExtension<import("../lens-extension-set-dependencies").LensExtensionDependencies> | undefined;

package/dist/src/extensions/extension-loader/file-system-provisioner-store/file-system-provisioner-store.d.ts

@@ -2,17 +2,23 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { BaseStore } from "../../../common/base-store";
+import type { BaseStoreDependencies } from "../../../common/base-store/base-store";
+import { BaseStore } from "../../../common/base-store/base-store";
+import type { EnsureDirectory } from "../../../common/fs/ensure-dir.injectable";
+import type { JoinPaths } from "../../../common/path/join-paths.injectable";
+import type { RandomBytes } from "../../../common/utils/random-bytes.injectable";
 interface FSProvisionModel {
     extensions: Record<string, string>;
 }
-interface Dependencies {
-    directoryForExtensionData: string;
+interface Dependencies extends BaseStoreDependencies {
+    readonly directoryForExtensionData: string;
+    ensureDirectory: EnsureDirectory;
+    joinPaths: JoinPaths;
+    randomBytes: RandomBytes;
 }
 export declare class FileSystemProvisionerStore extends BaseStore<FSProvisionModel> {
-    private dependencies;
-    readonly displayName = "FilesystemProvisionerStore";
-    registeredExtensions: import("mobx").ObservableMap<string, string>;
+    protected readonly dependencies: Dependencies;
+    readonly registeredExtensions: import("mobx").ObservableMap<string, string>;
     constructor(dependencies: Dependencies);
     /**
      * This function retrieves the saved path to the folder which the extension

package/dist/src/extensions/extension-store.d.ts

@@ -2,10 +2,30 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { BaseStore } from "../common/base-store";
+import type { BaseStoreParams } from "../common/base-store/base-store";
+import { BaseStore } from "../common/base-store/base-store";
 import type { LensExtension } from "./lens-extension";
+import type { StaticThis } from "../common/utils";
+import type { Migrations } from "conf/dist/source/types";
+export interface ExtensionStoreParams<T extends object> extends BaseStoreParams<T> {
+    migrations?: Migrations<T>;
+}
 export declare abstract class ExtensionStore<T extends object> extends BaseStore<T> {
-    readonly displayName = "ExtensionStore<T>";
+    private static readonly instances;
+    /**
+     * @deprecated This is a form of global shared state. Just call `new Store(...)`
+     */
+    static createInstance<T, R extends any[]>(this: StaticThis<T, R>, ...args: R): T;
+    /**
+     * @deprecated This is a form of global shared state. Just call `new Store(...)`
+     */
+    static getInstance<T, R extends any[]>(this: StaticThis<T, R>, strict?: true): T;
+    static getInstance<T, R extends any[]>(this: StaticThis<T, R>, strict: false): T | undefined;
+    constructor({ migrations, ...params }: ExtensionStoreParams<T>);
+    /**
+     * @deprecated This is a form of global shared state. Just call `new Store(...)`
+     */
+    static resetInstance(): void;
     protected extension?: LensExtension;
     loadExtension(extension: LensExtension): void;
     load(): void;

package/dist/src/extensions/extensions-store/extensions-store.d.ts

@@ -3,7 +3,8 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { LensExtensionId } from "../lens-extension";
-import { BaseStore } from "../../common/base-store";
+import type { BaseStoreDependencies } from "../../common/base-store/base-store";
+import { BaseStore } from "../../common/base-store/base-store";
 export interface LensExtensionsStoreModel {
     extensions: Record<LensExtensionId, LensExtensionState>;
 }
@@ -16,8 +17,7 @@ export interface IsEnabledExtensionDescriptor {
     isBundled: boolean;
 }
 export declare class ExtensionsStore extends BaseStore<LensExtensionsStoreModel> {
-    readonly displayName = "ExtensionsStore";
-    constructor();
+    constructor(deps: BaseStoreDependencies);
     get enabledExtensions(): string[];
     protected state: import("mobx").ObservableMap<string, LensExtensionState>;
     isEnabled({ id, isBundled }: IsEnabledExtensionDescriptor): boolean;

package/dist/src/extensions/renderer-api/k8s-api.d.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { KubeResource } from "../../common/rbac";
-export declare function isAllowedResource(resource: KubeResource | KubeResource[]): boolean;
+export declare function isAllowedResource(resources: KubeResource | KubeResource[]): boolean;
 export declare const serviceAccountsApi: import("../../common/k8s-api/endpoints").ServiceAccountApi;
 export declare const clusterRoleApi: import("../../common/k8s-api/endpoints").ClusterRoleApi;
 export declare const clusterRoleBindingApi: import("../../common/k8s-api/endpoints").ClusterRoleBindingApi;

package/dist/src/extensions/renderer-api/theming.d.ts

@@ -2,10 +2,10 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { LensTheme } from "../../renderer/themes/store";
-export declare const activeTheme: import("mobx").IComputedValue<LensTheme>;
+import type { LensTheme } from "../../renderer/themes/lens-theme";
+export declare const activeTheme: import("mobx").IComputedValue<import("type-fest/source/readonly-deep").ReadonlyObjectDeep<LensTheme>>;
 /**
  * @deprecated This hides the reactivity of active theme, use {@link activeTheme} instead
  */
-export declare function getActiveTheme(): LensTheme;
+export declare function getActiveTheme(): import("type-fest/source/readonly-deep").ReadonlyObjectDeep<LensTheme>;
 export type { LensTheme };

package/dist/src/features/application-menu/main/start-application-menu.injectable.d.ts

@@ -1,5 +1,5 @@
 declare const startApplicationMenuInjectable: import("@ogre-tools/injectable").Injectable<{
     id: string;
-    run: () => Promise<void>;
+    run: () => void;
 }, import("../../../common/runnable/run-many-for").Runnable<void>, void>;
 export default startApplicationMenuInjectable;

package/dist/src/features/application-update/child-features/periodical-checking-of-updates/main/start-checking-for-updates.injectable.d.ts

@@ -1,5 +1,5 @@
 declare const startCheckingForUpdatesInjectable: import("@ogre-tools/injectable").Injectable<{
     id: string;
-    run: () => Promise<void>;
+    run: () => void;
 }, import("../../../../../common/runnable/run-many-for").Runnable<void>, void>;
 export default startCheckingForUpdatesInjectable;

package/dist/src/features/cluster/state-sync/common/channels.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { ClusterId, ClusterState } from "../../../../common/cluster-types";
+import type { MessageChannel } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+export interface ClusterStateSync {
+    clusterId: ClusterId;
+    state: ClusterState;
+}
+export declare const clusterStateSyncChannel: MessageChannel<ClusterStateSync>;
+export declare const initialClusterStatesChannel: RequestChannel<void, ClusterStateSync[]>;

package/dist/src/features/cluster/state-sync/main/emit-update.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { MessageChannelHandler } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import { clusterStateSyncChannel } from "../common/channels";
+export type EmitClusterStateUpdate = MessageChannelHandler<typeof clusterStateSyncChannel>;
+declare const emitClusterStateUpdateInjectable: import("@ogre-tools/injectable").Injectable<(message: import("../common/channels").ClusterStateSync) => void, unknown, void>;
+export default emitClusterStateUpdateInjectable;

package/dist/src/features/cluster/state-sync/main/handle-initial.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const handleInitialClusterStateSyncInjectable: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<void, import("../common/channels").ClusterStateSync[]>;
+    handler: (req: void) => import("../common/channels").ClusterStateSync[] | Promise<import("../common/channels").ClusterStateSync[]>;
+}, import("../../../../main/utils/channel/channel-listeners/listener-tokens").RequestChannelListener<import("../../../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<unknown, unknown>>, void>;
+export default handleInitialClusterStateSyncInjectable;

package/dist/src/features/cluster/state-sync/main/setup-sync.injectable.d.ts

@@ -0,0 +1,29 @@
+declare const setupClusterStateBroadcastingInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+    runAfter: {
+        id: string;
+        run: () => void;
+        runAfter: {
+            id: string;
+            run: () => Promise<void>;
+            runAfter: {
+                id: string;
+                run: () => Promise<void>;
+                runAfter: {
+                    id: string;
+                    run: () => Promise<void>;
+                    runAfter: {
+                        id: string;
+                        run: () => Promise<void>;
+                        runAfter: {
+                            id: string;
+                            run: () => Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default setupClusterStateBroadcastingInjectable;

package/dist/src/features/cluster/state-sync/renderer/listener.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const clusterStateListenerInjectable: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannel<import("../common/channels").ClusterStateSync>;
+    handler: (message: import("../common/channels").ClusterStateSync) => void;
+}, import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannelListener<import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannel<unknown>>, void>;
+export default clusterStateListenerInjectable;

package/dist/src/features/cluster/state-sync/renderer/request-initial.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { RequestChannelHandler } from "../../../../main/utils/channel/channel-listeners/listener-tokens";
+import { initialClusterStatesChannel } from "../common/channels";
+export type RequestInitialClusterStates = RequestChannelHandler<typeof initialClusterStatesChannel>;
+declare const requestInitialClusterStatesInjectable: import("@ogre-tools/injectable").Injectable<(req: void) => import("../common/channels").ClusterStateSync[] | Promise<import("../common/channels").ClusterStateSync[]>, unknown, void>;
+export default requestInitialClusterStatesInjectable;

package/dist/src/features/cluster/state-sync/renderer/setup-sync.injectable.d.ts

@@ -0,0 +1,29 @@
+declare const setupClusterStateSyncInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => Promise<void>;
+    runAfter: {
+        id: string;
+        run: () => void;
+        runAfter: {
+            id: string;
+            run: () => void;
+            runAfter: {
+                id: string;
+                run: () => Promise<void>;
+                runAfter: {
+                    id: string;
+                    run: () => Promise<void>;
+                    runAfter: {
+                        id: string;
+                        run: () => Promise<void>;
+                        runAfter: {
+                            id: string;
+                            run: () => Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default setupClusterStateSyncInjectable;

package/dist/src/features/cluster/store/main/init.injectable.d.ts

@@ -0,0 +1,25 @@
+declare const initClusterStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+    runAfter: {
+        id: string;
+        run: () => Promise<void>;
+        runAfter: {
+            id: string;
+            run: () => Promise<void>;
+            runAfter: {
+                id: string;
+                run: () => Promise<void>;
+                runAfter: {
+                    id: string;
+                    run: () => Promise<void>;
+                    runAfter: {
+                        id: string;
+                        run: () => Promise<void>;
+                    };
+                };
+            };
+        };
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initClusterStoreInjectable;

package/dist/src/features/cluster/store/renderer/init.injectable.d.ts

@@ -0,0 +1,25 @@
+declare const initClusterStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+    runAfter: {
+        id: string;
+        run: () => void;
+        runAfter: {
+            id: string;
+            run: () => Promise<void>;
+            runAfter: {
+                id: string;
+                run: () => Promise<void>;
+                runAfter: {
+                    id: string;
+                    run: () => Promise<void>;
+                    runAfter: {
+                        id: string;
+                        run: () => Promise<void>;
+                    };
+                };
+            };
+        };
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initClusterStoreInjectable;

package/dist/src/features/extensions/navigate/common/channel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { MessageChannel } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+export interface NavigateForExtensionArgs {
+    extId: string;
+    pageId: string | undefined;
+    params: Record<string, any> | undefined;
+}
+export declare const navigateForExtensionChannel: MessageChannel<NavigateForExtensionArgs>;

package/dist/src/features/extensions/navigate/renderer/listener.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const navigateForExtensionListenerInjectable: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannel<import("../common/channel").NavigateForExtensionArgs>;
+    handler: (message: import("../common/channel").NavigateForExtensionArgs) => void;
+}, import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannelListener<import("../../../../common/utils/channel/message-channel-listener-injection-token").MessageChannel<unknown>>, void>;
+export default navigateForExtensionListenerInjectable;

package/dist/src/features/file-system-provisioner/main/init-store.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const initFileSystemProvisionerStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+}, import("../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initFileSystemProvisionerStoreInjectable;

package/dist/src/features/file-system-provisioner/renderer/init-store.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const initFileSystemProvisionerStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+}, import("../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initFileSystemProvisionerStoreInjectable;

package/dist/src/features/helm-charts/child-features/preferences/renderer/adding-of-custom-helm-repository/custom-helm-repo.injectable.d.ts

@@ -1,11 +1,3 @@
-declare const customHelmRepoInjectable: import("@ogre-tools/injectable").Injectable<{
-    name: string;
-    url: string;
-    username: string;
-    password: string;
-    insecureSkipTlsVerify: boolean;
-    caFile: string;
-    keyFile: string;
-    certFile: string;
-}, unknown, void>;
+import type { HelmRepo } from "../../../../../../common/helm/helm-repo";
+declare const customHelmRepoInjectable: import("@ogre-tools/injectable").Injectable<HelmRepo, unknown, void>;
 export default customHelmRepoInjectable;

package/dist/src/features/helm-charts/child-features/preferences/renderer/adding-of-custom-helm-repository/helm-file-input/get-file-paths.injectable.d.ts

@@ -1,6 +1,8 @@
 import type { FileFilter } from "electron";
-declare const getFilePathsInjectable: import("@ogre-tools/injectable").Injectable<(fileFilter: FileFilter) => Promise<{
-    canceled: boolean;
-    filePaths: string[];
-}>, unknown, void>;
-export default getFilePathsInjectable;
+import type { PathPickOpts } from "../../../../../../../renderer/components/path-picker";
+export interface RequestFilePathOptions extends Pick<PathPickOpts, "onCancel" | "onPick"> {
+    filter: FileFilter;
+}
+export type RequestFilePaths = (options: RequestFilePathOptions) => Promise<void>;
+declare const requestFilePathsInjectable: import("@ogre-tools/injectable").Injectable<RequestFilePaths, unknown, void>;
+export default requestFilePathsInjectable;

package/dist/src/features/helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/{call-for-public-helm-repositories.injectable.d.ts → request-public-helm-repositories.injectable.d.ts}

@@ -1,3 +1,3 @@
 import type { HelmRepo } from "../../../../../../../common/helm/helm-repo";
-declare const callForPublicHelmRepositoriesInjectable: import("@ogre-tools/injectable").Injectable<() => Promise<HelmRepo[]>, unknown, void>;
-export default callForPublicHelmRepositoriesInjectable;
+declare const requestPublicHelmRepositoriesInjectable: import("@ogre-tools/injectable").Injectable<() => Promise<HelmRepo[]>, unknown, void>;
+export default requestPublicHelmRepositoriesInjectable;

package/dist/src/features/hotbar/store/main/init.injectable.d.ts

@@ -0,0 +1,9 @@
+declare const initHotbarStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+    runAfter: {
+        id: string;
+        run: () => void;
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initHotbarStoreInjectable;

package/dist/src/features/hotbar/store/renderer/init.injectable.d.ts

@@ -0,0 +1,29 @@
+declare const initHotbarStoreInjectable: import("@ogre-tools/injectable").Injectable<{
+    id: string;
+    run: () => void;
+    runAfter: {
+        id: string;
+        run: () => void;
+        runAfter: {
+            id: string;
+            run: () => void;
+            runAfter: {
+                id: string;
+                run: () => Promise<void>;
+                runAfter: {
+                    id: string;
+                    run: () => Promise<void>;
+                    runAfter: {
+                        id: string;
+                        run: () => Promise<void>;
+                        runAfter: {
+                            id: string;
+                            run: () => Promise<void>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, import("../../../../common/runnable/run-many-for").Runnable<void>, void>;
+export default initHotbarStoreInjectable;

package/dist/src/features/path-picking-dialog/common/channel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { OpenDialogOptions } from "electron";
+import type { RequestChannel } from "../../../common/utils/channel/request-channel-listener-injection-token";
+export type PathPickingResponse = {
+    canceled: true;
+} | {
+    canceled: false;
+    paths: string[];
+};
+export declare const openPathPickingDialogChannel: RequestChannel<OpenDialogOptions, PathPickingResponse>;

package/dist/src/features/path-picking-dialog/main/handle-pick-paths.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 openPathPickingDialogListener: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<Electron.OpenDialogOptions, import("../common/channel").PathPickingResponse>;
+    handler: (req: Electron.OpenDialogOptions) => import("../common/channel").PathPickingResponse | Promise<import("../common/channel").PathPickingResponse>;
+}, import("../../../main/utils/channel/channel-listeners/listener-tokens").RequestChannelListener<import("../../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<unknown, unknown>>, void>;
+export default openPathPickingDialogListener;

package/dist/src/features/path-picking-dialog/renderer/pick-paths.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { PathPickOpts } from "../../../renderer/components/path-picker";
+export type OpenPathPickingDialog = (options: PathPickOpts) => Promise<void>;
+declare const openPathPickingDialogInjectable: import("@ogre-tools/injectable").Injectable<OpenPathPickingDialog, unknown, void>;
+export default openPathPickingDialogInjectable;

package/dist/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/discover-all-sync-kinds.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { SyncKind } from "./discover-sync-kind.injectable";
+export type DiscoverAllKubeconfigSyncKinds = (filePaths: string[]) => Promise<[string, SyncKind][]>;
+declare const discoverAllKubeconfigSyncKindsInjectable: import("@ogre-tools/injectable").Injectable<DiscoverAllKubeconfigSyncKinds, unknown, void>;
+export default discoverAllKubeconfigSyncKindsInjectable;

package/dist/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/discover-sync-kind.injectable.d.ts

@@ -0,0 +1,6 @@
+export interface SyncKind {
+    type: "file" | "folder" | "unknown";
+}
+export type DiscoverKubeconfigSyncKind = (path: string) => Promise<[string, SyncKind]>;
+declare const discoverKubeconfigSyncKindInjectable: import("@ogre-tools/injectable").Injectable<DiscoverKubeconfigSyncKind, unknown, void>;
+export default discoverKubeconfigSyncKindInjectable;

package/dist/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/kubeconfig-sync.d.ts

@@ -1,13 +1,2 @@
 import React from "react";
-import type { KubeconfigSyncValue } from "../../../../../../common/user-store";
-import type { Logger } from "../../../../../../common/logger";
-interface SyncInfo {
-    type: "file" | "folder" | "unknown";
-}
-interface Value {
-    data: KubeconfigSyncValue;
-    info: SyncInfo;
-}
-export declare function getAllEntries(filePaths: string[], logger: Logger): Promise<[string, Value][]>;
 export declare const KubeconfigSync: React.FunctionComponent<{}>;
-export {};

package/dist/src/features/theme/system-type/common/channels.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 { MessageChannel } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import type { RequestChannel } from "../../../../common/utils/channel/request-channel-listener-injection-token";
+export type SystemThemeType = "dark" | "light";
+export declare const initialSystemThemeTypeChannel: RequestChannel<void, SystemThemeType>;
+export declare const systemThemeTypeUpdateChannel: MessageChannel<SystemThemeType>;

package/dist/src/features/theme/system-type/main/emit-update.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { MessageChannelHandler } from "../../../../common/utils/channel/message-channel-listener-injection-token";
+import { systemThemeTypeUpdateChannel } from "../common/channels";
+export type EmitSystemThemeTypeUpdate = MessageChannelHandler<typeof systemThemeTypeUpdateChannel>;
+declare const emitSystemThemeTypeUpdateInjectable: import("@ogre-tools/injectable").Injectable<(message: import("../common/channels").SystemThemeType) => void, unknown, void>;
+export default emitSystemThemeTypeUpdateInjectable;