@k8slens/extensions 6.1.9 → 6.2.0-git.19aeda0241.0

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;

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

@@ -2,15 +2,12 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-/// <reference types="node" />
 import type { KubeObjectConstructor, KubeJsonApiDataFor, KubeObjectMetadata } from "./kube-object";
-import { KubeObject } from "./kube-object";
+import { KubeObject, KubeStatus } from "./kube-object";
 import type { IKubeWatchEvent } from "./kube-watch-event";
-import type { KubeJsonApiData } from "./kube-json-api";
-import { KubeJsonApi } from "./kube-json-api";
+import type { KubeJsonApiData, KubeJsonApi } from "./kube-json-api";
 import type { Disposer } from "../utils";
-import type { RequestInit } from "node-fetch";
-import { Agent } from "https";
+import type { RequestInit, Response } from "node-fetch";
 import type { Patch } from "rfc6902";
 import type { PartialDeep } from "type-fest";
 import type AbortController from "abort-controller";
@@ -117,47 +114,32 @@ export interface KubeApiResourceList {
     kind?: string;
     resources: KubeApiResource[];
 }
-export interface ILocalKubeApiConfig {
-    metadata: {
-        uid: string;
-    };
-}
 export declare type PropagationPolicy = undefined | "Orphan" | "Foreground" | "Background";
-/**
- * @deprecated
- */
-export interface IKubeApiCluster extends ILocalKubeApiConfig {
-}
-export interface IRemoteKubeApiConfig {
-    cluster: {
-        server: string;
-        caData?: string;
-        skipTLSVerify?: boolean;
-    };
-    user: {
-        token?: string | (() => Promise<string>);
-        clientCertificateData?: string;
-        clientKeyData?: string;
-    };
+export declare type KubeApiWatchCallback<T extends KubeJsonApiData = KubeJsonApiData> = (data: IKubeWatchEvent<T> | null, error: KubeStatus | Response | null | any) => void;
+export interface KubeApiWatchOptions<Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>> {
     /**
-     * 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.
+     * If the resource is namespaced then the default is `"default"`
+     */
+    namespace?: string;
+    /**
+     * This will be called when either an error occurs or some data is received
      */
-    agent?: Agent;
-}
-export declare function forCluster<Object extends KubeObject, Api extends KubeApi<Object>, Data extends KubeJsonApiDataFor<Object>>(cluster: ILocalKubeApiConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass: new (apiOpts: KubeApiOptions<Object>) => Api): Api;
-export declare function forCluster<Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>>(cluster: ILocalKubeApiConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass?: new (apiOpts: KubeApiOptions<Object>) => KubeApi<Object>): KubeApi<Object>;
-export declare function forRemoteCluster<Object extends KubeObject, Api extends KubeApi<Object>, Data extends KubeJsonApiDataFor<Object>>(config: IRemoteKubeApiConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass: new (apiOpts: KubeApiOptions<Object>) => Api): Api;
-export declare function forRemoteCluster<Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>>(config: IRemoteKubeApiConfig, kubeClass: KubeObjectConstructor<Object, Data>, apiClass?: new (apiOpts: KubeApiOptions<Object>) => KubeApi<Object>): KubeApi<Object>;
-export declare type KubeApiWatchCallback<T extends KubeJsonApiData = KubeJsonApiData> = (data: IKubeWatchEvent<T>, error: any) => void;
-export interface KubeApiWatchOptions<Object extends KubeObject, Data extends KubeJsonApiDataFor<Object>> {
-    namespace: string;
     callback?: KubeApiWatchCallback<Data>;
+    /**
+     * This is a way of aborting the request
+     */
     abortController?: AbortController;
+    /**
+     * The ID used for tracking within logs
+     */
     watchId?: string;
+    /**
+     * @default false
+     */
     retry?: boolean;
+    /**
+     * timeout in seconds
+     */
     timeout?: number;
 }
 export declare type KubeApiPatchType = "merge" | "json" | "strategic";
@@ -214,7 +196,19 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     getResourceVersion(namespace?: string): string | undefined;
     refreshResourceVersion(params?: KubeApiListOptions): Promise<Object[] | null>;
     private computeApiBase;
-    getUrl({ name, namespace }?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
+    /**
+     * This method differs from {@link formatUrlForNotListing} because this treats `""` as "all namespaces"
+     * @param namespace The namespace to list in or `""` for all namespaces
+     */
+    formatUrlForListing(namespace: string): string;
+    /**
+     * Format a URL pathname and query for acting upon a specific resource.
+     */
+    formatUrlForNotListing(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
+    /**
+     * @deprecated use {@link formatUrlForNotListing} instead
+     */
+    getUrl(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
     protected normalizeQuery(query?: Partial<KubeApiQueryParams>): Partial<KubeApiQueryParams>;
     protected parseResponse(data: unknown, namespace?: string): Object | Object[] | null;
     private ensureMetadataSelfLink;
@@ -222,7 +216,10 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     get(desc: ResourceDescriptor, query?: KubeApiQueryParams): Promise<Object | null>;
     create({ name, namespace }: Partial<ResourceDescriptor>, partialData?: PartialDeep<Object>): Promise<Object | null>;
     update({ name, namespace }: ResourceDescriptor, data: PartialDeep<Object>): Promise<Object | null>;
-    patch(desc: ResourceDescriptor, data: PartialDeep<Object> | Patch, strategy?: KubeApiPatchType): Promise<Object | null>;
+    patch(desc: ResourceDescriptor, data: PartialDeep<Object>): Promise<Object | null>;
+    patch(desc: ResourceDescriptor, data: PartialDeep<Object>, strategy: "strategic" | "merge"): Promise<Object | null>;
+    patch(desc: ResourceDescriptor, data: Patch, strategy: "json"): Promise<Object | null>;
+    patch(desc: ResourceDescriptor, data: PartialDeep<Object> | Patch, strategy: KubeApiPatchType): Promise<Object | null>;
     delete({ propagationPolicy, ...desc }: DeleteResourceDescriptor): Promise<KubeJsonApiData<import("./kube-object").KubeJsonApiObjectMetadata<import("./kube-object").KubeObjectScope>, unknown, unknown>>;
     getWatchUrl(namespace?: string, query?: KubeApiQueryParams): string;
     watch(opts?: KubeApiWatchOptions<Object, Data>): () => void;

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

@@ -35,6 +35,5 @@ export interface KubeJsonApiError extends JsonApiError {
     };
 }
 export declare class KubeJsonApi extends JsonApi<KubeJsonApiData> {
-    static forCluster(clusterId: string): KubeJsonApi;
     protected parseError(error: KubeJsonApiError | string, res: Response): string[];
 }

package/dist/src/common/k8s-api/window-location.global-override-for-injectable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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<{
+        host: string;
+        port: string;
+    }, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<{
+        host: string;
+        port: string;
+    }, void>;
+};
+export default _default;

package/dist/src/common/k8s-api/window-location.injectable.d.ts

@@ -0,0 +1,5 @@
+declare const windowLocationInjectable: import("@ogre-tools/injectable").Injectable<{
+    host: string;
+    port: string;
+}, unknown, void>;
+export default windowLocationInjectable;

package/dist/src/common/kube-helpers/load-config-from-file.injectable.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigResult } from "../kube-helpers";
+export declare type LoadConfigfromFile = (filePath: string) => Promise<ConfigResult>;
+declare const loadConfigfromFileInjectable: import("@ogre-tools/injectable").Injectable<LoadConfigfromFile, unknown, void>;
+export default loadConfigfromFileInjectable;

package/dist/src/common/kube-helpers.d.ts

@@ -6,9 +6,6 @@ import { KubeConfig } from "@kubernetes/client-node";
 import type { Cluster, Context, User } from "@kubernetes/client-node/dist/config_types";
 import Joi from "joi";
 import type { PartialDeep } from "type-fest";
-export declare const kubeConfigDefaultPath: string;
-export declare function loadConfigFromFileSync(filePath: string): ConfigResult;
-export declare function loadConfigFromFile(filePath: string): Promise<ConfigResult>;
 interface KubeConfigOptions {
     clusters: Cluster[];
     users: User[];

package/dist/src/common/log-error.global-override-for-injectable.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<Function, any, any>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<Function, any>;
+};
+export default _default;

package/dist/src/common/logger/prefixed-logger.injectable.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../logger";
+declare const prefixedLoggerInjectable: import("@ogre-tools/injectable").Injectable<Logger, unknown, string>;
+export default prefixedLoggerInjectable;

package/dist/src/common/os/home-directory-path.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<string, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<string, void>;
+};
+export default _default;

package/dist/src/common/os/home-directory-path.injectable.d.ts

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

package/dist/src/common/os/temp-directory-path.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<string, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<string, void>;
+};
+export default _default;

package/dist/src/common/os/temp-directory-path.injectable.d.ts

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

package/dist/src/common/path/get-absolute-path.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("./get-absolute-path.injectable").GetAbsolutePath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./get-absolute-path.injectable").GetAbsolutePath, void>;
+};
+export default _default;

package/dist/src/common/path/get-basename.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("./get-basename.injectable").GetBasenameOfPath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./get-basename.injectable").GetBasenameOfPath, void>;
+};
+export default _default;

package/dist/src/common/path/get-basename.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type GetBasenameOfPath = (path: string) => string;
+declare const getBasenameOfPathInjectable: import("@ogre-tools/injectable").Injectable<GetBasenameOfPath, unknown, void>;
+export default getBasenameOfPathInjectable;

package/dist/src/common/path/get-dirname.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("./get-dirname.injectable").GetDirnameOfPath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./get-dirname.injectable").GetDirnameOfPath, void>;
+};
+export default _default;

package/dist/src/common/path/get-dirname.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type GetDirnameOfPath = (path: string) => string;
+declare const getDirnameOfPathInjectable: import("@ogre-tools/injectable").Injectable<GetDirnameOfPath, unknown, void>;
+export default getDirnameOfPathInjectable;

package/dist/src/common/path/get-relative-path.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("./get-relative-path.injectable").GetRelativePath, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./get-relative-path.injectable").GetRelativePath, void>;
+};
+export default _default;

package/dist/src/common/path/get-relative-path.injectable.d.ts

@@ -0,0 +1,3 @@
+export declare type GetRelativePath = (from: string, to: string) => string;
+declare const getRelativePathInjectable: import("@ogre-tools/injectable").Injectable<GetRelativePath, unknown, void>;
+export default getRelativePathInjectable;

package/dist/src/common/{utils/paths.d.ts → path/is-logical-child-path.injectable.d.ts}

@@ -1,9 +1,3 @@
-/**
- * Copyright (c) OpenLens Authors. All rights reserved.
- * Licensed under MIT License. See LICENSE in root directory for more information.
- */
-export declare function resolveTilde(filePath: string): string;
-export declare function resolvePath(filePath: string): string;
 /**
  * Checks if `testPath` represents a potential filesystem entry that would be
  * logically "within" the `parentPath` directory.
@@ -17,4 +11,6 @@ export declare function resolvePath(filePath: string): string;
  * @param parentPath The known path of a directory
  * @param testPath The path that is to be tested
  */
-export declare function isLogicalChildPath(parentPath: string, testPath: string): boolean;
+export declare type IsLogicalChildPath = (parentPath: string, testPath: string) => boolean;
+declare const isLogicalChildPathInjectable: import("@ogre-tools/injectable").Injectable<IsLogicalChildPath, unknown, void>;
+export default isLogicalChildPathInjectable;