chore: Extract specific KubeApi injectables to own package

Signed-off-by: Sebastian Malton <sebastian@malton.name>

packages/core/src/renderer/before-frame-starts/runnables/setup-auto-crd-api-creations.injectable.ts

@@ -8,11 +8,11 @@ import { customResourceDefinitionApiInjectionToken } from "../../../common/k8s-a
 import type { CustomResourceDefinition } from "@k8slens/kube-object";
 import { KubeApi } from "@k8slens/kube-api";
 import { KubeObject } from "@k8slens/kube-object";
-import maybeKubeApiInjectable from "../../../common/k8s-api/maybe-kube-api.injectable";
-import { loggerInjectionToken } from "@k8slens/logger";
+import { logErrorInjectionToken, logInfoInjectionToken, logWarningInjectionToken } from "@k8slens/logger";
 import { injectableDifferencingRegistratorWith } from "../../../common/utils/registrator-helper";
 import customResourceDefinitionStoreInjectable from "../../components/custom-resource-definitions/store.injectable";
 import { beforeClusterFrameStartsSecondInjectionToken } from "../tokens";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 const setupAutoCrdApiCreationsInjectable = getInjectable({
   id: "setup-auto-crd-api-creations",
@@ -45,7 +45,9 @@ const toCrdApiInjectable = (crd: CustomResourceDefinition) => getInjectable({
     };
 
     return new KubeApi({
-      logger: di.inject(loggerInjectionToken),
+      logError: di.inject(logErrorInjectionToken),
+      logInfo: di.inject(logInfoInjectionToken),
+      logWarn: di.inject(logWarningInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     }, { objectConstructor });
   },

packages/core/src/renderer/components/cluster/store.injectable.ts

@@ -6,8 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 
 import { ClusterStore } from "./store";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import clusterApiInjectable from "../../../common/k8s-api/endpoints/cluster.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
+import { clusterApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import assert from "assert";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
@@ -16,7 +15,7 @@ const clusterStoreInjectable = getInjectable({
   id: "cluster-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "clusterStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterStore is only available in certain environments");
     const clusterApi = di.inject(clusterApiInjectable);
 
     return new ClusterStore({

packages/core/src/renderer/components/config-horizontal-pod-autoscalers/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
+import { horizontalPodAutoscalerApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { HorizontalPodAutoscalerStore } from "./store";
 
 const horizontalPodAutoscalerStoreInjectable = getInjectable({
   id: "horizontal-pod-autoscaler-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(horizontalPodAutoscalerApiInjectable);
 

packages/core/src/renderer/components/config-leases/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import leaseApiInjectable from "../../../common/k8s-api/endpoints/lease.api.injectable";
+import { leaseApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { LeaseStore } from "./store";
 
 const leaseStoreInjectable = getInjectable({
   id: "lease-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "leaseStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseStore is only available in certain environments");
 
     const api = di.inject(leaseApiInjectable);
 

packages/core/src/renderer/components/config-limit-ranges/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
+import { limitRangeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { LimitRangeStore } from "./store";
 
 const limitRangeStoreInjectable = getInjectable({
   id: "limit-range-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeStore is only available in certain environments");
 
     const api = di.inject(limitRangeApiInjectable);
 

packages/core/src/renderer/components/config-maps/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
+import { configMapApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ConfigMapStore } from "./store";
 
 const configMapStoreInjectable = getInjectable({
   id: "config-map-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "configMapStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapStore is only available in certain environments");
 
     const api = di.inject(configMapApiInjectable);
 

packages/core/src/renderer/components/config-mutating-webhook-configurations/mutating-webhook-configuration-store.injectable.ts

@@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import { MutatingWebhookConfigurationStore } from "./mutating-webhook-configuration-store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import mutatingWebhookConfigurationApiInjectable
-  from "../../../common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable";
+import { mutatingWebhookConfigurationApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
+import assert from "assert";
 
 const mutatingWebhookConfigurationStoreInjectable = getInjectable({
   id: "mutating-webhook-configuration-store",
   instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookConfigurationStore is only available in certain environments");
+
     const api = di.inject(mutatingWebhookConfigurationApiInjectable);
 
     return new MutatingWebhookConfigurationStore({

packages/core/src/renderer/components/config-pod-disruption-budgets/__tests__/pod-distruption-budgets.test.tsx

@@ -11,13 +11,13 @@ import { PodDisruptionBudgets } from "../pod-disruption-budgets";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import selectedNamespacesStorageInjectable from "../../../../features/namespace-filtering/renderer/storage.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import maybeKubeApiInjectable from "../../../../common/k8s-api/maybe-kube-api.injectable";
 import podDisruptionBudgetStoreInjectable from "../store.injectable";
 import siblingTabsInjectable from "../../../routes/sibling-tabs.injectable";
 import { Cluster } from "../../../../common/cluster/cluster";
 import hostedClusterInjectable from "../../../cluster-frame-context/hosted-cluster.injectable";
 import userPreferencesStateInjectable from "../../../../features/user-preferences/common/state.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
+import { maybeKubeApiInjectable } from "@k8slens/kube-api-specifics";
 
 describe("<PodDisruptionBudgets />", () => {
   let di: DiContainer;
@@ -60,7 +60,7 @@ describe("<PodDisruptionBudgets />", () => {
       get: () => ({}),
     }) as any);
     di.override(loggerInjectionToken, () => null);
-    di.override(maybeKubeApiInjectable, () => (() => null) as any);
+    di.override(maybeKubeApiInjectable, () => null);
     di.override(siblingTabsInjectable, () => ({ get: () => [] } as any));
     di.override(userPreferencesStateInjectable, () => ({
       hiddenTableColumns: {

packages/core/src/renderer/components/config-pod-disruption-budgets/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
+import { podDisruptionBudgetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PodDisruptionBudgetStore } from "./store";
 
 const podDisruptionBudgetStoreInjectable = getInjectable({
   id: "pod-disruption-budget-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podDisruptionBudgetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetStore is only available in certain environments");
 
     const api = di.inject(podDisruptionBudgetApiInjectable);
 

packages/core/src/renderer/components/config-priority-classes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import priorityClassApiInjectable from "../../../common/k8s-api/endpoints/priority-class.api.injectable";
+import { priorityClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PriorityClassStore } from "./store";
 
 const priorityClassStoreInjectable = getInjectable({
   id: "priority-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "priorityClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "priorityClassStore is only available in certain environments");
 
     const api = di.inject(priorityClassApiInjectable);
 

packages/core/src/renderer/components/config-resource-quotas/add-dialog/view.tsx

@@ -24,7 +24,7 @@ import { SubTitle } from "../../layout/sub-title";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeAddQuotaDialogInjectable from "./close.injectable";
 import isAddQuotaDialogOpenInjectable from "./is-open.injectable";
-import resourceQuotaApiInjectable from "../../../../common/k8s-api/endpoints/resource-quota.api.injectable";
+import { resourceQuotaApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";
 

packages/core/src/renderer/components/config-resource-quotas/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
+import { resourceQuotaApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ResourceQuotaStore } from "./store";
 
 const resourceQuotaStoreInjectable = getInjectable({
   id: "resource-quota-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "resourceQuotaStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaStore is only available in certain environments");
 
     const api = di.inject(resourceQuotaApiInjectable);
 

packages/core/src/renderer/components/config-runtime-classes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import runtimeClassApiInjectable from "../../../common/k8s-api/endpoints/runtime-class.api.injectable";
+import { runtimeClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { RuntimeClassStore } from "./store";
 
 const runtimeClassStoreInjectable = getInjectable({
   id: "runtime-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "runtimeClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "runtimeClassStore is only available in certain environments");
 
     const api = di.inject(runtimeClassApiInjectable);
 

packages/core/src/renderer/components/config-secrets/add-dialog/view.tsx

@@ -25,7 +25,7 @@ import upperFirst from "lodash/upperFirst";
 import type { ShowDetails } from "../../kube-detail-params/show-details.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeAddSecretDialogInjectable from "./close.injectable";
-import secretApiInjectable from "../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import showDetailsInjectable from "../../kube-detail-params/show-details.injectable";
 import isAddSecretDialogOpenInjectable from "./is-open.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/config-secrets/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { SecretStore } from "./store";
 
 const secretStoreInjectable = getInjectable({
   id: "secret-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "secretStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretStore is only available in certain environments");
 
     const api = di.inject(secretApiInjectable);
 

packages/core/src/renderer/components/config-validating-webhook-configurations/validating-webhook-configuration-store.injectable.ts

@@ -7,12 +7,14 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import { ValidatingWebhookConfigurationStore } from "./validating-webhook-configuration-store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import validatingWebhookConfigurationApiInjectable
-  from "../../../common/k8s-api/endpoints/validating-webhook-configuration-api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, validatingWebhookConfigurationApiInjectable } from "@k8slens/kube-api-specifics";
+import assert from "assert";
 
 const validatingWebhookConfigurationStoreInjectable = getInjectable({
   id: "validating-webhook-configuration-store",
   instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookConfigurationStore is only available in certain environments");
+
     const api = di.inject(validatingWebhookConfigurationApiInjectable);
 
     return new ValidatingWebhookConfigurationStore({

packages/core/src/renderer/components/config-vertical-pod-autoscalers/store.injectable.ts

@@ -6,15 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { loggerInjectionToken } from "@k8slens/logger";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import verticalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, verticalPodAutoscalerApiInjectable } from "@k8slens/kube-api-specifics";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { VerticalPodAutoscalerStore } from "./store";
 
 const verticalPodAutoscalerStoreInjectable = getInjectable({
   id: "vertical-pod-autoscaler-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "verticalPodAutoscalerStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerStore is only available in certain environments");
 
     const api = di.inject(verticalPodAutoscalerApiInjectable);
 

packages/core/src/renderer/components/custom-resource-definitions/definitions.injectable.ts

@@ -5,15 +5,15 @@
 
 import { getInjectable } from "@ogre-tools/injectable";
 import { computed } from "mobx";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import subscribeStoresInjectable from "../../kube-watch-api/subscribe-stores.injectable";
 import customResourceDefinitionStoreInjectable from "./store.injectable";
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 
 const customResourceDefinitionsInjectable = getInjectable({
   id: "custom-resource-definitions",
 
   instantiate: (di) => {
-    const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectable);
+    const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectionToken);
 
     if (!createStoresAndApis) {
       return computed(() => []);

packages/core/src/renderer/components/custom-resource-definitions/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
+import { customResourceDefinitionApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CustomResourceDefinitionStore } from "./store";
 
 const customResourceDefinitionStoreInjectable = getInjectable({
   id: "custom-resource-definition-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "customResourceDefinitionStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionStore is only available in certain environments");
 
     const api = di.inject(customResourceDefinitionApiInjectable);
 

packages/core/src/renderer/components/dock/logs/call-for-logs.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import type { PodLogsQuery } from "@k8slens/kube-object";
-import podApiInjectable from "../../../../common/k8s-api/endpoints/pod.api.injectable";
+import { podApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ResourceDescriptor } from "@k8slens/kube-api";
 
 export type CallForLogs = (params: ResourceDescriptor, query?: PodLogsQuery) => Promise<string>;

packages/core/src/renderer/components/events/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodByIdInjectable from "../workloads-pods/get-pod-by-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
+import { kubeEventApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EventStore } from "./store";
 
 const eventStoreInjectable = getInjectable({
   id: "event-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "eventStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "eventStore is only available in certain environments");
 
     const api = di.inject(kubeEventApiInjectable);
 

packages/core/src/renderer/components/kube-object-meta/kube-object-meta.tsx

@@ -20,7 +20,7 @@ import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injec
 import apiManagerInjectable from "../../../common/k8s-api/api-manager/manager.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
 import type { NamespaceApi } from "@k8slens/kube-api";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable } from "@k8slens/kube-api-specifics";
 
 export interface KubeObjectMetaProps {
   object: KubeObject;

packages/core/src/renderer/components/namespaces/store.injectable.ts

@@ -5,9 +5,8 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { NamespaceStore } from "./store";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import assert from "assert";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
 import clusterConfiguredAccessibleNamespacesInjectable from "../../cluster/accessible-namespaces.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
@@ -17,7 +16,7 @@ const namespaceStoreInjectable = getInjectable({
   id: "namespace-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "namespaceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceStore is only available in certain environments");
 
     const api = di.inject(namespaceApiInjectable);
 

packages/core/src/renderer/components/network-endpoints/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
+import { endpointsApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { EndpointsStore } from "./store";
 
 const endpointsStoreInjectable = getInjectable({
   id: "endpoints-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "endpointsStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsStore is only available in certain environments");
 
     const api = di.inject(endpointsApiInjectable);
 

packages/core/src/renderer/components/network-ingresses/ingress-class-set-default.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import type { IngressClass } from "@k8slens/kube-object";
-import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
+import { ingressClassApiInjectable } from "@k8slens/kube-api-specifics";
 import ingressClassStoreInjectable from "./ingress-class-store.injectable";
 
 export const ingressClassSetDefaultInjectable = getInjectable({

packages/core/src/renderer/components/network-ingresses/ingress-class-store.injectable.ts

@@ -5,9 +5,8 @@
 import assert from "assert";
 import { getInjectable } from "@ogre-tools/injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import ingressClassApiInjectable from "../../../common/k8s-api/endpoints/ingress-class.api.injectable";
+import { ingressClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { IngressClassStore } from "./ingress-class-store";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
 
@@ -15,7 +14,7 @@ const ingressClassStoreInjectable = getInjectable({
   id: "ingress-class-store",
 
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressClassStore is only available in certain environments");
 
     const api = di.inject(ingressClassApiInjectable);
 

packages/core/src/renderer/components/network-ingresses/ingress-store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import ingressApiInjectable from "../../../common/k8s-api/endpoints/ingress.api.injectable";
+import { ingressApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { IngressStore } from "./ingress-store";
 
 const ingressStoreInjectable = getInjectable({
   id: "ingress-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressStore is only available in certain environments");
 
     const api = di.inject(ingressApiInjectable);
 

packages/core/src/renderer/components/network-policies/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
+import { networkPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NetworkPolicyStore } from "./store";
 
 const networkPolicyStoreInjectable = getInjectable({
   id: "network-policy-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "networkPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyStore is only available in certain environments");
 
     const api = di.inject(networkPolicyApiInjectable);
 

packages/core/src/renderer/components/network-port-forwards/port-forward-details.tsx

@@ -14,10 +14,9 @@ import { cssNames } from "@k8slens/utilities";
 import type { PodApi, ServiceApi } from "@k8slens/kube-api";
 import { PortForwardMenu } from "./port-forward-menu";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
+import { serviceApiInjectable, podApiInjectable } from "@k8slens/kube-api-specifics";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
 
 export interface PortForwardDetailsProps {
   portForward: PortForwardItem;

packages/core/src/renderer/components/network-services/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
+import { serviceApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { ServiceStore } from "./store";
 
 const serviceStoreInjectable = getInjectable({
   id: "service-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceStore is only available in certain environments");
 
     const api = di.inject(serviceApiInjectable);
 

packages/core/src/renderer/components/nodes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
+import { nodeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { NodeStore } from "./store";
 
 const nodeStoreInjectable = getInjectable({
   id: "node-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "nodeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeStore is only available in certain environments");
 
     const api = di.inject(nodeApiInjectable);
 

packages/core/src/renderer/components/pod-security-policies/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
+import { podSecurityPolicyApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PodSecurityPolicyStore } from "./store";
 
 const podSecurityPolicyStoreInjectable = getInjectable({
   id: "pod-security-policy-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podSecurityPolicyStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyStore is only available in certain environments");
 
     const api = di.inject(podSecurityPolicyApiInjectable);
 

packages/core/src/renderer/components/storage-classes/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPersistentVolumesByStorageClassInjectable from "../storage-volumes/get-persistent-volumes-by-storage-class.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { StorageClassStore } from "./store";
 
 const storageClassStoreInjectable = getInjectable({
   id: "storage-class-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "storageClassStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassStore is only available in certain environments");
 
     const api = di.inject(storageClassApiInjectable);
 

packages/core/src/renderer/components/storage-volume-claims/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PersistentVolumeClaimStore } from "./store";
 
 const persistentVolumeClaimStoreInjectable = getInjectable({
   id: "persistent-volume-claim-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeClaimStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeClaimApiInjectable);
 

packages/core/src/renderer/components/storage-volume-claims/volume-claim-details.tsx

@@ -20,7 +20,7 @@ import type { PodStore } from "../workloads-pods/store";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import podStoreInjectable from "../workloads-pods/store.injectable";
 import { stopPropagation } from "@k8slens/utilities";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 
 export interface PersistentVolumeClaimDetailsProps extends KubeObjectDetailsProps<PersistentVolumeClaim> {

packages/core/src/renderer/components/storage-volume-claims/volume-claims.tsx

@@ -21,7 +21,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import persistentVolumeClaimStoreInjectable from "./store.injectable";
 import podStoreInjectable from "../workloads-pods/store.injectable";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import { NamespaceSelectBadge } from "../namespaces/namespace-select-badge";
 
 enum columnId {

packages/core/src/renderer/components/storage-volumes/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import persistentVolumeApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume.api.injectable";
+import { persistentVolumeApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../cluster-frame-context/for-cluster-scoped-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { PersistentVolumeStore } from "./store";
 
 const persistentVolumeStoreInjectable = getInjectable({
   id: "persistent-volume-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeStore is only available in certain environments");
 
     const api = di.inject(persistentVolumeApiInjectable);
 

packages/core/src/renderer/components/storage-volumes/volume-details.tsx

@@ -20,8 +20,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import { loggerInjectionToken } from "@k8slens/logger";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
+import { persistentVolumeClaimApiInjectable, storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 
 export interface PersistentVolumeDetailsProps extends KubeObjectDetailsProps<PersistentVolume> {
 }

packages/core/src/renderer/components/storage-volumes/volumes.tsx

@@ -18,9 +18,8 @@ import type { PersistentVolumeStore } from "./store";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable, storageClassApiInjectable } from "@k8slens/kube-api-specifics";
 import persistentVolumeStoreInjectable from "./store.injectable";
-import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
 
 enum columnId {
   name = "name",

packages/core/src/renderer/components/test-utils/get-application-builder.tsx

@@ -52,7 +52,7 @@ import { applicationWindowInjectionToken } from "../../../main/start-main-applic
 import type { LensWindow } from "../../../main/start-main-application/lens-window/application-window/create-lens-window.injectable";
 import type { FakeExtensionOptions } from "./get-extension-fake";
 import { getExtensionFakeForMain, getExtensionFakeForRenderer } from "./get-extension-fake";
-import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
+import { namespaceApiInjectable } from "@k8slens/kube-api-specifics";
 import { Namespace } from "@k8slens/kube-object";
 import { getOverrideFsWithFakes } from "../../../test-utils/override-fs-with-fakes";
 import applicationMenuItemCompositeInjectable from "../../../features/application-menu/main/application-menu-item-composite.injectable";

packages/core/src/renderer/components/user-management/cluster-role-bindings/store.injectable.ts

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
-import clusterRoleBindingApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, clusterRoleBindingApiInjectable } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ClusterRoleBindingStore } from "./store";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../../cluster-frame-context/for-cluster-scoped-resources.injectable";

packages/core/src/renderer/components/user-management/cluster-roles/store.injectable.ts

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
-import clusterRoleApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role.api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, clusterRoleApiInjectable } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ClusterRoleStore } from "./store";
 import clusterFrameContextForClusterScopedResourcesInjectable from "../../../cluster-frame-context/for-cluster-scoped-resources.injectable";

packages/core/src/renderer/components/user-management/role-bindings/dialog/view.tsx

@@ -35,7 +35,7 @@ import showDetailsInjectable from "../../../kube-detail-params/show-details.inje
 import clusterRoleStoreInjectable from "../../cluster-roles/store.injectable";
 import roleStoreInjectable from "../../roles/store.injectable";
 import serviceAccountStoreInjectable from "../../service-accounts/store.injectable";
-import roleApiInjectable from "../../../../../common/k8s-api/endpoints/role.api.injectable";
+import { roleApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../../notifications/show-checked-error.injectable";
 import type { RoleApi } from "@k8slens/kube-api";

packages/core/src/renderer/components/user-management/role-bindings/store.injectable.ts

@@ -5,16 +5,15 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
-import roleBindingApiInjectable from "../../../../common/k8s-api/endpoints/role-binding.api.injectable";
+import { roleBindingApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { RoleBindingStore } from "./store";
 
 const roleBindingStoreInjectable = getInjectable({
   id: "role-binding-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleBindingStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingStore is only available in certain environments");
 
     const api = di.inject(roleBindingApiInjectable);
 

packages/core/src/renderer/components/user-management/roles/store.injectable.ts

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import roleApiInjectable from "../../../../common/k8s-api/endpoints/role.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
+import { roleApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { RoleStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -14,7 +13,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const roleStoreInjectable = getInjectable({
   id: "role-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleStore is only available in certain environments");
 
     const api = di.inject(roleApiInjectable);
 

packages/core/src/renderer/components/user-management/service-accounts/store.injectable.ts

@@ -4,8 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import serviceAccountApiInjectable from "../../../../common/k8s-api/endpoints/service-account.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
+import { serviceAccountApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ServiceAccountStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -14,7 +13,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const serviceAccountStoreInjectable = getInjectable({
   id: "service-account-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceAccountStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountStore is only available in certain environments");
 
     const api = di.inject(serviceAccountApiInjectable);
 

packages/core/src/renderer/components/workloads-cronjobs/cron-job-menu.tsx

@@ -12,7 +12,7 @@ import { withInjectables } from "@ogre-tools/injectable-react";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
 import type { OpenCronJobTriggerDialog } from "./trigger-dialog/open.injectable";
 import openCronJobTriggerDialogInjectable from "./trigger-dialog/open.injectable";
-import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
+import { cronJobApiInjectable } from "@k8slens/kube-api-specifics";
 import type { ShowCheckedErrorNotification } from "../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../notifications/show-checked-error.injectable";
 import type { CronJobApi } from "@k8slens/kube-api";

packages/core/src/renderer/components/workloads-cronjobs/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getJobsByOwnerInjectable from "../workloads-jobs/get-jobs-by-owner.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
+import { cronJobApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { CronJobStore } from "./store";
 
 const cronJobStoreInjectable = getInjectable({
   id: "cron-job-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "cronJobStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobStore is only available in certain environments");
 
     const api = di.inject(cronJobApiInjectable);
 

packages/core/src/renderer/components/workloads-cronjobs/trigger-dialog/view.tsx

@@ -19,7 +19,7 @@ import { Input } from "../../input";
 import { systemName, maxLength } from "../../input/input_validators";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import closeCronJobTriggerDialogInjectable from "./close.injectable";
-import jobApiInjectable from "../../../../common/k8s-api/endpoints/job.api.injectable";
+import { jobApiInjectable } from "@k8slens/kube-api-specifics";
 import cronJobTriggerDialogStateInjectable from "./state.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-daemonsets/daemonset-menu.tsx

@@ -8,7 +8,7 @@ import type { DaemonSet } from "@k8slens/kube-object";
 import { MenuItem } from "../menu";
 import { Icon } from "@k8slens/icon";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import daemonSetApiInjectable from "../../../common/k8s-api/endpoints/daemon-set.api.injectable";
+import { daemonSetApiInjectable } from "@k8slens/kube-api-specifics";
 import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
 import type { ShowCheckedErrorNotification } from "../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-daemonsets/store.injectable.ts

@@ -5,8 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../workloads-pods/get-pods-by-owner-id.injectable";
-import daemonSetApiInjectable from "../../../common/k8s-api/endpoints/daemon-set.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
+import { daemonSetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
 import { DaemonSetStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -15,7 +14,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const daemonSetStoreInjectable = getInjectable({
   id: "daemon-set-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "daemonSetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetStore is only available in certain environments");
 
     const api = di.inject(daemonSetApiInjectable);
 

packages/core/src/renderer/components/workloads-deployments/deployment-menu.tsx

@@ -9,7 +9,7 @@ import { MenuItem } from "../menu";
 import { Icon } from "@k8slens/icon";
 import type { OpenDeploymentScaleDialog } from "./scale/open.injectable";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import openDeploymentScaleDialogInjectable from "./scale/open.injectable";
 import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";

packages/core/src/renderer/components/workloads-deployments/scale/dialog.test.tsx

@@ -9,7 +9,7 @@ import { DeploymentScaleDialog } from "./dialog";
 import type { DeploymentApi } from "@k8slens/kube-api";
 import { Deployment } from "@k8slens/kube-object";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
-import deploymentApiInjectable from "../../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import type { OpenDeploymentScaleDialog } from "./open.injectable";
 import openDeploymentScaleDialogInjectable from "./open.injectable";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";

packages/core/src/renderer/components/workloads-deployments/scale/dialog.tsx

@@ -17,7 +17,7 @@ import { Icon } from "@k8slens/icon";
 import { Slider } from "../../slider";
 import { cssNames } from "@k8slens/utilities";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import deploymentApiInjectable from "../../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import deploymentScaleDialogStateInjectable from "./dialog-state.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-deployments/store.injectable.ts

@@ -6,8 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import podStoreInjectable from "../workloads-pods/store.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../../common/k8s-api/stores-apis-can-be-created.token";
-import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
+import { storesAndApisCanBeCreatedInjectionToken, deploymentApiInjectable } from "@k8slens/kube-api-specifics";
 import { DeploymentStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";

packages/core/src/renderer/components/workloads-jobs/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../workloads-pods/get-pods-by-owner-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import jobApiInjectable from "../../../common/k8s-api/endpoints/job.api.injectable";
+import { jobApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { JobStore } from "./store";
 
 const jobStoreInjectable = getInjectable({
   id: "job-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "jobStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobStore is only available in certain environments");
 
     const api = di.inject(jobApiInjectable);
 

packages/core/src/renderer/components/workloads-pods/columns/pods-node-column.injectable.tsx

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import React from "react";
 import { Link } from "react-router-dom";
-import nodeApiInjectable from "../../../../common/k8s-api/endpoints/node.api.injectable";
+import { nodeApiInjectable } from "@k8slens/kube-api-specifics";
 import { Badge } from "../../badge";
 import getDetailsUrlInjectable from "../../kube-detail-params/get-details-url.injectable";
 import { stopPropagation } from "@k8slens/utilities";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/ceph-fs.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/config-map.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { ConfigMapApi } from "@k8slens/kube-api";
-import configMapApiInjectable from "../../../../../../common/k8s-api/endpoints/config-map.api.injectable";
+import { configMapApiInjectable } from "@k8slens/kube-api-specifics";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";
 

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/container-storage-interface.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/flex-volume.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/persistent-volume-claim.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { PersistentVolumeClaimApi } from "@k8slens/kube-api";
-import persistentVolumeClaimApiInjectable from "../../../../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
+import { persistentVolumeClaimApiInjectable } from "@k8slens/kube-api-specifics";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";
 

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/rados-block-device.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/scale-io.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/secret.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/details/volumes/variants/storage-os.tsx

@@ -6,7 +6,7 @@
 import { withInjectables } from "@ogre-tools/injectable-react";
 import React from "react";
 import type { SecretApi } from "@k8slens/kube-api";
-import secretApiInjectable from "../../../../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import { DrawerItem } from "../../../../drawer";
 import type { PodVolumeVariantSpecificProps } from "../variant-helpers";
 import { LocalRef } from "../variant-helpers";

packages/core/src/renderer/components/workloads-pods/pod-details-secrets.tsx

@@ -11,7 +11,7 @@ import { reaction } from "mobx";
 import { observer } from "mobx-react";
 import type { Pod, Secret } from "@k8slens/kube-object";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
+import { secretApiInjectable } from "@k8slens/kube-api-specifics";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
 import type { SecretApi } from "@k8slens/kube-api";

packages/core/src/renderer/components/workloads-pods/pod-details.tsx

@@ -23,10 +23,7 @@ import { PodVolumes } from "./details/volumes/view";
 import { withInjectables } from "@ogre-tools/injectable-react";
 import type { GetDetailsUrl } from "../kube-detail-params/get-details-url.injectable";
 import getDetailsUrlInjectable from "../kube-detail-params/get-details-url.injectable";
-import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
-import runtimeClassApiInjectable from "../../../common/k8s-api/endpoints/runtime-class.api.injectable";
-import serviceAccountApiInjectable from "../../../common/k8s-api/endpoints/service-account.api.injectable";
-import priorityClassApiInjectable from "../../../common/k8s-api/endpoints/priority-class.api.injectable";
+import { nodeApiInjectable, runtimeClassApiInjectable, serviceAccountApiInjectable, priorityClassApiInjectable } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import { PodDetailsContainers } from "./details/containers/pod-details-containers";
 import { PodDetailsInitContainers } from "./details/containers/pod-details-init-containers";

packages/core/src/renderer/components/workloads-pods/store.injectable.ts

@@ -4,18 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
-import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
+import { podApiInjectable, podMetricsApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
 import { PodStore } from "./store";
-import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
 
 const podStoreInjectable = getInjectable({
   id: "pod-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "podStore is only available in certain environements");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podStore is only available in certain environments");
 
     const api = di.inject(podApiInjectable);
 

packages/core/src/renderer/components/workloads-replicasets/scale-dialog/dialog.test.tsx

@@ -8,7 +8,7 @@ import React from "react";
 import type { ReplicaSetApi } from "@k8slens/kube-api";
 import { ReplicaSet } from "@k8slens/kube-object";
 import type { OpenReplicaSetScaleDialog } from "./open.injectable";
-import replicaSetApiInjectable from "../../../../common/k8s-api/endpoints/replica-set.api.injectable";
+import { replicaSetApiInjectable } from "@k8slens/kube-api-specifics";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
 import { type DiRender, renderFor } from "../../test-utils/renderFor";

packages/core/src/renderer/components/workloads-replicasets/scale-dialog/dialog.tsx

@@ -17,7 +17,7 @@ import { Slider } from "../../slider";
 import { cssNames } from "@k8slens/utilities";
 import type { ReplicaSet } from "@k8slens/kube-object";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import replicaSetApiInjectable from "../../../../common/k8s-api/endpoints/replica-set.api.injectable";
+import { replicaSetApiInjectable } from "@k8slens/kube-api-specifics";
 import replicaSetScaleDialogStateInjectable from "./state.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-replicasets/store.injectable.ts

@@ -5,8 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../workloads-pods/get-pods-by-owner-id.injectable";
-import replicaSetApiInjectable from "../../../common/k8s-api/endpoints/replica-set.api.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
+import { replicaSetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
 import { ReplicaSetStore } from "./store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
@@ -15,7 +14,7 @@ import { loggerInjectionToken } from "@k8slens/logger";
 const replicaSetStoreInjectable = getInjectable({
   id: "replica-set-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "replicaSetStore is only available in certain environments");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetStore is only available in certain environments");
 
     const api = di.inject(replicaSetApiInjectable);
 

packages/core/src/renderer/components/workloads-replication-controllers/replication-controller-details.tsx

@@ -12,7 +12,7 @@ import { DrawerItem, DrawerTitle } from "../drawer";
 import { Badge } from "../badge";
 import type { KubeObjectDetailsProps } from "../kube-object-details";
 import type { ReplicationController } from "@k8slens/kube-object";
-import replicationControllerApiInjectable from "../../../common/k8s-api/endpoints/replication-controller.api.injectable";
+import { replicationControllerApiInjectable } from "@k8slens/kube-api-specifics";
 import showErrorNotificationInjectable from "../notifications/show-error-notification.injectable";
 import type { ShowNotification } from "../notifications";
 import { Slider } from "../slider";

packages/core/src/renderer/components/workloads-replication-controllers/replication-controller-store.injectable.ts

@@ -7,7 +7,7 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
 import { ReplicationControllerStore } from "./replication-controller-store";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
 import { loggerInjectionToken } from "@k8slens/logger";
-import replicationControllerApiInjectable from "../../../common/k8s-api/endpoints/replication-controller.api.injectable";
+import { replicationControllerApiInjectable } from "@k8slens/kube-api-specifics";
 
 const replicationControllerStoreInjectable = getInjectable({
   id: "replication-controller-store",

packages/core/src/renderer/components/workloads-statefulsets/scale/dialog.test.tsx

@@ -10,7 +10,7 @@ import { waitFor, fireEvent } from "@testing-library/react";
 import React from "react";
 import type { OpenStatefulSetScaleDialog } from "./open-dialog.injectable";
 import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
-import statefulSetApiInjectable from "../../../../common/k8s-api/endpoints/stateful-set.api.injectable";
+import { statefulSetApiInjectable } from "@k8slens/kube-api-specifics";
 import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
 import openStatefulSetScaleDialogInjectable from "./open-dialog.injectable";
 import { type DiRender, renderFor } from "../../test-utils/renderFor";

packages/core/src/renderer/components/workloads-statefulsets/scale/dialog.tsx

@@ -17,7 +17,7 @@ import { Icon } from "@k8slens/icon";
 import { Slider } from "../../slider";
 import { cssNames } from "@k8slens/utilities";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import statefulSetApiInjectable from "../../../../common/k8s-api/endpoints/stateful-set.api.injectable";
+import { statefulSetApiInjectable } from "@k8slens/kube-api-specifics";
 import statefulSetDialogStateInjectable from "./dialog-state.injectable";
 import type { ShowCheckedErrorNotification } from "../../notifications/show-checked-error.injectable";
 import showCheckedErrorNotificationInjectable from "../../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-statefulsets/statefulset-menu.tsx

@@ -8,7 +8,7 @@ import type { StatefulSet } from "@k8slens/kube-object";
 import { MenuItem } from "../menu";
 import { Icon } from "@k8slens/icon";
 import { withInjectables } from "@ogre-tools/injectable-react";
-import statefulSetApiInjectable from "../../../common/k8s-api/endpoints/stateful-set.api.injectable";
+import { statefulSetApiInjectable } from "@k8slens/kube-api-specifics";
 import type { OpenConfirmDialog } from "../confirm-dialog/open.injectable";
 import openConfirmDialogInjectable from "../confirm-dialog/open.injectable";
 import type { ShowCheckedErrorNotification } from "../notifications/show-checked-error.injectable";

packages/core/src/renderer/components/workloads-statefulsets/store.injectable.ts

@@ -6,16 +6,15 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import getPodsByOwnerIdInjectable from "../workloads-pods/get-pods-by-owner-id.injectable";
 import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
-import statefulSetApiInjectable from "../../../common/k8s-api/endpoints/stateful-set.api.injectable";
+import { statefulSetApiInjectable, storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import { loggerInjectionToken } from "@k8slens/logger";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
-import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
 import { StatefulSetStore } from "./store";
 
 const statefulSetStoreInjectable = getInjectable({
   id: "stateful-set-store",
   instantiate: (di) => {
-    assert(di.inject(storesAndApisCanBeCreatedInjectable), "statefulSetStore is only available in certain environment");
+    assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetStore is only available in certain environment");
 
     const api = di.inject(statefulSetApiInjectable);
 

packages/core/src/renderer/k8s/api-kube.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { apiKubePrefix } from "../../common/vars";
 import { apiKubeInjectionToken } from "@k8slens/kube-api";
-import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import createKubeJsonApiInjectable from "../../common/k8s-api/create-kube-json-api.injectable";
 import isDevelopmentInjectable from "../../common/vars/is-development.injectable";
 import showErrorNotificationInjectable from "../components/notifications/show-error-notification.injectable";

packages/core/src/renderer/stores-apis-can-be-created.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
+import { storesAndApisCanBeCreatedInjectionToken } from "@k8slens/kube-api-specifics";
 import hostedClusterIdInjectable from "./cluster-frame-context/hosted-cluster-id.injectable";
 
 const storesAndApisCanBeCreatedInjectable = getInjectable({