@k8slens/extensions 6.1.9 → 6.2.0-git.7e6751bf38.0

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

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

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

@@ -0,0 +1,14 @@
+import type { KubeApiOptions } from "./kube-api";
+import { KubeApi } from "./kube-api";
+import type { KubeJsonApiDataFor, KubeObject, KubeObjectConstructor } from "./kube-object";
+export interface CreateKubeApiForLocalClusterConfig {
+    metadata: {
+        uid: string;
+    };
+}
+export interface CreateKubeApiForCluster {
+    <Object extends KubeObject, Api extends KubeApi<Object>, Data extends KubeJsonApiDataFor<Object>>(cluster: CreateKubeApiForLocalClusterConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass: new (apiOpts: KubeApiOptions<Object>) => Api): Api;
+    <Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>>(cluster: CreateKubeApiForLocalClusterConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass?: new (apiOpts: KubeApiOptions<Object>) => KubeApi<Object>): KubeApi<Object>;
+}
+declare const createKubeApiForClusterInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeApiForCluster, unknown, void>;
+export default createKubeApiForClusterInjectable;

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { Agent } from "https";
+import type { KubeApiOptions } from "./kube-api";
+import { KubeApi } from "./kube-api";
+import type { KubeJsonApiDataFor, KubeObject, KubeObjectConstructor } from "./kube-object";
+export interface CreateKubeApiForRemoteClusterConfig {
+    cluster: {
+        server: string;
+        caData?: string;
+        skipTLSVerify?: boolean;
+    };
+    user: {
+        token?: string | (() => Promise<string>);
+        clientCertificateData?: string;
+        clientKeyData?: string;
+    };
+    /**
+     * Custom instance of https.agent to use for the requests
+     *
+     * @remarks the custom agent replaced default agent, options skipTLSVerify,
+     * clientCertificateData, clientKeyData and caData are ignored.
+     */
+    agent?: Agent;
+}
+export interface CreateKubeApiForRemoteCluster {
+    <Object extends KubeObject, Api extends KubeApi<Object>, Data extends KubeJsonApiDataFor<Object>>(config: CreateKubeApiForRemoteClusterConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass: new (apiOpts: KubeApiOptions<Object>) => Api): Api;
+    <Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>>(config: CreateKubeApiForRemoteClusterConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass?: new (apiOpts: KubeApiOptions<Object>) => KubeApi<Object>): KubeApi<Object>;
+}
+declare const createKubeApiForRemoteClusterInjectable: import("@ogre-tools/injectable").Injectable<CreateKubeApiForRemoteCluster, unknown, void>;
+export default createKubeApiForRemoteClusterInjectable;

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

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

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

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

package/dist/src/common/k8s-api/endpoints/cluster.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, IMetricsReqParams } from "./metrics.api";
 import { KubeObject } from "../kube-object";
 import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
@@ -17,27 +16,12 @@ export declare class ClusterApi extends KubeApi<Cluster> {
     static namespaced: boolean;
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsByNodeNames(nodeNames: string[], params?: IMetricsReqParams): Promise<ClusterMetricData>;
 export declare enum ClusterStatus {
     ACTIVE = "Active",
     CREATING = "Creating",
     REMOVING = "Removing",
     ERROR = "Error"
 }
-export interface ClusterMetricData extends Partial<Record<string, MetricData>> {
-    memoryUsage: MetricData;
-    memoryRequests: MetricData;
-    memoryLimits: MetricData;
-    memoryCapacity: MetricData;
-    cpuUsage: MetricData;
-    cpuRequests: MetricData;
-    cpuLimits: MetricData;
-    cpuCapacity: MetricData;
-    podUsage: MetricData;
-    podCapacity: MetricData;
-    fsSize: MetricData;
-    fsUsage: MetricData;
-}
 export interface Cluster {
     spec: {
         clusterNetwork?: {

package/dist/src/common/k8s-api/endpoints/daemon-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";
@@ -49,4 +48,3 @@ export declare class DaemonSet extends KubeObject<NamespaceScopedMetadata, Daemo
 export declare class DaemonSetApi extends KubeApi<DaemonSet> {
     constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
 }
-export declare function getMetricsForDaemonSets(daemonsets: DaemonSet[], namespace: string, selector?: string): Promise<PodMetricData>;

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

@@ -15,6 +15,7 @@ export * from "./events.api";
 export * from "./horizontal-pod-autoscaler.api";
 export * from "./ingress.api";
 export * from "./job.api";
+export * from "./lease.api";
 export * from "./limit-range.api";
 export * from "./namespace.api";
 export * from "./network-policy.api";
@@ -30,6 +31,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/lease.api.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { DerivedKubeApiOptions, IgnoredKubeApiOptions } from "../kube-api";
+import { KubeApi } from "../kube-api";
+import type { NamespaceScopedMetadata } from "../kube-object";
+import { KubeObject } from "../kube-object";
+export interface LeaseSpec {
+    acquireTime?: string;
+    holderIdentity: string;
+    leaseDurationSeconds: number;
+    leaseTransitions?: number;
+    renewTime: string;
+}
+export declare class Lease extends KubeObject<NamespaceScopedMetadata, void, LeaseSpec> {
+    static readonly kind = "Lease";
+    static readonly namespaced = true;
+    static readonly apiBase = "/apis/coordination.k8s.io/v1/leases";
+    getAcquireTime(): string;
+    getHolderIdentity(): string;
+    getLeaseDurationSeconds(): number;
+    getLeaseTransitions(): number | undefined;
+    getRenewTime(): string;
+}
+export declare class LeaseApi extends KubeApi<Lease> {
+    constructor(opts?: DerivedKubeApiOptions & IgnoredKubeApiOptions);
+}

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

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

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;