@k8slens/extensions 6.1.1-git.f594f961c6.0 → 6.1.1-git.fced6e6554.0

package/dist/src/common/k8s-api/endpoints/deployment.api.d.ts

@@ -4,7 +4,7 @@
  */
 import type { DerivedKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
-import type { PodMetricData, PodSpec } from "./pod.api";
+import type { PodSpec } from "./pod.api";
 import type { KubeObjectStatus, LabelSelector, NamespaceScopedMetadata } from "../kube-object";
 import { KubeObject } from "../kube-object";
 export declare class DeploymentApi extends KubeApi<Deployment> {
@@ -26,7 +26,6 @@ export declare class DeploymentApi extends KubeApi<Deployment> {
         name: string;
     }): Promise<import("../kube-json-api").KubeJsonApiData<import("../kube-object").KubeJsonApiObjectMetadata<import("../kube-object").KubeObjectScope>, unknown, unknown>>;
 }
-export declare function getMetricsForDeployments(deployments: Deployment[], namespace: string, selector?: string): Promise<PodMetricData>;
 export interface DeploymentSpec {
     replicas: number;
     selector: LabelSelector;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-charts.injectable.d.ts

@@ -0,0 +1,9 @@
+import type { RawHelmChart } from "../helm-charts.api";
+import { HelmChart } from "../helm-charts.api";
+export declare type RequestHelmCharts = () => Promise<HelmChart[]>;
+export declare type RepoHelmChartList = Record<string, RawHelmChart[]>;
+/**
+ * Get a list of all helm charts from all saved helm repos
+ */
+declare const requestHelmChartsInjectable: import("@ogre-tools/injectable").Injectable<() => Promise<HelmChart[]>, unknown, void>;
+export default requestHelmChartsInjectable;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-readme.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<string>;
+declare const requestHelmChartReadmeInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartReadme, unknown, void>;
+export default requestHelmChartReadmeInjectable;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-values.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<string>;
+declare const requestHelmChartValuesInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartValues, unknown, void>;
+export default requestHelmChartValuesInjectable;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-versions.injectable.d.ts

@@ -0,0 +1,4 @@
+import { HelmChart } from "../helm-charts.api";
+export declare type RequestHelmChartVersions = (repo: string, chartName: string) => Promise<HelmChart[]>;
+declare const requestHelmChartVersionsInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartVersions, unknown, void>;
+export default requestHelmChartVersionsInjectable;

package/dist/src/common/k8s-api/endpoints/helm-charts.api.d.ts

@@ -2,35 +2,6 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { RequestInit } from "node-fetch";
-export declare type RepoHelmChartList = Record<string, RawHelmChart[]>;
-export interface IHelmChartDetails {
-    readme: string;
-    versions: HelmChart[];
-}
-/**
- * Get a list of all helm charts from all saved helm repos
- */
-export declare function listCharts(): Promise<HelmChart[]>;
-export interface GetChartDetailsOptions {
-    version?: string;
-    reqInit?: RequestInit;
-}
-/**
- * Get the readme and all versions of a chart
- * @param repo The repo to get from
- * @param name The name of the chart to request the data of
- * @param options.version The version of the chart's readme to get, default latest
- * @param options.reqInit A way for passing in an abort controller or other browser request options
- */
-export declare function getChartDetails(repo: string, name: string, { version, reqInit }?: GetChartDetailsOptions): Promise<IHelmChartDetails>;
-/**
- * Get chart values related to a specific repos' version of a chart
- * @param repo The repo to get from
- * @param name The name of the chart to request the data of
- * @param version The version to get the values from
- */
-export declare function getChartValues(repo: string, name: string, version: string): Promise<string>;
 export interface RawHelmChart {
     apiVersion: string;
     name: string;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-configuration.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("./request-configuration.injectable").RequestHelmReleaseConfiguration, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./request-configuration.injectable").RequestHelmReleaseConfiguration, void>;
+};
+export default _default;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-configuration.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestHelmReleaseConfiguration = (name: string, namespace: string, all: boolean) => Promise<string>;
+declare const requestHelmReleaseConfigurationInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseConfiguration, unknown, void>;
+export default requestHelmReleaseConfigurationInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-create.injectable.d.ts

@@ -0,0 +1,12 @@
+import type { HelmReleaseUpdateDetails } from "../helm-releases.api";
+interface HelmReleaseCreatePayload {
+    name?: string;
+    repo: string;
+    chart: string;
+    namespace: string;
+    version: string;
+    values: string;
+}
+export declare type RequestCreateHelmRelease = (payload: HelmReleaseCreatePayload) => Promise<HelmReleaseUpdateDetails>;
+declare const requestCreateHelmReleaseInjectable: import("@ogre-tools/injectable").Injectable<RequestCreateHelmRelease, unknown, void>;
+export default requestCreateHelmReleaseInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-delete.injectable.d.ts

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

package/dist/src/{renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release-details/call-for-helm-release-details.injectable.d.ts → common/k8s-api/endpoints/helm-releases.api/request-details.injectable.d.ts}

@@ -1,4 +1,4 @@
-import type { KubeJsonApiData } from "../../../../../../../common/k8s-api/kube-json-api";
+import type { KubeJsonApiData } from "../../kube-json-api";
 export interface HelmReleaseDetails {
     resources: KubeJsonApiData[];
     name: string;
@@ -16,5 +16,5 @@ export interface HelmReleaseDetails {
     };
 }
 export declare type CallForHelmReleaseDetails = (name: string, namespace: string) => Promise<HelmReleaseDetails>;
-declare const callForHelmReleaseDetailsInjectable: import("@ogre-tools/injectable").Injectable<CallForHelmReleaseDetails, unknown, void>;
-export default callForHelmReleaseDetailsInjectable;
+declare const requestHelmReleaseDetailsInjectable: import("@ogre-tools/injectable").Injectable<CallForHelmReleaseDetails, unknown, void>;
+export default requestHelmReleaseDetailsInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-history.injectable.d.ts

@@ -0,0 +1,11 @@
+export interface HelmReleaseRevision {
+    revision: number;
+    updated: string;
+    status: string;
+    chart: string;
+    app_version: string;
+    description: string;
+}
+export declare type RequestHelmReleaseHistory = (name: string, namespace: string) => Promise<HelmReleaseRevision[]>;
+declare const requestHelmReleaseHistoryInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseHistory, unknown, void>;
+export default requestHelmReleaseHistoryInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-releases.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { HelmReleaseDto } from "../helm-releases.api";
+export declare type RequestHelmReleases = (namespace?: string) => Promise<HelmReleaseDto[]>;
+declare const requestHelmReleasesInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleases, unknown, void>;
+export default requestHelmReleasesInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-rollback.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestHelmReleaseRollback = (name: string, namespace: string, revision: number) => Promise<void>;
+declare const requestHelmReleaseRollbackInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseRollback, unknown, void>;
+export default requestHelmReleaseRollbackInjectable;

package/dist/src/{renderer/components/+helm-releases/update-release/call-for-helm-release-update/call-for-helm-release-update.injectable.d.ts → common/k8s-api/endpoints/helm-releases.api/request-update.injectable.d.ts}

@@ -4,11 +4,11 @@ interface HelmReleaseUpdatePayload {
     version: string;
     values: string;
 }
-export declare type CallForHelmReleaseUpdate = (name: string, namespace: string, payload: HelmReleaseUpdatePayload) => Promise<{
+export declare type RequestHelmReleaseUpdate = (name: string, namespace: string, payload: HelmReleaseUpdatePayload) => Promise<{
     updateWasSuccessful: true;
 } | {
     updateWasSuccessful: false;
     error: unknown;
 }>;
-declare const callForHelmReleaseUpdateInjectable: import("@ogre-tools/injectable").Injectable<CallForHelmReleaseUpdate, unknown, void>;
-export default callForHelmReleaseUpdateInjectable;
+declare const requestHelmReleaseUpdateInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseUpdate, unknown, void>;
+export default requestHelmReleaseUpdateInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-values.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestHelmReleaseValues = (name: string, namespace: string, all?: boolean) => Promise<string>;
+declare const requestHelmReleaseValuesInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseValues, unknown, void>;
+export default requestHelmReleaseValuesInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api.d.ts

@@ -3,38 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { ItemObject } from "../../item.store";
-import type { JsonApiData } from "../json-api";
-import type { HelmReleaseDetails } from "../../../renderer/components/+helm-releases/release-details/release-details-model/call-for-helm-release/call-for-helm-release-details/call-for-helm-release-details.injectable";
+import type { HelmReleaseDetails } from "./helm-releases.api/request-details.injectable";
 export interface HelmReleaseUpdateDetails {
     log: string;
     release: HelmReleaseDetails;
 }
-export interface HelmReleaseRevision {
-    revision: number;
-    updated: string;
-    status: string;
-    chart: string;
-    app_version: string;
-    description: string;
-}
-declare type EndpointParams = {} | {
-    namespace: string;
-} | {
-    namespace: string;
-    name: string;
-} | {
-    namespace: string;
-    name: string;
-    route: string;
-};
-interface EndpointQuery {
-    all?: boolean;
-}
-export declare const endpoint: (params?: EndpointParams | undefined, query?: EndpointQuery | undefined, fragment?: string | undefined) => string;
-export declare function deleteRelease(name: string, namespace: string): Promise<JsonApiData>;
-export declare function getReleaseValues(name: string, namespace: string, all?: boolean): Promise<string>;
-export declare function getReleaseHistory(name: string, namespace: string): Promise<HelmReleaseRevision[]>;
-export declare function rollbackRelease(name: string, namespace: string, revision: number): Promise<JsonApiData>;
 export interface HelmReleaseDto {
     appVersion: string;
     name: string;
@@ -53,4 +26,3 @@ export interface HelmRelease extends HelmReleaseDto, ItemObject {
     getUpdated: (humanize?: boolean, compact?: boolean) => string | number;
     getRepo: () => Promise<string>;
 }
-export {};

package/dist/src/common/k8s-api/endpoints/index.d.ts

@@ -30,6 +30,7 @@ export * from "./replica-set.api";
 export * from "./resource-quota.api";
 export * from "./role.api";
 export * from "./role-binding.api";
+export * from "./runtime-class.api";
 export * from "./secret.api";
 export * from "./self-subject-rules-reviews.api";
 export * from "./service.api";

package/dist/src/common/k8s-api/endpoints/ingress.api.d.ts

@@ -4,20 +4,12 @@
  */
 import type { NamespaceScopedMetadata, TypedLocalObjectReference } from "../kube-object";
 import { KubeObject } from "../kube-object";
-import type { MetricData } from "./metrics.api";
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
 import type { RequireExactlyOne } from "type-fest";
 export declare class IngressApi extends KubeApi<Ingress> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForIngress(ingress: string, namespace: string): Promise<IngressMetricData>;
-export interface IngressMetricData extends Partial<Record<string, MetricData>> {
-    bytesSentSuccess: MetricData;
-    bytesSentFailure: MetricData;
-    requestDurationSeconds: MetricData;
-    responseDurationSeconds: MetricData;
-}
 export interface ILoadBalancerIngress {
     hostname?: string;
     ip?: string;

package/dist/src/common/k8s-api/endpoints/job.api.d.ts

@@ -4,7 +4,7 @@
  */
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
-import type { PodMetricData, PodSpec } from "./pod.api";
+import type { PodSpec } from "./pod.api";
 import type { Container } from "./types/container";
 import type { KubeObjectStatus, LabelSelector, NamespaceScopedMetadata } from "../kube-object";
 import { KubeObject } from "../kube-object";
@@ -53,4 +53,3 @@ export declare class Job extends KubeObject<NamespaceScopedMetadata, JobStatus,
 export declare class JobApi extends KubeApi<Job> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForJobs(jobs: Job[], namespace: string, selector?: string): Promise<PodMetricData>;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-cluster-metrics-by-node-names.injectable.d.ts

@@ -0,0 +1,22 @@
+import type { MetricData } from "../metrics.api";
+import type { RequestMetricsParams } from "./request-metrics.injectable";
+export interface ClusterMetricData {
+    memoryUsage: MetricData;
+    memoryRequests: MetricData;
+    memoryLimits: MetricData;
+    memoryCapacity: MetricData;
+    memoryAllocatableCapacity: MetricData;
+    cpuUsage: MetricData;
+    cpuRequests: MetricData;
+    cpuLimits: MetricData;
+    cpuCapacity: MetricData;
+    cpuAllocatableCapacity: MetricData;
+    podUsage: MetricData;
+    podCapacity: MetricData;
+    podAllocatableCapacity: MetricData;
+    fsSize: MetricData;
+    fsUsage: MetricData;
+}
+export declare type RequestClusterMetricsByNodeNames = (nodeNames: string[], params?: RequestMetricsParams) => Promise<ClusterMetricData>;
+declare const requestClusterMetricsByNodeNamesInjectable: import("@ogre-tools/injectable").Injectable<RequestClusterMetricsByNodeNames, unknown, void>;
+export default requestClusterMetricsByNodeNamesInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-ingress-metrics.injectable.d.ts

@@ -0,0 +1,10 @@
+import type { MetricData } from "../metrics.api";
+export interface IngressMetricData {
+    bytesSentSuccess: MetricData;
+    bytesSentFailure: MetricData;
+    requestDurationSeconds: MetricData;
+    responseDurationSeconds: MetricData;
+}
+export declare type RequestIngressMetrics = (ingress: string, namespace: string) => Promise<IngressMetricData>;
+declare const requestIngressMetricsInjectable: import("@ogre-tools/injectable").Injectable<RequestIngressMetrics, unknown, void>;
+export default requestIngressMetricsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-metrics-for-all-nodes.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { MetricData } from "../metrics.api";
+export interface NodeMetricData {
+    memoryUsage: MetricData;
+    workloadMemoryUsage: MetricData;
+    memoryCapacity: MetricData;
+    memoryAllocatableCapacity: MetricData;
+    cpuUsage: MetricData;
+    cpuCapacity: MetricData;
+    fsUsage: MetricData;
+    fsSize: MetricData;
+}
+export declare type RequestAllNodeMetrics = () => Promise<NodeMetricData>;
+declare const requestAllNodeMetricsInjectable: import("@ogre-tools/injectable").Injectable<RequestAllNodeMetrics, unknown, void>;
+export default requestAllNodeMetricsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-metrics.injectable.d.ts

@@ -0,0 +1,32 @@
+import type { MetricData } from "../metrics.api";
+export interface RequestMetricsParams {
+    /**
+     * timestamp in seconds or valid date-string
+     */
+    start?: number | string;
+    /**
+     * timestamp in seconds or valid date-string
+     */
+    end?: number | string;
+    /**
+     * step in seconds
+     * @default 60 (1 minute)
+     */
+    step?: number;
+    /**
+     * time-range in seconds for data aggregation
+     * @default 3600 (1 hour)
+     */
+    range?: number;
+    /**
+     * rbac-proxy validation param
+     */
+    namespace?: string;
+}
+export interface RequestMetrics {
+    (query: string, params?: RequestMetricsParams): Promise<MetricData>;
+    (query: string[], params?: RequestMetricsParams): Promise<MetricData[]>;
+    <Keys extends string>(query: Record<Keys, Partial<Record<string, string>>>, params?: RequestMetricsParams): Promise<Record<Keys, MetricData>>;
+}
+declare const requestMetricsInjectable: import("@ogre-tools/injectable").Injectable<RequestMetrics, unknown, void>;
+export default requestMetricsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-persistent-volume-claim-metrics.injectable.d.ts

@@ -0,0 +1,9 @@
+import type { MetricData } from "../metrics.api";
+import type { PersistentVolumeClaim } from "../persistent-volume-claim.api";
+export interface PersistentVolumeClaimMetricData {
+    diskUsage: MetricData;
+    diskCapacity: MetricData;
+}
+export declare type RequestPersistentVolumeClaimMetrics = (claim: PersistentVolumeClaim) => Promise<PersistentVolumeClaimMetricData>;
+declare const requestPersistentVolumeClaimMetricsInjectable: import("@ogre-tools/injectable").Injectable<RequestPersistentVolumeClaimMetrics, unknown, void>;
+export default requestPersistentVolumeClaimMetricsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-for-daemon-sets.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonSet } from "../daemon-set.api";
+import type { MetricData } from "../metrics.api";
+export interface DaemonSetPodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsForDaemonSets = (daemonsets: DaemonSet[], namespace: string, selector?: string) => Promise<DaemonSetPodMetricData>;
+declare const requestPodMetricsForDaemonSetsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsForDaemonSets, unknown, void>;
+export default requestPodMetricsForDaemonSetsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-for-deployments.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { Deployment } from "../deployment.api";
+import type { MetricData } from "../metrics.api";
+export interface DeploymentPodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsForDeployments = (deployments: Deployment[], namespace: string, selector?: string) => Promise<DeploymentPodMetricData>;
+declare const requestPodMetricsForDeploymentsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsForDeployments, unknown, void>;
+export default requestPodMetricsForDeploymentsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-for-jobs.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { Job } from "../job.api";
+import type { MetricData } from "../metrics.api";
+export interface JobPodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsForJobs = (jobs: Job[], namespace: string, selector?: string) => Promise<JobPodMetricData>;
+declare const requestPodMetricsForJobsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsForJobs, unknown, void>;
+export default requestPodMetricsForJobsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-for-replica-sets.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { MetricData } from "../metrics.api";
+import type { ReplicaSet } from "../replica-set.api";
+export interface ReplicaSetPodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsForReplicaSets = (replicaSets: ReplicaSet[], namespace: string, selector?: string) => Promise<ReplicaSetPodMetricData>;
+declare const requestPodMetricsForReplicaSetsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsForReplicaSets, unknown, void>;
+export default requestPodMetricsForReplicaSetsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-for-stateful-sets.injectable.d.ts

@@ -0,0 +1,14 @@
+import type { MetricData } from "../metrics.api";
+import type { StatefulSet } from "../stateful-set.api";
+export interface StatefulSetPodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsForStatefulSets = (statefulSets: StatefulSet[], namespace: string, selector?: string) => Promise<StatefulSetPodMetricData>;
+declare const requestPodMetricsForStatefulSetsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsForStatefulSets, unknown, void>;
+export default requestPodMetricsForStatefulSetsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics-in-namespace.injectable.d.ts

@@ -0,0 +1,13 @@
+import type { MetricData } from "../metrics.api";
+export interface PodMetricInNamespaceData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+}
+export declare type RequestPodMetricsInNamespace = (namespace: string, selector?: string) => Promise<PodMetricInNamespaceData>;
+declare const requestPodMetricsInNamespaceInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetricsInNamespace, unknown, void>;
+export default requestPodMetricsInNamespaceInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-pod-metrics.injectable.d.ts

@@ -0,0 +1,18 @@
+import type { MetricData } from "../metrics.api";
+import type { Pod } from "../pod.api";
+export interface PodMetricData {
+    cpuUsage: MetricData;
+    memoryUsage: MetricData;
+    fsUsage: MetricData;
+    fsWrites: MetricData;
+    fsReads: MetricData;
+    networkReceive: MetricData;
+    networkTransmit: MetricData;
+    cpuRequests: MetricData;
+    cpuLimits: MetricData;
+    memoryRequests: MetricData;
+    memoryLimits: MetricData;
+}
+export declare type RequestPodMetrics = (pods: Pod[], namespace: string, selector?: string) => Promise<PodMetricData>;
+declare const requestPodMetricsInjectable: import("@ogre-tools/injectable").Injectable<RequestPodMetrics, unknown, void>;
+export default requestPodMetricsInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api/request-providers.injectable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export interface MetricProviderInfo {
+    name: string;
+    id: string;
+    isConfigurable: boolean;
+}
+export declare type RequestMetricsProviders = () => Promise<MetricProviderInfo[]>;
+declare const requestMetricsProvidersInjectable: import("@ogre-tools/injectable").Injectable<RequestMetricsProviders, unknown, void>;
+export default requestMetricsProvidersInjectable;

package/dist/src/common/k8s-api/endpoints/metrics.api.d.ts

@@ -21,37 +21,7 @@ export interface MetricResult {
     };
     values: [number, string][];
 }
-export interface MetricProviderInfo {
-    name: string;
-    id: string;
-    isConfigurable: boolean;
-}
-export interface IMetricsReqParams {
-    start?: number | string;
-    end?: number | string;
-    step?: number;
-    range?: number;
-    namespace?: string;
-}
-export interface IResourceMetrics<T extends MetricData> {
-    [metric: string]: T;
-    cpuUsage: T;
-    memoryUsage: T;
-    fsUsage: T;
-    fsWrites: T;
-    fsReads: T;
-    networkReceive: T;
-    networkTransmit: T;
-}
-declare function getMetrics(query: string, reqParams?: IMetricsReqParams): Promise<MetricData>;
-declare function getMetrics(query: string[], reqParams?: IMetricsReqParams): Promise<MetricData[]>;
-declare function getMetrics<MetricNames extends string>(query: Record<MetricNames, Partial<Record<string, string>>>, reqParams?: IMetricsReqParams): Promise<Record<MetricNames, MetricData>>;
-export declare const metricsApi: {
-    getMetrics: typeof getMetrics;
-    getMetricProviders(): Promise<MetricProviderInfo[]>;
-};
 export declare function normalizeMetrics(metrics: MetricData | undefined | null, frames?: number): MetricData;
 export declare function isMetricsEmpty(metrics: Partial<Record<string, MetricData>>): boolean;
-export declare function getItemMetrics(metrics: Partial<Record<string, MetricData>> | null | undefined, itemName: string): Partial<Record<string, MetricData>> | undefined;
-export declare function getMetricLastPoints<T extends Partial<Record<string, MetricData>>>(metrics: T): Record<keyof T, number>;
-export {};
+export declare function getItemMetrics<Keys extends string>(metrics: Partial<Record<Keys, MetricData>> | null | undefined, itemName: string): Partial<Record<Keys, MetricData>> | undefined;
+export declare function getMetricLastPoints<Keys extends string>(metrics: Partial<Record<Keys, MetricData>>): Partial<Record<Keys, number>>;

package/dist/src/common/k8s-api/endpoints/namespace.api.d.ts

@@ -6,7 +6,6 @@ import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
 import type { ClusterScopedMetadata, KubeObjectStatus } from "../kube-object";
 import { KubeObject } from "../kube-object";
-import type { PodMetricData } from "./pod.api";
 export declare enum NamespaceStatusKind {
     ACTIVE = "Active",
     TERMINATING = "Terminating"
@@ -26,4 +25,3 @@ export declare class Namespace extends KubeObject<ClusterScopedMetadata, Namespa
 export declare class NamespaceApi extends KubeApi<Namespace> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForNamespace(namespace: string, selector?: string): Promise<PodMetricData>;

package/dist/src/common/k8s-api/endpoints/node.api.d.ts

@@ -4,23 +4,11 @@
  */
 import type { BaseKubeObjectCondition, ClusterScopedMetadata } from "../kube-object";
 import { KubeObject } from "../kube-object";
-import type { MetricData } from "./metrics.api";
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
 export declare class NodeApi extends KubeApi<Node> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForAllNodes(): Promise<NodeMetricData>;
-export interface NodeMetricData extends Partial<Record<string, MetricData>> {
-    memoryUsage: MetricData;
-    workloadMemoryUsage: MetricData;
-    memoryCapacity: MetricData;
-    memoryAllocatableCapacity: MetricData;
-    cpuUsage: MetricData;
-    cpuCapacity: MetricData;
-    fsUsage: MetricData;
-    fsSize: MetricData;
-}
 export interface NodeTaint {
     key: string;
     value?: string;

package/dist/src/common/k8s-api/endpoints/persistent-volume-claim.api.d.ts

@@ -4,7 +4,6 @@
  */
 import type { LabelSelector, NamespaceScopedMetadata, TypedLocalObjectReference } from "../kube-object";
 import { KubeObject } from "../kube-object";
-import type { MetricData } from "./metrics.api";
 import type { Pod } from "./pod.api";
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
@@ -12,11 +11,6 @@ import type { ResourceRequirements } from "./types/resource-requirements";
 export declare class PersistentVolumeClaimApi extends KubeApi<PersistentVolumeClaim> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForPvc(pvc: PersistentVolumeClaim): Promise<PersistentVolumeClaimMetricData>;
-export interface PersistentVolumeClaimMetricData extends Partial<Record<string, MetricData>> {
-    diskUsage: MetricData;
-    diskCapacity: MetricData;
-}
 export interface PersistentVolumeClaimSpec {
     accessModes?: string[];
     dataSource?: TypedLocalObjectReference;

package/dist/src/common/k8s-api/endpoints/pod.api.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 { MetricData } from "./metrics.api";
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions, ResourceDescriptor } from "../kube-api";
 import { KubeApi } from "../kube-api";
 import type { RequireExactlyOne } from "type-fest";
@@ -17,20 +16,6 @@ export declare class PodApi extends KubeApi<Pod> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
     getLogs(params: ResourceDescriptor, query?: PodLogsQuery): Promise<string>;
 }
-export declare function getMetricsForPods(pods: Pod[], namespace: string, selector?: string): Promise<PodMetricData>;
-export interface PodMetricData extends Partial<Record<string, MetricData>> {
-    cpuUsage: MetricData;
-    memoryUsage: MetricData;
-    fsUsage: MetricData;
-    fsWrites: MetricData;
-    fsReads: MetricData;
-    networkReceive: MetricData;
-    networkTransmit: MetricData;
-    cpuRequests?: MetricData;
-    cpuLimits?: MetricData;
-    memoryRequests?: MetricData;
-    memoryLimits?: MetricData;
-}
 export interface PodLogsQuery {
     container?: string;
     tailLines?: number;
@@ -571,6 +556,7 @@ export declare class Pod extends KubeObject<NamespaceScopedMetadata, PodStatus,
     getQosClass(): string;
     getReason(): string;
     getPriorityClassName(): string;
+    getRuntimeClassName(): string;
     getServiceAccountName(): string;
     getStatus(): PodStatusPhase;
     getStatusMessage(): string;