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

package/dist/src/main/cluster/visible-cluster.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const visibleClusterInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IObservableValue<string | null>, unknown, void>;
+export default visibleClusterInjectable;

package/dist/src/main/cluster-detectors/detector-registry.d.ts

@@ -9,7 +9,7 @@ import type { K8sRequest } from "../k8s-request.injectable";
 interface Dependencies {
     k8sRequest: K8sRequest;
 }
-export declare type DetectorConstructor = new (cluster: Cluster, k8sRequest: K8sRequest) => BaseClusterDetector;
+export type DetectorConstructor = new (cluster: Cluster, k8sRequest: K8sRequest) => BaseClusterDetector;
 export declare class DetectorRegistry {
     private dependencies;
     constructor(dependencies: Dependencies);

package/dist/src/main/context-handler/context-handler.d.ts

@@ -3,13 +3,16 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 /// <reference types="node" />
-import type { PrometheusProvider, PrometheusService, PrometheusProviderRegistry } from "../prometheus/provider-registry";
+import type { PrometheusProvider, PrometheusService } from "../prometheus/provider";
 import type { ClusterPrometheusPreferences } from "../../common/cluster-types";
 import type { Cluster } from "../../common/cluster/cluster";
 import type httpProxy from "http-proxy";
 import type { UrlWithStringQuery } from "url";
 import type { KubeAuthProxy } from "../kube-auth-proxy/kube-auth-proxy";
 import type { CreateKubeAuthProxy } from "../kube-auth-proxy/create-kube-auth-proxy.injectable";
+import type { GetPrometheusProviderByKind } from "../prometheus/get-by-kind.injectable";
+import type { IComputedValue } from "mobx";
+import type { Logger } from "../../common/logger";
 export interface PrometheusDetails {
     prometheusPath: string;
     provider: PrometheusProvider;
@@ -20,10 +23,12 @@ interface PrometheusServicePreferences {
     port: number;
     prefix: string;
 }
-interface Dependencies {
-    readonly createKubeAuthProxy: CreateKubeAuthProxy;
+export interface ContextHandlerDependencies {
+    createKubeAuthProxy: CreateKubeAuthProxy;
+    getPrometheusProviderByKind: GetPrometheusProviderByKind;
     readonly authProxyCa: string;
-    readonly prometheusProviderRegistry: PrometheusProviderRegistry;
+    readonly prometheusProviders: IComputedValue<PrometheusProvider[]>;
+    readonly logger: Logger;
 }
 export interface ClusterContextHandler {
     readonly clusterUrl: UrlWithStringQuery;
@@ -37,14 +42,14 @@ export interface ClusterContextHandler {
     stopServer(): void;
 }
 export declare class ContextHandler implements ClusterContextHandler {
-    private dependencies;
-    protected cluster: Cluster;
+    private readonly dependencies;
+    protected readonly cluster: Cluster;
     readonly clusterUrl: UrlWithStringQuery;
     protected kubeAuthProxy?: KubeAuthProxy;
     protected apiTarget?: httpProxy.ServerOptions;
     protected prometheusProvider?: string;
     protected prometheus?: PrometheusServicePreferences;
-    constructor(dependencies: Dependencies, cluster: Cluster);
+    constructor(dependencies: ContextHandlerDependencies, cluster: Cluster);
     setupPrometheus(preferences?: ClusterPrometheusPreferences): void;
     getPrometheusDetails(): Promise<PrometheusDetails>;
     protected ensurePrometheusPath({ service, namespace, port }: PrometheusService): string;

package/dist/src/main/electron-app/features/show-message-popup.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type ShowMessagePopup = (title: string, message: string, detail: string) => void;
+export type ShowMessagePopup = (title: string, message: string, detail: string) => void;
 declare const showMessagePopupInjectable: import("@ogre-tools/injectable").Injectable<ShowMessagePopup, unknown, void>;
 export default showMessagePopupInjectable;

package/dist/src/main/electron-app/runnables/setup-ipc-main-handlers/setup-ipc-main-handlers.d.ts

@@ -1,6 +1,5 @@
 import { ClusterStore } from "../../../../common/cluster-store/cluster-store";
 import type { CatalogEntityRegistry } from "../../../catalog";
-import type { ClusterManager } from "../../../cluster/manager";
 import type { IComputedValue } from "mobx";
 import type { Theme } from "../../../theme/operating-system-theme-state.injectable";
 import type { AskUserForFilePaths } from "../../../ipc/ask-user-for-file-paths.injectable";
@@ -8,16 +7,13 @@ import type { ApplicationMenuItemTypes } from "../../../../features/application-
 import type { Composite } from "../../../../common/utils/composite/get-composite/get-composite";
 import type { MenuItemRoot } from "../../../../features/application-menu/main/application-menu-item-composite.injectable";
 import type { EmitAppEvent } from "../../../../common/app-event-bus/emit-event.injectable";
-import type { CreateResourceApplier } from "../../../resource-applier/create-resource-applier.injectable";
 interface Dependencies {
     applicationMenuItemComposite: IComputedValue<Composite<ApplicationMenuItemTypes | MenuItemRoot>>;
-    clusterManager: ClusterManager;
     catalogEntityRegistry: CatalogEntityRegistry;
     clusterStore: ClusterStore;
     operatingSystemTheme: IComputedValue<Theme>;
     askUserForFilePaths: AskUserForFilePaths;
     emitAppEvent: EmitAppEvent;
-    createResourceApplier: CreateResourceApplier;
 }
-export declare const setupIpcMainHandlers: ({ applicationMenuItemComposite, clusterManager, catalogEntityRegistry, clusterStore, operatingSystemTheme, askUserForFilePaths, emitAppEvent, createResourceApplier, }: Dependencies) => void;
+export declare const setupIpcMainHandlers: ({ applicationMenuItemComposite, catalogEntityRegistry, clusterStore, operatingSystemTheme, askUserForFilePaths, emitAppEvent, }: Dependencies) => void;
 export {};

package/dist/src/main/get-metrics.injectable.d.ts

@@ -1,6 +1,6 @@
 import type { Cluster } from "../common/cluster/cluster";
 import type { RequestMetricsParams } from "../common/k8s-api/endpoints/metrics.api/request-metrics.injectable";
-export declare type GetMetrics = (cluster: Cluster, prometheusPath: string, queryParams: RequestMetricsParams & {
+export type GetMetrics = (cluster: Cluster, prometheusPath: string, queryParams: RequestMetricsParams & {
     query: string;
 }) => Promise<any>;
 declare const getMetricsInjectable: import("@ogre-tools/injectable").Injectable<GetMetrics, unknown, void>;

package/dist/src/main/helm/exec-helm/exec-env.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("mobx").IComputedValue<Partial<Record<string, string>>>, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("mobx").IComputedValue<Partial<Record<string, string>>>, void>;
+};
+export default _default;

package/dist/src/main/helm/exec-helm/exec-env.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const execHelmEnvInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<Partial<Record<string, string>>>, unknown, void>;
+export default execHelmEnvInjectable;

package/dist/src/main/helm/exec-helm/exec-helm.injectable.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { ExecFileException } from "child_process";
 import type { AsyncResult } from "../../../common/utils/async-result";
-export declare type ExecHelm = (args: string[]) => Promise<AsyncResult<string, ExecFileException & {
+export type ExecHelm = (args: string[]) => Promise<AsyncResult<string, ExecFileException & {
     stderr: string;
 }>>;
 declare const execHelmInjectable: import("@ogre-tools/injectable").Injectable<ExecHelm, unknown, void>;

package/dist/src/main/helm/get-helm-env/get-helm-env.injectable.d.ts

@@ -1,5 +1,5 @@
 import type { AsyncResult } from "../../../common/utils/async-result";
-export declare type HelmEnv = Record<string, string> & {
+export type HelmEnv = Record<string, string> & {
     HELM_REPOSITORY_CACHE?: string;
     HELM_REPOSITORY_CONFIG?: string;
 };

package/dist/src/main/helm/helm-chart-manager-cache.injectable.d.ts

@@ -2,6 +2,6 @@ export interface ChartCacheEntry {
     data: string;
     mtimeMs: number;
 }
-export declare type HelmChartManagerCache = Map<string, ChartCacheEntry>;
+export type HelmChartManagerCache = Map<string, ChartCacheEntry>;
 declare const helmChartManagerCacheInjectable: import("@ogre-tools/injectable").Injectable<HelmChartManagerCache, unknown, void>;
 export default helmChartManagerCacheInjectable;

package/dist/src/main/helm/helm-service/get-helm-release-resources/call-for-kube-resources-by-manifest/call-for-kube-resources-by-manifest.injectable.d.ts

@@ -1,5 +1,5 @@
 import type { JsonObject } from "type-fest";
 import type { KubeJsonApiData } from "../../../../../common/k8s-api/kube-json-api";
-export declare type CallForKubeResourcesByManifest = (namespace: string, kubeconfigPath: string, kubectlPath: string, resourceManifests: KubeJsonApiData[]) => Promise<JsonObject[]>;
+export type CallForKubeResourcesByManifest = (namespace: string, kubeconfigPath: string, kubectlPath: string, resourceManifests: KubeJsonApiData[]) => Promise<JsonObject[]>;
 declare const callForKubeResourcesByManifestInjectable: import("@ogre-tools/injectable").Injectable<CallForKubeResourcesByManifest, unknown, void>;
 export default callForKubeResourcesByManifestInjectable;

package/dist/src/main/helm/helm-service/get-helm-release-resources/call-for-kube-resources-by-manifest/exec-file-with-input/exec-file-with-input.injectable.d.ts

@@ -1,5 +1,5 @@
 import type { AsyncResult } from "../../../../../../common/utils/async-result";
-export declare type ExecFileWithInput = (options: {
+export type ExecFileWithInput = (options: {
     filePath: string;
     commandArguments: string[];
     input: string;

package/dist/src/main/helm/helm-service/get-helm-release-resources/get-helm-release-resources.injectable.d.ts

@@ -1,5 +1,5 @@
 import type { KubeJsonApiData } from "../../../../common/k8s-api/kube-json-api";
 import type { AsyncResult } from "../../../../common/utils/async-result";
-export declare type GetHelmReleaseResources = (name: string, namespace: string, kubeconfigPath: string) => Promise<AsyncResult<KubeJsonApiData[], string>>;
+export type GetHelmReleaseResources = (name: string, namespace: string, kubeconfigPath: string) => Promise<AsyncResult<KubeJsonApiData[], string>>;
 declare const getHelmReleaseResourcesInjectable: import("@ogre-tools/injectable").Injectable<GetHelmReleaseResources, unknown, void>;
 export default getHelmReleaseResourcesInjectable;

package/dist/src/main/helm/helm-service/update-helm-release.injectable.d.ts

@@ -1,8 +1,7 @@
 import type { Cluster } from "../../../common/cluster/cluster";
-import type { JsonObject } from "type-fest";
 export interface UpdateChartArgs {
     chart: string;
-    values: JsonObject;
+    values: string;
     version: string;
 }
 declare const updateHelmReleaseInjectable: import("@ogre-tools/injectable").Injectable<(cluster: Cluster, releaseName: string, namespace: string, data: UpdateChartArgs) => Promise<{

package/dist/src/main/ipc/ask-user-for-file-paths.injectable.d.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { OpenDialogOptions } from "electron";
-export declare type AskUserForFilePaths = (dialogOptions: OpenDialogOptions) => Promise<{
+export type AskUserForFilePaths = (dialogOptions: OpenDialogOptions) => Promise<{
     canceled: boolean;
     filePaths: string[];
 }>;

package/dist/src/main/k8s-request.injectable.d.ts

@@ -4,6 +4,6 @@
  */
 import type { RequestPromiseOptions } from "request-promise-native";
 import type { Cluster } from "../common/cluster/cluster";
-export declare type K8sRequest = (cluster: Cluster, path: string, options?: RequestPromiseOptions) => Promise<any>;
+export type K8sRequest = (cluster: Cluster, path: string, options?: RequestPromiseOptions) => Promise<any>;
 declare const k8SRequestInjectable: import("@ogre-tools/injectable").Injectable<(cluster: Cluster, path: string, options?: RequestPromiseOptions) => Promise<any>, unknown, void>;
 export default k8SRequestInjectable;

package/dist/src/main/kube-auth-proxy/create-kube-auth-proxy.injectable.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { KubeAuthProxy } from "./kube-auth-proxy";
 import type { Cluster } from "../../common/cluster/cluster";
-export declare type CreateKubeAuthProxy = (cluster: Cluster, environmentVariables: NodeJS.ProcessEnv) => KubeAuthProxy;
+export type CreateKubeAuthProxy = (cluster: Cluster, environmentVariables: NodeJS.ProcessEnv) => KubeAuthProxy;
 declare const createKubeAuthProxyInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeAuthProxy, unknown, void>;
 export default createKubeAuthProxyInjectable;

package/dist/src/main/kube-auth-proxy/kube-auth-proxy-certificate.injectable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+/// <reference types="selfsigned" />
+declare const kubeAuthProxyCertificateInjectable: import("@ogre-tools/injectable").Injectable<import("selfsigned").SelfSignedCert, unknown, string>;
+export default kubeAuthProxyCertificateInjectable;

package/dist/src/main/kube-auth-proxy/lens-k8s-proxy-path.injectable.d.ts

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

package/dist/src/main/kube-auth-proxy/wait-until-port-is-used/wait-until-port-is-used.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type WaitUntilPortIsUsed = (port: number, retryAfterMs: number, timeoutAfterMs: number) => Promise<void>;
+export type WaitUntilPortIsUsed = (port: number, retryAfterMs: number, timeoutAfterMs: number) => Promise<void>;
 declare const waitUntilPortIsUsedInjectable: import("@ogre-tools/injectable").Injectable<WaitUntilPortIsUsed, unknown, void>;
 export default waitUntilPortIsUsedInjectable;

package/dist/src/main/kubeconfig-manager/create-kubeconfig-manager.injectable.d.ts

@@ -3,6 +3,6 @@ import { KubeconfigManager } from "./kubeconfig-manager";
 export interface KubeConfigManagerInstantiationParameter {
     cluster: Cluster;
 }
-export declare type CreateKubeconfigManager = (cluster: Cluster) => KubeconfigManager;
+export type CreateKubeconfigManager = (cluster: Cluster) => KubeconfigManager;
 declare const createKubeconfigManagerInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeconfigManager, unknown, void>;
 export default createKubeconfigManagerInjectable;

package/dist/src/main/kubectl/apply-all-handler.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const kubectlApplyAllChannelHandlerInjectable: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<import("../../common/kube-helpers/channels").KubectlApplyAllArgs, import("../../common/utils/async-result").AsyncResult<string, string>>;
+    handler: (req: import("../../common/kube-helpers/channels").KubectlApplyAllArgs) => import("../../common/utils/async-result").AsyncResult<string, string> | Promise<import("../../common/utils/async-result").AsyncResult<string, string>>;
+}, import("../utils/channel/channel-listeners/listener-tokens").RequestChannelListener<import("../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<unknown, unknown>>, void>;
+export default kubectlApplyAllChannelHandlerInjectable;

package/dist/src/main/kubectl/binary-name.injectable.d.ts

@@ -1,2 +1,2 @@
-declare const kubectlBinaryNameInjectable: import("@ogre-tools/injectable").Injectable<"kubectl.exe" | "kubectl", unknown, void>;
+declare const kubectlBinaryNameInjectable: import("@ogre-tools/injectable").Injectable<string, unknown, void>;
 export default kubectlBinaryNameInjectable;

package/dist/src/main/kubectl/delete-all-handler.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const kubectlDeleteAllChannelHandlerInjectable: import("@ogre-tools/injectable").Injectable<{
+    channel: import("../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<import("../../common/kube-helpers/channels").KubectlDeleteAllArgs, import("../../common/utils/async-result").AsyncResult<string, string>>;
+    handler: (req: import("../../common/kube-helpers/channels").KubectlDeleteAllArgs) => import("../../common/utils/async-result").AsyncResult<string, string> | Promise<import("../../common/utils/async-result").AsyncResult<string, string>>;
+}, import("../utils/channel/channel-listeners/listener-tokens").RequestChannelListener<import("../../common/utils/channel/request-channel-listener-injection-token").RequestChannel<unknown, unknown>>, void>;
+export default kubectlDeleteAllChannelHandlerInjectable;

package/dist/src/main/kubectl/kubectl-apply-all.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const kubectlApplyAllInjectable: import("@ogre-tools/injectable").Injectable<(req: import("../../common/kube-helpers/channels").KubectlApplyAllArgs) => Promise<import("../../common/utils/async-result").AsyncResult<string, string>>, (req: import("../../common/kube-helpers/channels").KubectlApplyAllArgs) => Promise<import("../../common/utils/async-result").AsyncResult<string, string>>, void>;
+export default kubectlApplyAllInjectable;

package/dist/src/main/kubectl/kubectl-delete-all.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const kubectlDeleteAllInjectable: import("@ogre-tools/injectable").Injectable<(req: import("../../common/kube-helpers/channels").KubectlDeleteAllArgs) => Promise<import("../../common/utils/async-result").AsyncResult<string, string>>, (req: import("../../common/kube-helpers/channels").KubectlDeleteAllArgs) => Promise<import("../../common/utils/async-result").AsyncResult<string, string>>, void>;
+export default kubectlDeleteAllInjectable;

package/dist/src/main/kubectl/kubectl.d.ts

@@ -5,9 +5,10 @@
 import type { JoinPaths } from "../../common/path/join-paths.injectable";
 import type { GetDirnameOfPath } from "../../common/path/get-dirname.injectable";
 import type { GetBasenameOfPath } from "../../common/path/get-basename.injectable";
+import type { NormalizedPlatform } from "../../common/vars/normalized-platform.injectable";
 export interface KubectlDependencies {
     readonly directoryForKubectlBinaries: string;
-    readonly normalizedDownloadPlatform: "darwin" | "linux" | "windows";
+    readonly normalizedDownloadPlatform: NormalizedPlatform;
     readonly normalizedDownloadArch: "amd64" | "arm64" | "386";
     readonly kubectlBinaryName: string;
     readonly bundledKubectlBinaryPath: string;

package/dist/src/main/lens-proxy/lens-proxy.d.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 /// <reference types="node" />
-import type http from "http";
+import http from "http";
 import type httpProxy from "http-proxy";
 import type { Router } from "../router/router";
 import type { ClusterContextHandler } from "../context-handler/context-handler";
@@ -12,8 +12,8 @@ import type { ProxyApiRequestArgs } from "./proxy-functions";
 import type { SetRequired } from "type-fest";
 import type { EmitAppEvent } from "../../common/app-event-bus/emit-event.injectable";
 import type { Logger } from "../../common/logger";
-declare type GetClusterForRequest = (req: http.IncomingMessage) => Cluster | undefined;
-export declare type ServerIncomingMessage = SetRequired<http.IncomingMessage, "url" | "method">;
+type GetClusterForRequest = (req: http.IncomingMessage) => Cluster | undefined;
+export type ServerIncomingMessage = SetRequired<http.IncomingMessage, "url" | "method">;
 interface Dependencies {
     getClusterForRequest: GetClusterForRequest;
     shellApiRequest: (args: ProxyApiRequestArgs) => void | Promise<void>;

package/dist/src/main/logger/level.injectable.d.ts

@@ -1,3 +1,3 @@
-export declare type LogLevel = "silly" | "debug" | "info" | "warn" | "error";
+export type LogLevel = "silly" | "debug" | "info" | "warn" | "error";
 declare const logLevelInjectable: import("@ogre-tools/injectable").Injectable<LogLevel, unknown, void>;
 export default logLevelInjectable;

package/dist/src/main/prometheus/get-by-kind.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { PrometheusProvider } from "./provider";
+export type GetPrometheusProviderByKind = (kind: string) => PrometheusProvider;
+declare const getPrometheusProviderByKindInjectable: import("@ogre-tools/injectable").Injectable<GetPrometheusProviderByKind, unknown, void>;
+export default getPrometheusProviderByKindInjectable;

package/dist/src/main/prometheus/helm-14-provider.injectable.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.
+ */
+declare const helm14PrometheusProviderInjectable: import("@ogre-tools/injectable").Injectable<import("./provider").PrometheusProvider, import("./provider").PrometheusProvider, void>;
+export default helm14PrometheusProviderInjectable;

package/dist/src/main/prometheus/helm-provider.injectable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { PrometheusProvider } from "./provider";
+export declare const getHelmLikeQueryFor: ({ rateAccuracy }: {
+    rateAccuracy: string;
+}) => PrometheusProvider["getQuery"];
+declare const helmPrometheusProviderInjectable: import("@ogre-tools/injectable").Injectable<PrometheusProvider, PrometheusProvider, void>;
+export default helmPrometheusProviderInjectable;

package/dist/src/main/prometheus/lens-provider.injectable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { PrometheusProvider } from "./provider";
+export declare const getLensLikeQueryFor: ({ rateAccuracy }: {
+    rateAccuracy: string;
+}) => PrometheusProvider["getQuery"];
+declare const lensPrometheusProviderInjectable: import("@ogre-tools/injectable").Injectable<PrometheusProvider, PrometheusProvider, void>;
+export default lensPrometheusProviderInjectable;

package/dist/src/main/prometheus/operator-provider.injectable.ts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { PrometheusProvider } from "./provider";
+export declare const getOperatorLikeQueryFor: ({ rateAccuracy }: {
+    rateAccuracy: string;
+}) => PrometheusProvider["getQuery"];
+declare const operatorPrometheusProviderInjectable: import("@ogre-tools/injectable").Injectable<PrometheusProvider, PrometheusProvider, void>;
+export default operatorPrometheusProviderInjectable;

package/dist/src/main/prometheus/provider.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { CoreV1Api } from "@kubernetes/client-node";
+export interface PrometheusService extends PrometheusServiceInfo {
+    kind: string;
+}
+export interface PrometheusServiceInfo {
+    namespace: string;
+    service: string;
+    port: number;
+}
+export interface PrometheusProvider {
+    readonly kind: string;
+    readonly name: string;
+    readonly isConfigurable: boolean;
+    getQuery(opts: Record<string, string>, queryName: string): string;
+    getPrometheusService(client: CoreV1Api): Promise<PrometheusService>;
+}
+export interface CreatePrometheusProviderOpts {
+    readonly kind: string;
+    readonly name: string;
+    readonly isConfigurable: boolean;
+    getQuery(opts: Record<string, string>, queryName: string): string;
+    getService(client: CoreV1Api): Promise<PrometheusServiceInfo>;
+}
+export declare const createPrometheusProvider: ({ getService, ...opts }: CreatePrometheusProviderOpts) => PrometheusProvider;
+export declare function findFirstNamespacedService(client: CoreV1Api, ...selectors: string[]): Promise<PrometheusServiceInfo>;
+export declare function findNamespacedService(client: CoreV1Api, name: string, namespace: string): Promise<PrometheusServiceInfo>;
+export interface BytesSentArgs {
+    rateAccuracy: string;
+    ingress: string;
+    namespace: string;
+    statuses: string;
+}
+export declare function bytesSent({ rateAccuracy, ingress, namespace, statuses }: BytesSentArgs): string;
+export declare const prometheusProviderInjectionToken: import("@ogre-tools/injectable").InjectionToken<PrometheusProvider, void>;

package/dist/src/main/prometheus/providers.injectable.d.ts

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

package/dist/src/main/prometheus/stacklight-provider.injectable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { PrometheusProvider } from "./provider";
+export declare const getStacklightLikeQueryFor: ({ rateAccuracy }: {
+    rateAccuracy: string;
+}) => PrometheusProvider["getQuery"];
+declare const stacklightPrometheusProviderInjectable: import("@ogre-tools/injectable").Injectable<PrometheusProvider, PrometheusProvider, void>;
+export default stacklightPrometheusProviderInjectable;

package/dist/src/main/resource-applier/create-resource-applier.injectable.d.ts

@@ -1,5 +1,5 @@
 import type { Cluster } from "../../common/cluster/cluster";
 import { ResourceApplier } from "./resource-applier";
-export declare type CreateResourceApplier = (cluster: Cluster) => ResourceApplier;
+export type CreateResourceApplier = (cluster: Cluster) => ResourceApplier;
 declare const createResourceApplierInjectable: import("@ogre-tools/injectable").Injectable<CreateResourceApplier, unknown, void>;
 export default createResourceApplierInjectable;

package/dist/src/main/resource-applier/resource-applier.d.ts

@@ -10,6 +10,7 @@ import type { WriteFile } from "../../common/fs/write-file.injectable";
 import type { DeleteFile } from "../../common/fs/delete-file.injectable";
 import type { ExecFile } from "../../common/fs/exec-file.injectable";
 import type { JoinPaths } from "../../common/path/join-paths.injectable";
+import type { AsyncResult } from "../../common/utils/async-result";
 export interface ResourceApplierDependencies {
     emitAppEvent: EmitAppEvent;
     writeFile: WriteFile;
@@ -30,10 +31,10 @@ export declare class ResourceApplier {
      * @param ns The optional namespace of the kube resource
      */
     patch(name: string, kind: string, patch: Patch, ns?: string): Promise<string>;
-    create(resource: string): Promise<string>;
-    protected kubectlApply(content: string): Promise<string>;
-    kubectlApplyAll(resources: string[], extraArgs?: string[]): Promise<string>;
-    kubectlDeleteAll(resources: string[], extraArgs?: string[]): Promise<string>;
-    protected kubectlCmdAll(subCmd: string, resources: string[], parentArgs?: string[]): Promise<string>;
+    create(resource: string): Promise<AsyncResult<string, string>>;
+    protected kubectlApply(content: string): Promise<AsyncResult<string, string>>;
+    kubectlApplyAll(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    kubectlDeleteAll(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    protected kubectlCmdAll(subCmd: string, resources: string[], parentArgs?: string[]): Promise<AsyncResult<string, string>>;
     protected sanitizeObject(resource: string): string;
 }

package/dist/src/main/router/create-handler-for-route.injectable.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { ServerResponse } from "http";
 import type { LensApiRequest, Route } from "./route";
-export declare type RouteHandler = (request: LensApiRequest<string>, response: ServerResponse) => Promise<void>;
-export declare type CreateHandlerForRoute = (route: Route<unknown, string>) => RouteHandler;
+export type RouteHandler = (request: LensApiRequest<string>, response: ServerResponse) => Promise<void>;
+export type CreateHandlerForRoute = (route: Route<unknown, string>) => RouteHandler;
 declare const createHandlerForRouteInjectable: import("@ogre-tools/injectable").Injectable<CreateHandlerForRoute, unknown, void>;
 export default createHandlerForRouteInjectable;

package/dist/src/main/router/parse-request.injectable.d.ts

@@ -1,4 +1,4 @@
 import Subtext from "@hapi/subtext";
-export declare type ParseRequest = typeof Subtext.parse;
+export type ParseRequest = typeof Subtext.parse;
 declare const parseRequestInjectable: import("@ogre-tools/injectable").Injectable<typeof Subtext.parse, unknown, void>;
 export default parseRequestInjectable;

package/dist/src/main/router/route.d.ts

@@ -10,8 +10,8 @@ import type httpProxy from "http-proxy";
 import type { LensApiResultContentType } from "./router-content-types";
 import type { URLSearchParams } from "url";
 import type Joi from "joi";
-export declare type InferParam<T extends string, PathParams extends Record<string, string>> = T extends `{${infer P}?}` ? PathParams & Partial<Record<P, string>> : T extends `{${infer P}}` ? PathParams & Record<P, string> : PathParams;
-export declare type InferParamFromPath<P extends string> = P extends `${string}/{${infer B}*}${infer Tail}` ? Tail extends "" ? Record<B, string> : never : P extends `${infer A}/${infer B}` ? InferParam<A, InferParamFromPath<B>> : InferParam<P, {}>;
+export type InferParam<T extends string, PathParams extends Record<string, string>> = T extends `{${infer P}?}` ? PathParams & Partial<Record<P, string>> : T extends `{${infer P}}` ? PathParams & Record<P, string> : PathParams;
+export type InferParamFromPath<P extends string> = P extends `${string}/{${infer B}*}${infer Tail}` ? Tail extends "" ? Record<B, string> : never : P extends `${infer A}/${infer B}` ? InferParam<A, InferParamFromPath<B>> : InferParam<P, {}>;
 export interface LensApiRequest<Path extends string> {
     path: Path;
     payload: unknown;
@@ -34,7 +34,7 @@ export interface LensApiResult<Response> {
     headers?: Partial<Record<string, string>>;
     proxy?: httpProxy;
 }
-export declare type RouteResponse<Response> = LensApiResult<Response> | void;
+export type RouteResponse<Response> = LensApiResult<Response> | void;
 export interface RouteHandler<TResponse, Path extends string> {
     (request: LensApiRequest<Path>): RouteResponse<TResponse> | Promise<RouteResponse<TResponse>>;
 }

package/dist/src/main/router/router-content-types.d.ts

@@ -10,5 +10,5 @@ export interface LensApiResultContentType {
         headers: Record<string, string>;
     });
 }
-export declare type SupportedFileExtension = "json" | "txt" | "html" | "css" | "gif" | "jpg" | "png" | "svg" | "js" | "woff2" | "ttf";
+export type SupportedFileExtension = "json" | "txt" | "html" | "css" | "gif" | "jpg" | "png" | "svg" | "js" | "woff2" | "ttf";
 export declare const contentTypes: Record<SupportedFileExtension, LensApiResultContentType>;

package/dist/src/main/routes/resource-applier/create-resource-route.injectable.d.ts

@@ -1,2 +1,14 @@
-declare const createResourceRouteInjectable: import("@ogre-tools/injectable").Injectable<import("../../router/route").Route<string, "/api/stack">, import("../../router/route").Route<string, "/api/stack">, void>;
+declare const createResourceRouteInjectable: import("@ogre-tools/injectable").Injectable<import("../../router/route").Route<{
+    callWasSuccessful: true;
+    response: string;
+} | {
+    callWasSuccessful: false;
+    error: string;
+}, "/api/stack">, import("../../router/route").Route<{
+    callWasSuccessful: true;
+    response: string;
+} | {
+    callWasSuccessful: false;
+    error: string;
+}, "/api/stack">, void>;
 export default createResourceRouteInjectable;

package/dist/src/main/shell-session/create-shell-session.injectable.d.ts

@@ -6,6 +6,6 @@ export interface OpenShellSessionArgs {
     tabId: string;
     nodeName?: string;
 }
-export declare type OpenShellSession = (args: OpenShellSessionArgs) => Promise<void>;
+export type OpenShellSession = (args: OpenShellSessionArgs) => Promise<void>;
 declare const openShellSessionInjectable: import("@ogre-tools/injectable").Injectable<OpenShellSession, unknown, void>;
 export default openShellSessionInjectable;

package/dist/src/main/shell-session/local-shell-session/open.injectable.d.ts

@@ -5,6 +5,6 @@ export interface OpenLocalShellSessionArgs {
     cluster: Cluster;
     tabId: string;
 }
-export declare type OpenLocalShellSession = (args: OpenLocalShellSessionArgs) => Promise<void>;
+export type OpenLocalShellSession = (args: OpenLocalShellSessionArgs) => Promise<void>;
 declare const openLocalShellSessionInjectable: import("@ogre-tools/injectable").Injectable<OpenLocalShellSession, unknown, void>;
 export default openLocalShellSessionInjectable;

package/dist/src/main/shell-session/shell-env-modifier/modify-terminal-shell-env.injectable.d.ts

@@ -3,6 +3,6 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { ClusterId } from "../../../common/cluster-types";
-export declare type ModifyTerminalShellEnv = (clusterId: ClusterId, env: Partial<Record<string, string>>) => Partial<Record<string, string>>;
+export type ModifyTerminalShellEnv = (clusterId: ClusterId, env: Partial<Record<string, string>>) => Partial<Record<string, string>>;
 declare const modifyTerminalShellEnvInjectable: import("@ogre-tools/injectable").Injectable<ModifyTerminalShellEnv, unknown, void>;
 export default modifyTerminalShellEnvInjectable;

package/dist/src/main/shell-session/shell-env-modifier/shell-env-modifier-registration.d.ts

@@ -6,4 +6,4 @@ import type { CatalogEntity } from "../../../common/catalog";
 export interface ShellEnvContext {
     catalogEntity: CatalogEntity;
 }
-export declare type ShellEnvModifier = (ctx: ShellEnvContext, env: Record<string, string | undefined>) => Record<string, string | undefined>;
+export type ShellEnvModifier = (ctx: ShellEnvContext, env: Record<string, string | undefined>) => Record<string, string | undefined>;

package/dist/src/main/shell-session/shell-session.d.ts

@@ -8,7 +8,7 @@ import type WebSocket from "ws";
 import type * as pty from "node-pty";
 import { type TerminalMessage } from "../../common/terminal/channels";
 import type { Logger } from "../../common/logger";
-import type { ComputeShellEnvironment } from "../utils/shell-env/compute-shell-environment.injectable";
+import type { ComputeShellEnvironment } from "../../features/shell-sync/main/compute-shell-environment.injectable";
 import type { SpawnPty } from "./spawn-pty.injectable";
 import type { InitializableState } from "../../common/initializable-state/create";
 import type { EmitAppEvent } from "../../common/app-event-bus/emit-event.injectable";

package/dist/src/main/shell-session/spawn-pty.injectable.d.ts

@@ -1,11 +1,11 @@
 import type { IPty, IPtyForkOptions, IWindowsPtyForkOptions } from "node-pty";
-export declare type WindowsSpawnPtyOptions = Omit<IWindowsPtyForkOptions, "env"> & {
+export type WindowsSpawnPtyOptions = Omit<IWindowsPtyForkOptions, "env"> & {
     env?: Partial<Record<string, string>>;
 };
-export declare type UnixSpawnPtyOptions = Omit<IPtyForkOptions, "env"> & {
+export type UnixSpawnPtyOptions = Omit<IPtyForkOptions, "env"> & {
     env?: Partial<Record<string, string>>;
 };
-export declare type SpawnPtyOptions = UnixSpawnPtyOptions | WindowsSpawnPtyOptions;
-export declare type SpawnPty = (file: string, args: string[], options: SpawnPtyOptions) => IPty;
+export type SpawnPtyOptions = UnixSpawnPtyOptions | WindowsSpawnPtyOptions;
+export type SpawnPty = (file: string, args: string[], options: SpawnPtyOptions) => IPty;
 declare const spawnPtyInjectable: import("@ogre-tools/injectable").Injectable<SpawnPty, unknown, void>;
 export default spawnPtyInjectable;