@k8slens/extensions 6.3.0-git.fbaa9de007.0 → 6.3.1-git.6aee907dc5.0

package/dist/src/common/cluster/cluster.d.ts

@@ -6,7 +6,7 @@ import type { ClusterContextHandler } from "../../main/context-handler/context-h
 import type { KubeConfig } from "@kubernetes/client-node";
 import type { Kubectl } from "../../main/kubectl/kubectl";
 import type { KubeconfigManager } from "../../main/kubeconfig-manager/kubeconfig-manager";
-import type { KubeResource } from "../rbac";
+import type { KubeApiResourceDescriptor } from "../rbac";
 import type { VersionDetector } from "../../main/cluster-detectors/version-detector";
 import type { DetectorRegistry } from "../../main/cluster-detectors/detector-registry";
 import type { ClusterState, ClusterMetricsResourceType, ClusterId, ClusterMetadata, ClusterModel, ClusterPreferences, ClusterPrometheusPreferences, UpdateClusterModel, ClusterConfigData } from "../cluster-types";
@@ -16,8 +16,8 @@ import type { ListNamespaces } from "./list-namespaces.injectable";
 import type { Logger } from "../logger";
 import type { BroadcastMessage } from "../ipc/broadcast-message.injectable";
 import type { LoadConfigfromFile } from "../kube-helpers/load-config-from-file.injectable";
-import type { RequestNamespaceResources } from "./authorization-namespace-review.injectable";
-import type { RequestListApiResources } from "./list-api-resources.injectable";
+import type { RequestNamespaceListPermissions, RequestNamespaceListPermissionsFor } from "./request-namespace-list-permissions.injectable";
+import type { RequestApiResources } from "../../main/cluster/request-api-resources.injectable";
 export interface ClusterDependencies {
     readonly directoryForKubeConfigs: string;
     readonly logger: Logger;
@@ -26,8 +26,8 @@ export interface ClusterDependencies {
     createContextHandler: (cluster: Cluster) => ClusterContextHandler;
     createKubectl: (clusterVersion: string) => Kubectl;
     createAuthorizationReview: (config: KubeConfig) => CanI;
-    createAuthorizationNamespaceReview: (config: KubeConfig) => RequestNamespaceResources;
-    createListApiResources: (cluster: Cluster) => RequestListApiResources;
+    requestApiResources: RequestApiResources;
+    requestNamespaceListPermissionsFor: RequestNamespaceListPermissionsFor;
     createListNamespaces: (config: KubeConfig) => ListNamespaces;
     createVersionDetector: (cluster: Cluster) => VersionDetector;
     broadcastMessage: BroadcastMessage;
@@ -38,7 +38,7 @@ export interface ClusterDependencies {
  *
  * @beta
  */
-export declare class Cluster implements ClusterModel, ClusterState {
+export declare class Cluster implements ClusterModel {
     private readonly dependencies;
     /** Unique id for a cluster */
     readonly id: ClusterId;
@@ -52,7 +52,6 @@ export declare class Cluster implements ClusterModel, ClusterState {
     protected readonly _proxyKubeconfigManager: KubeconfigManager | undefined;
     protected readonly eventsDisposer: import("../utils").ExtendableDisposer;
     protected activated: boolean;
-    private readonly resourceAccessStatuses;
     get contextHandler(): ClusterContextHandler;
     protected get proxyKubeconfigManager(): KubeconfigManager;
     get whenReady(): Promise<void> & {
@@ -140,23 +139,14 @@ export declare class Cluster implements ClusterModel, ClusterState {
     metadata: ClusterMetadata;
     /**
      * List of allowed namespaces verified via K8S::SelfSubjectAccessReview api
-     *
-     * @observable
      */
-    allowedNamespaces: string[];
-    /**
-     * List of allowed resources
-     *
-     * @observable
-     * @internal
-     */
-    allowedResources: string[];
+    readonly allowedNamespaces: import("mobx").IObservableArray<string>;
     /**
      * List of accessible namespaces provided by user in the Cluster Settings
-     *
-     * @observable
      */
-    accessibleNamespaces: string[];
+    readonly accessibleNamespaces: import("mobx").IObservableArray<string>;
+    private readonly knownResources;
+    private readonly allowedResources;
     /**
      * Labels for the catalog entity
      */
@@ -280,9 +270,9 @@ export declare class Cluster implements ClusterModel, ClusterState {
      * @internal
      */
     broadcastConnectUpdate(message: string, isError?: boolean): void;
-    protected getAllowedNamespaces(proxyConfig: KubeConfig): Promise<string[]>;
-    protected getAllowedResources(listApiResources: RequestListApiResources, requestNamespaceResources: RequestNamespaceResources): Promise<KubeResource[]>;
-    isAllowedResource(kind: string): boolean;
+    protected requestAllowedNamespaces(proxyConfig: KubeConfig): Promise<string[]>;
+    protected getAllowedResources(requestNamespaceListPermissions: RequestNamespaceListPermissions): Promise<string[]>;
+    shouldShowResource(resource: KubeApiResourceDescriptor): boolean;
     isMetricHidden(resource: ClusterMetricsResourceType): boolean;
     get nodeShellImage(): string;
     get imagePullSecret(): string | undefined;

package/dist/src/common/cluster/request-namespace-list-permissions.injectable.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { KubeConfig } from "@kubernetes/client-node";
+import type { KubeApiResource } from "../rbac";
+export type CanListResource = (resource: KubeApiResource) => boolean;
+/**
+ * Requests the permissions for actions on the kube cluster
+ * @param namespace The namespace of the resources
+ */
+export type RequestNamespaceListPermissions = (namespace: string) => Promise<CanListResource>;
+/**
+ * @param proxyConfig This config's `currentContext` field must be set, and will be used as the target cluster
+ */
+export type RequestNamespaceListPermissionsFor = (proxyConfig: KubeConfig) => RequestNamespaceListPermissions;
+declare const requestNamespaceListPermissionsForInjectable: import("@ogre-tools/injectable").Injectable<RequestNamespaceListPermissionsFor, unknown, void>;
+export default requestNamespaceListPermissionsForInjectable;

package/dist/src/common/cluster-store/allowed-resources-injection-token.d.ts

@@ -3,4 +3,5 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { IComputedValue } from "mobx";
-export declare const allowedResourcesInjectionToken: import("@ogre-tools/injectable").InjectionToken<IComputedValue<Set<string>>, void>;
+import type { KubeApiResourceDescriptor } from "../rbac";
+export declare const shouldShowResourceInjectionToken: import("@ogre-tools/injectable").InjectionToken<IComputedValue<boolean>, KubeApiResourceDescriptor>;

package/dist/src/common/fetch/download-json/impl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { AsyncResult } from "../../utils/async-result";
+import type { Fetch } from "../fetch.injectable";
+export interface DownloadJsonOptions {
+    signal?: AbortSignal | null | undefined;
+}
+export type DownloadJson = (url: string, opts?: DownloadJsonOptions) => Promise<AsyncResult<unknown, string>>;
+export declare const downloadJsonWith: (fetch: Fetch) => DownloadJson;

package/dist/src/common/fetch/download-json/normal.injectable.d.ts

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

package/dist/src/common/fetch/download-json/proxy.injectable.d.ts

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

package/dist/src/common/fetch/fetch-module.injectable.d.ts

@@ -0,0 +1,7 @@
+import type * as FetchModule from "node-fetch";
+/**
+ * NOTE: while using this module can cause side effects, this specific injectable is not marked as
+ * such since sometimes the request can be wholely within the perview of unit test
+ */
+declare const nodeFetchModuleInjectable: import("@ogre-tools/injectable").Injectable<typeof FetchModule, unknown, void>;
+export default nodeFetchModuleInjectable;

package/dist/src/common/fetch/fetch.injectable.d.ts

@@ -1,6 +1,4 @@
-import type * as FetchModule from "node-fetch";
-type Response = FetchModule.Response;
-type RequestInit = FetchModule.RequestInit;
+import type { RequestInit, Response } from "node-fetch";
 export type Fetch = (url: string, init?: RequestInit) => Promise<Response>;
 declare const fetchInjectable: import("@ogre-tools/injectable").Injectable<Fetch, unknown, void>;
 export default fetchInjectable;

package/dist/src/common/fetch/proxy-fetch.injectable.d.ts

@@ -0,0 +1,3 @@
+import type { Fetch } from "./fetch.injectable";
+declare const proxyFetchInjectable: import("@ogre-tools/injectable").Injectable<Fetch, unknown, void>;
+export default proxyFetchInjectable;

package/dist/src/common/k8s-api/api-base-configs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export declare const apiBaseServerAddressInjectionToken: import("@ogre-tools/injectable").InjectionToken<string, void>;
+export declare const apiBaseHostHeaderInjectionToken: import("@ogre-tools/injectable").InjectionToken<string, void>;

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

@@ -0,0 +1,2 @@
+declare const apiBaseInjectable: import("@ogre-tools/injectable").Injectable<import("./json-api").JsonApi<import("./json-api").JsonApiData, import("./json-api").JsonApiParams<import("./json-api").JsonApiData>>, unknown, void>;
+export default apiBaseInjectable;

package/dist/src/common/k8s-api/api-manager/resource.store.d.ts

@@ -3,8 +3,9 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { KubeApi } from "../kube-api";
+import type { KubeObjectStoreDependencies } from "../kube-object.store";
 import { KubeObjectStore } from "../kube-object.store";
 import type { KubeObject } from "../kube-object";
 export declare class CustomResourceStore<K extends KubeObject> extends KubeObjectStore<K, KubeApi<K>> {
-    constructor(api: KubeApi<K>);
+    constructor(deps: KubeObjectStoreDependencies, api: KubeApi<K>);
 }

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

@@ -1,3 +1,4 @@
-export type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<string>;
+import type { AsyncResult } from "../../../utils/async-result";
+export type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<AsyncResult<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

@@ -1,3 +1,4 @@
-export type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<string>;
+import type { AsyncResult } from "../../../utils/async-result";
+export type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<AsyncResult<string>>;
 declare const requestHelmChartValuesInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartValues, unknown, void>;
 export default requestHelmChartValuesInjectable;

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

@@ -1,5 +1,6 @@
 import type { Patch } from "rfc6902";
+import type { AsyncResult } from "../../../utils/async-result";
 import type { KubeJsonApiData } from "../../kube-json-api";
-export type RequestKubeObjectPatch = (name: string, kind: string, ns: string | undefined, patch: Patch) => Promise<KubeJsonApiData>;
+export type RequestKubeObjectPatch = (name: string, kind: string, ns: string | undefined, patch: Patch) => Promise<AsyncResult<KubeJsonApiData, string>>;
 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

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

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

@@ -210,15 +210,16 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     private computeApiBase;
     /**
      * This method differs from {@link formatUrlForNotListing} because this treats `""` as "all namespaces"
+     * NOTE: This is also useful for watching
      * @param namespace The namespace to list in or `""` for all namespaces
      */
-    formatUrlForListing(namespace: string): string;
+    formatUrlForListing(namespace: string | undefined, query?: Partial<KubeApiQueryParams>): string;
     /**
      * Format a URL pathname and query for acting upon a specific resource.
      */
-    formatUrlForNotListing(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
+    formatUrlForNotListing({ name, namespace }?: Partial<ResourceDescriptor>): string;
     /**
-     * @deprecated use {@link formatUrlForNotListing} instead
+     * @deprecated use {@link formatUrlForNotListing} or {@link formatUrlForListing} instead
      */
     getUrl(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
     protected normalizeQuery(query?: Partial<KubeApiQueryParams>): Partial<KubeApiQueryParams>;
@@ -234,6 +235,6 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     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;
+    watch(opts?: KubeApiWatchOptions<Object, Data>): Disposer;
     protected modifyWatchEvent(event: IKubeWatchEvent<KubeJsonApiData<KubeObjectMetadata>>): void;
 }

package/dist/src/common/k8s-api/kube-object.store.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 { ClusterContext } from "./cluster-context";
 import type { Disposer } from "../utils";
 import type { KubeJsonApiDataFor, KubeObject } from "./kube-object";
 import type { IKubeWatchEvent } from "./kube-watch-event";
@@ -12,6 +11,7 @@ import type { RequestInit } from "node-fetch";
 import type { Patch } from "rfc6902";
 import type { PartialDeep } from "type-fest";
 import AbortController from "abort-controller";
+import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
 export type OnLoadFailure = (error: unknown) => void;
 export interface KubeObjectStoreLoadingParams {
     namespaces: string[];
@@ -59,24 +59,16 @@ export interface KubeObjectStoreOptions {
 }
 export type KubeApiDataFrom<K extends KubeObject, A> = A extends KubeApi<K, infer D> ? D extends KubeJsonApiDataFor<K> ? D : never : never;
 export type JsonPatch = Patch;
+export interface KubeObjectStoreDependencies {
+    readonly context: ClusterContext;
+}
 export declare abstract class KubeObjectStore<K extends KubeObject = KubeObject, A extends KubeApi<K, D> = KubeApi<K, KubeJsonApiDataFor<K>>, D extends KubeJsonApiDataFor<K> = KubeApiDataFrom<K, A>> extends ItemStore<K> {
-    static readonly defaultContext: import("mobx").IObservableValue<ClusterContext | undefined>;
+    protected readonly dependencies: KubeObjectStoreDependencies;
     readonly api: A;
     readonly limit: number | undefined;
     readonly bufferSize: number;
-    private loadedNamespaces;
-    get contextReady(): Promise<void> & {
-        cancel(): void;
-    };
-    get namespacesReady(): Promise<void> & {
-        cancel(): void;
-    };
-    constructor(api: A, opts?: KubeObjectStoreOptions);
-    /**
-     * @deprecated Supply API instance through constructor
-     */
-    constructor();
-    get context(): ClusterContext | undefined;
+    private readonly loadedNamespaces;
+    constructor(dependencies: KubeObjectStoreDependencies, api: A, opts?: KubeObjectStoreOptions);
     get contextItems(): K[];
     getTotalCount(): number;
     get query(): KubeApiQueryParams;
@@ -118,7 +110,7 @@ export declare abstract class KubeObjectStore<K extends KubeObject = KubeObject,
     remove(item: K): Promise<void>;
     removeSelectedItems(): Promise<void>;
     removeItems(items: K[]): Promise<void>;
-    protected eventsBuffer: import("mobx").IObservableArray<IKubeWatchEvent<D>>;
+    protected readonly eventsBuffer: import("mobx").IObservableArray<IKubeWatchEvent<D>>;
     protected bindWatchEventsUpdater(delay?: number): void;
     subscribe({ onLoadFailure, abortController }?: KubeObjectStoreSubscribeParams): Disposer;
     private watchNamespace;

package/dist/src/common/logger.d.ts

@@ -12,5 +12,5 @@ export interface Logger {
 /**
  * @deprecated use `di.inject(loggerInjectable)` instead
  */
-declare const _default: Logger;
-export default _default;
+declare const logger: Logger;
+export default logger;

package/dist/src/common/rbac.d.ts

@@ -3,12 +3,20 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 export type KubeResource = "namespaces" | "nodes" | "events" | "resourcequotas" | "services" | "limitranges" | "leases" | "secrets" | "configmaps" | "ingresses" | "networkpolicies" | "persistentvolumeclaims" | "persistentvolumes" | "storageclasses" | "pods" | "daemonsets" | "deployments" | "statefulsets" | "replicasets" | "jobs" | "cronjobs" | "endpoints" | "customresourcedefinitions" | "horizontalpodautoscalers" | "podsecuritypolicies" | "poddisruptionbudgets" | "priorityclasses" | "runtimeclasses" | "roles" | "clusterroles" | "rolebindings" | "clusterrolebindings" | "serviceaccounts";
-export interface KubeApiResource extends KubeApiResourceData {
-    apiName: KubeResource;
+export interface KubeApiResource {
+    kind: string;
+    group: string;
+    apiName: string;
+    namespaced: boolean;
+}
+export interface KubeApiResourceDescriptor {
+    apiName: string;
+    group: string;
 }
+export declare const formatKubeApiResource: (res: KubeApiResourceDescriptor) => string;
 export interface KubeApiResourceData {
     kind: string;
-    group?: string;
+    group: string;
+    namespaced: boolean;
 }
 export declare const apiResourceRecord: Record<KubeResource, KubeApiResourceData>;
-export declare const apiResources: KubeApiResource[];

package/dist/src/common/utils/computed-or.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { IComputedValue } from "mobx";
+export declare const computedOr: (...values: IComputedValue<boolean>[]) => IComputedValue<boolean>;

package/dist/src/common/utils/iter.d.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 export type Falsey = false | 0 | "" | null | undefined;
-interface Iterator<T> {
+interface Iterator<T> extends Iterable<T> {
     filter(fn: (val: T) => unknown): Iterator<T>;
     filterMap<U>(fn: (val: T) => Falsey | U): Iterator<U>;
     find(fn: (val: T) => unknown): T | undefined;
@@ -12,7 +12,7 @@ interface Iterator<T> {
     flatMap<U>(fn: (val: T) => U[]): Iterator<U>;
     join(sep?: string): string;
 }
-export declare function pipeline<T>(src: IterableIterator<T>): Iterator<T>;
+export declare function chain<T>(src: IterableIterator<T>): Iterator<T>;
 /**
  * Create a new type safe empty Iterable
  * @returns An `Iterable` that yields 0 items

package/dist/src/common/utils/with-concurrency-limit.d.ts

@@ -0,0 +1,2 @@
+export type ConcurrencyLimiter = <Args extends any[], Res>(fn: (...args: Args) => Res) => (...args: Args) => Promise<Res>;
+export declare function withConcurrencyLimit(limit: number): ConcurrencyLimiter;

package/dist/src/common/vars.d.ts

@@ -3,22 +3,6 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { ThemeId } from "../renderer/themes/lens-theme";
-/**
- * @deprecated Switch to using isMacInjectable
- */
-export declare const isMac: boolean;
-/**
- * @deprecated Switch to using isWindowsInjectable
- */
-export declare const isWindows: boolean;
-/**
- * @deprecated Switch to using isLinuxInjectable
- */
-export declare const isLinux: boolean;
-/**
- * @deprecated switch to using `isDebuggingInjectable`
- */
-export declare const isDebugging: boolean;
 /**
  * @deprecated Switch to using isTestEnvInjectable
  */

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

@@ -4,6 +4,11 @@
  */
 import type { ResourceApplyingStack } from "../../common/k8s/resource-stack";
 import type { KubernetesCluster } from "./catalog";
+import type { KubeApiDataFrom, KubeObjectStoreOptions } from "../../common/k8s-api/kube-object.store";
+import { KubeObjectStore as InternalKubeObjectStore } from "../../common/k8s-api/kube-object.store";
+import type { KubeJsonApiDataFor, KubeObject } from "../../common/k8s-api/kube-object";
+import type { KubeApi } from "../../common/k8s-api/kube-api";
+import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
 export declare const apiManager: import("../../common/k8s-api/api-manager").ApiManager;
 export declare const forCluster: import("../../common/k8s-api/create-kube-api-for-cluster.injectable").CreateKubeApiForCluster;
 export declare const forRemoteCluster: import("../../common/k8s-api/create-kube-api-for-remote-cluster.injectable").CreateKubeApiForRemoteCluster;
@@ -30,5 +35,20 @@ export type { CreateKubeApiForRemoteClusterConfig as IRemoteKubeApiConfig } from
 export type { CreateKubeApiForLocalClusterConfig as ILocalKubeApiConfig } from "../../common/k8s-api/create-kube-api-for-cluster.injectable";
 export { KubeObject, KubeStatus, type OwnerReference, type KubeObjectMetadata, type NamespaceScopedMetadata, type ClusterScopedMetadata, type BaseKubeJsonApiObjectMetadata, type KubeJsonApiObjectMetadata, type KubeStatusData, } from "../../common/k8s-api/kube-object";
 export { KubeJsonApi, type KubeJsonApiData, } from "../../common/k8s-api/kube-json-api";
-export { KubeObjectStore, type JsonPatch, type KubeObjectStoreLoadAllParams, type KubeObjectStoreLoadingParams, type KubeObjectStoreSubscribeParams, } from "../../common/k8s-api/kube-object.store";
+export declare abstract class KubeObjectStore<K extends KubeObject = KubeObject, A extends KubeApi<K, D> = KubeApi<K, KubeJsonApiDataFor<K>>, D extends KubeJsonApiDataFor<K> = KubeApiDataFrom<K, A>> extends InternalKubeObjectStore<K, A, D> {
+    /**
+     * @deprecated This is no longer used and shouldn't have been every really used
+     */
+    static readonly context: {
+        set: (ctx: ClusterContext) => void;
+        get: () => ClusterContext;
+    };
+    get context(): ClusterContext;
+    constructor(api: A, opts?: KubeObjectStoreOptions);
+    /**
+     * @deprecated Supply API instance through constructor
+     */
+    constructor();
+}
+export { type JsonPatch, type KubeObjectStoreLoadAllParams, type KubeObjectStoreLoadingParams, type KubeObjectStoreSubscribeParams, } from "../../common/k8s-api/kube-object.store";
 export { type Container as IPodContainer, type PodContainerStatus as IPodContainerStatus, Pod, PodApi as PodsApi, Node, NodeApi as NodesApi, Deployment, DeploymentApi, DaemonSet, StatefulSet, Job, CronJob, ConfigMap, type SecretReference as ISecretRef, Secret, ReplicaSet, ResourceQuota, LimitRange, HorizontalPodAutoscaler, PodDisruptionBudget, PriorityClass, Service, Endpoints as Endpoint, Ingress, IngressApi, NetworkPolicy, PersistentVolume, PersistentVolumeClaim, PersistentVolumeClaimApi as PersistentVolumeClaimsApi, StorageClass, Namespace, KubeEvent, ServiceAccount, Role, RoleBinding, ClusterRole, ClusterRoleBinding, CustomResourceDefinition, } from "../../common/k8s-api/endpoints";