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

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;

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

@@ -4,7 +4,6 @@
  */
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
-import type { PodMetricData } from "./pod.api";
 import type { KubeObjectStatus, LabelSelector, NamespaceScopedMetadata } from "../kube-object";
 import { KubeObject } from "../kube-object";
 import type { PodTemplateSpec } from "./types/pod-template-spec";
@@ -23,7 +22,6 @@ export declare class ReplicaSetApi extends KubeApi<ReplicaSet> {
         name: string;
     }, replicas: number): Promise<import("../kube-json-api").KubeJsonApiData<import("../kube-object").KubeJsonApiObjectMetadata<import("../kube-object").KubeObjectScope>, unknown, unknown>>;
 }
-export declare function getMetricsForReplicaSets(replicasets: ReplicaSet[], namespace: string, selector?: string): Promise<PodMetricData>;
 export interface ReplicaSetSpec {
     replicas?: number;
     selector: LabelSelector;

package/dist/src/common/k8s-api/endpoints/resource-applier.api/request-patch.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { Patch } from "rfc6902";
+import type { KubeJsonApiData } from "../../kube-json-api";
+export declare type RequestKubeObjectPatch = (name: string, kind: string, ns: string | undefined, patch: Patch) => Promise<KubeJsonApiData>;
+declare const requestKubeObjectPatchInjectable: import("@ogre-tools/injectable").Injectable<RequestKubeObjectPatch, unknown, void>;
+export default requestKubeObjectPatchInjectable;

package/dist/src/common/k8s-api/endpoints/resource-applier.api/request-update.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { KubeJsonApiData } from "../../kube-json-api";
+export declare type RequestKubeObjectCreation = (resourceDescriptor: string) => Promise<KubeJsonApiData>;
+declare const requestKubeObjectCreationInjectable: import("@ogre-tools/injectable").Injectable<RequestKubeObjectCreation, unknown, void>;
+export default requestKubeObjectCreationInjectable;

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

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { DerivedKubeApiOptions } from "../kube-api";
+import { KubeApi } from "../kube-api";
+import type { KubeJsonApiData } from "../kube-json-api";
+import type { ClusterScopedMetadata, KubeObjectMetadata, KubeObjectScope, Toleration } from "../kube-object";
+import { KubeObject } from "../kube-object";
+export interface RuntimeClassData extends KubeJsonApiData<KubeObjectMetadata<KubeObjectScope.Cluster>, void, void> {
+    handler: string;
+    overhead?: RuntimeClassOverhead;
+    scheduling?: RuntimeClassScheduling;
+}
+export interface RuntimeClassOverhead {
+    podFixed?: string;
+}
+export interface RuntimeClassScheduling {
+    nodeSelector?: Partial<Record<string, string>>;
+    tolerations?: Toleration[];
+}
+export declare class RuntimeClass extends KubeObject<ClusterScopedMetadata, void, void> {
+    static readonly kind = "RuntimeClass";
+    static readonly namespaced = false;
+    static readonly apiBase = "/apis/node.k8s.io/v1/runtimeclasses";
+    handler: string;
+    overhead?: RuntimeClassOverhead;
+    scheduling?: RuntimeClassScheduling;
+    constructor({ handler, overhead, scheduling, ...rest }: RuntimeClassData);
+    getHandler(): string;
+    getPodFixed(): string;
+    getNodeSelectors(): string[];
+    getTolerations(): Toleration[];
+}
+export declare class RuntimeClassApi extends KubeApi<RuntimeClass, RuntimeClassData> {
+    constructor(opts?: DerivedKubeApiOptions);
+}

package/dist/src/common/k8s-api/endpoints/runtime-class.api.injectable.d.ts

@@ -0,0 +1,3 @@
+import { RuntimeClassApi } from "./runtime-class.api";
+declare const runtimeClassApiInjectable: import("@ogre-tools/injectable").Injectable<RuntimeClassApi, import("../kube-api").KubeApi<any, any>, void>;
+export default runtimeClassApiInjectable;

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

@@ -4,7 +4,6 @@
  */
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
-import type { PodMetricData } from "./pod.api";
 import type { LabelSelector, NamespaceScopedMetadata } from "../kube-object";
 import { KubeObject } from "../kube-object";
 import type { PodTemplateSpec } from "./types/pod-template-spec";
@@ -24,7 +23,6 @@ export declare class StatefulSetApi extends KubeApi<StatefulSet> {
         name: string;
     }, replicas: number): Promise<import("../kube-json-api").KubeJsonApiData<import("../kube-object").KubeJsonApiObjectMetadata<import("../kube-object").KubeObjectScope>, unknown, unknown>>;
 }
-export declare function getMetricsForStatefulSets(statefulSets: StatefulSet[], namespace: string, selector?: string): Promise<PodMetricData>;
 export interface StatefulSetSpec {
     serviceName: string;
     replicas: number;

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

@@ -6,6 +6,8 @@ import type { Response, RequestInit } from "node-fetch";
 import type { Patch } from "rfc6902";
 import type { PartialDeep, ValueOf } from "type-fest";
 import { EventEmitter } from "../../common/event-emitter";
+import type { Logger } from "../../common/logger";
+import type { Fetch } from "../fetch/fetch.injectable";
 import type { Defaulted } from "../utils";
 export interface JsonApiData {
 }
@@ -42,7 +44,12 @@ export declare type ParamsAndQuery<Params, Query> = (ValueOf<Query> extends Quer
 } : Params & {
     query?: undefined;
 });
+export interface JsonApiDependencies {
+    fetch: Fetch;
+    readonly logger: Logger;
+}
 export declare class JsonApi<Data = JsonApiData, Params extends JsonApiParams<Data> = JsonApiParams<Data>> {
+    protected readonly dependencies: JsonApiDependencies;
     readonly config: JsonApiConfig;
     static readonly reqInitDefault: {
         headers: {
@@ -51,7 +58,7 @@ export declare class JsonApi<Data = JsonApiData, Params extends JsonApiParams<Da
     };
     protected readonly reqInit: Defaulted<RequestInit, keyof typeof JsonApi["reqInitDefault"]>;
     static readonly configDefault: Partial<JsonApiConfig>;
-    constructor(config: JsonApiConfig, reqInit?: RequestInit);
+    constructor(dependencies: JsonApiDependencies, config: JsonApiConfig, reqInit?: RequestInit);
     readonly onData: EventEmitter<[Data, Response]>;
     readonly onError: EventEmitter<[JsonApiErrorParsed, Response]>;
     private readonly getRequestOptions;