@k8slens/extensions 5.5.0-git.83d5e1f91e.0 → 5.5.0-git.8e8ad6663b.0

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

@@ -6,6 +6,10 @@ import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
 import { IMetrics } from "./metrics.api";
 import { KubeApi } from "../kube-api";
 import type { KubeJsonApiData } from "../kube-json-api";
+import type { RequireExactlyOne } from "type-fest";
+import type { KubeObjectMetadata, LocalObjectReference } from "../kube-object";
+import type { SecretReference } from "./secret.api";
+import type { PersistentVolumeClaimSpec } from "./persistent-volume-claims.api";
 export declare class PodsApi extends KubeApi<Pod> {
     getLogs: (params: {
         namespace: string;
@@ -82,12 +86,8 @@ export interface IPodContainer extends Partial<Record<PodContainerProbe, IContai
         };
     }[];
     envFrom?: {
-        configMapRef?: {
-            name: string;
-        };
-        secretRef?: {
-            name: string;
-        };
+        configMapRef?: LocalObjectReference;
+        secretRef?: LocalObjectReference;
     }[];
     volumeMounts?: {
         name: string;
@@ -156,29 +156,418 @@ export interface IPodContainerStatus {
     containerID?: string;
     started?: boolean;
 }
+export interface AwsElasticBlockStoreSource {
+    volumeID: string;
+    fsType: string;
+}
+export interface AzureDiskSource {
+    /**
+     * The name of the VHD blob object OR the name of an Azure managed data disk if `kind` is `"Managed"`.
+     */
+    diskName: string;
+    /**
+     * The URI of the vhd blob object OR the `resourceID` of an Azure managed data disk if `kind` is `"Managed"`.
+     */
+    diskURI: string;
+    /**
+     * Kind of disk
+     * @default "Shared"
+     */
+    kind?: "Shared" | "Dedicated" | "Managed";
+    /**
+     * Disk caching mode.
+     * @default "None"
+     */
+    cachingMode?: "None" | "ReadOnly" | "ReadWrite";
+    /**
+     * The filesystem type to mount.
+     * @default "ext4"
+     */
+    fsType?: string;
+    /**
+     * Whether the filesystem is used as readOnly.
+     * @default false
+     */
+    readonly?: boolean;
+}
+export interface AzureFileSource {
+    /**
+     * The name of the secret that contains both Azure storage account name and key.
+     */
+    secretName: string;
+    /**
+     * The share name to be used.
+     */
+    shareName: string;
+    /**
+     * In case the secret is stored in a different namespace.
+     * @default "default"
+     */
+    secretNamespace?: string;
+    /**
+     * Whether the filesystem is used as readOnly.
+     */
+    readOnly: boolean;
+}
+export interface CephfsSource {
+    /**
+     * List of Ceph monitors
+     */
+    monitors: string[];
+    /**
+     * Used as the mounted root, rather than the full Ceph tree.
+     * @default "/"
+     */
+    path?: string;
+    /**
+     * The RADOS user name.
+     * @default "admin"
+     */
+    user?: string;
+    /**
+     * The path to the keyring file.
+     * @default "/etc/ceph/user.secret"
+     */
+    secretFile?: string;
+    /**
+     * Reference to Ceph authentication secrets. If provided, then the secret overrides `secretFile`
+     */
+    secretRef?: SecretReference;
+    /**
+     * Whether the filesystem is used as readOnly.
+     */
+    readOnly: boolean;
+}
+export interface CinderSource {
+    volumeID: string;
+    fsType: string;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    secretRef?: SecretReference;
+}
+export interface ConfigMapSource {
+    name: string;
+    items: {
+        key: string;
+        path: string;
+    }[];
+}
+export interface DownwardApiSource {
+    items: {
+        path: string;
+        fieldRef: {
+            fieldPath: string;
+        };
+    }[];
+}
+export interface EphemeralSource {
+    volumeClaimTemplate: {
+        /**
+         * All the rest of the fields are ignored and rejected during validation
+         */
+        metadata?: Pick<KubeObjectMetadata, "labels" | "annotations">;
+        spec: PersistentVolumeClaimSpec;
+    };
+}
+export interface EmptyDirSource {
+    medium?: string;
+    sizeLimit?: string;
+}
+export interface FiberChannelSource {
+    /**
+     * A list of World Wide Names
+     */
+    targetWWNs: string[];
+    /**
+     * Logical Unit number
+     */
+    lun: number;
+    /**
+     * The type of filesystem
+     * @default "ext4"
+     */
+    fsType?: string;
+    readOnly: boolean;
+}
+export interface FlockerSource {
+    datasetName: string;
+}
+export interface FlexVolumeSource {
+    driver: string;
+    fsType?: string;
+    secretRef?: LocalObjectReference;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    options?: Record<string, string>;
+}
+export interface GcePersistentDiskSource {
+    pdName: string;
+    fsType: string;
+}
+export interface GitRepoSource {
+    repository: string;
+    revision: string;
+}
+export interface GlusterFsSource {
+    /**
+     * The name of the Endpoints object that represents a Gluster cluster configuration.
+     */
+    endpoints: string;
+    /**
+     * The Glusterfs volume name.
+     */
+    path: string;
+    /**
+     * The boolean that sets the mountpoint readOnly or readWrite.
+     */
+    readOnly: boolean;
+}
+export interface HostPathSource {
+    path: string;
+    /**
+     * Determines the sorts of checks that will be done
+     * @default ""
+     */
+    type?: "" | "DirectoryOrCreate" | "Directory" | "FileOrCreate" | "File" | "Socket" | "CharDevice" | "BlockDevice";
+}
+export interface IScsiSource {
+    targetPortal: string;
+    iqn: string;
+    lun: number;
+    fsType: string;
+    readOnly: boolean;
+    chapAuthDiscovery?: boolean;
+    chapAuthSession?: boolean;
+    secretRef?: SecretReference;
+}
+export interface LocalSource {
+    path: string;
+}
+export interface NetworkFsSource {
+    server: string;
+    path: string;
+    readOnly?: boolean;
+}
+export interface PersistentVolumeClaimSource {
+    claimName: string;
+}
+export interface PhotonPersistentDiskSource {
+    pdID: string;
+    /**
+     * @default "ext4"
+     */
+    fsType?: string;
+}
+export interface PortworxVolumeSource {
+    volumeID: string;
+    fsType?: string;
+    readOnly?: boolean;
+}
+export interface ProjectedSource {
+    sources: {
+        secret?: {
+            name: string;
+            items?: {
+                key: string;
+                path: string;
+                mode?: number;
+            }[];
+        };
+        downwardAPI?: {
+            items?: {
+                path: string;
+                fieldRef?: {
+                    fieldPath: string;
+                    apiVersion?: string;
+                };
+                resourceFieldRef?: {
+                    resource: string;
+                    containerName?: string;
+                };
+                mode?: number;
+            }[];
+        };
+        configMap?: {
+            name: string;
+            items?: {
+                key: string;
+                path: string;
+                mode?: number;
+            }[];
+            optional?: boolean;
+        };
+        serviceAccountToken?: {
+            audience?: string;
+            expirationSeconds?: number;
+            path: string;
+        };
+    }[];
+    defaultMode: number;
+}
+export interface QuobyteSource {
+    registry: string;
+    volume: string;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * @default "serivceaccount"
+     */
+    user?: string;
+    group?: string;
+    tenant?: string;
+}
+export interface RadosBlockDeviceSource {
+    monitors: string[];
+    image: string;
+    /**
+     * @default "ext4"
+     */
+    fsType?: string;
+    /**
+     * @default "rbd"
+     */
+    pool?: string;
+    /**
+     * @default "admin"
+     */
+    user?: string;
+    /**
+     * @default "/etc/ceph/keyring"
+     */
+    keyring?: string;
+    secretRef?: SecretReference;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+}
+export interface ScaleIoSource {
+    gateway: string;
+    system: string;
+    secretRef?: LocalObjectReference;
+    /**
+     * @default false
+     */
+    sslEnabled?: boolean;
+    protectionDomain?: string;
+    storagePool?: string;
+    /**
+     * @default "ThinProvisioned"
+     */
+    storageMode?: "ThickProvisioned" | "ThinProvisioned";
+    volumeName: string;
+    /**
+     * @default "xfs"
+     */
+    fsType?: string;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+}
+export interface SecretSource {
+    secretName: string;
+    items?: {
+        key: string;
+        path: string;
+        mode?: number;
+    }[];
+    defaultMode?: number;
+    optional?: boolean;
+}
+export interface StorageOsSource {
+    volumeName: string;
+    /**
+     * @default Pod.metadata.namespace
+     */
+    volumeNamespace?: string;
+    /**
+     * @default "ext4"
+     */
+    fsType?: string;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    secretRef?: LocalObjectReference;
+}
+export interface VsphereVolumeSource {
+    volumePath: string;
+    /**
+     * @default "ext4"
+     */
+    fsType?: string;
+    storagePolicyName?: string;
+    storagePolicyID?: string;
+}
+export interface ContainerStorageInterfaceSource {
+    driver: string;
+    /**
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * @default "ext4"
+     */
+    fsType?: string;
+    volumeAttributes?: Record<string, string>;
+    controllerPublishSecretRef?: SecretReference;
+    nodeStageSecretRef?: SecretReference;
+    nodePublishSecretRef?: SecretReference;
+    controllerExpandSecretRef?: SecretReference;
+}
+export interface PodVolumeVariants {
+    awsElasticBlockStore: AwsElasticBlockStoreSource;
+    azureDisk: AzureDiskSource;
+    azureFile: AzureFileSource;
+    cephfs: CephfsSource;
+    cinder: CinderSource;
+    configMap: ConfigMapSource;
+    csi: ContainerStorageInterfaceSource;
+    downwardAPI: DownwardApiSource;
+    emptyDir: EmptyDirSource;
+    ephemeral: EphemeralSource;
+    fc: FiberChannelSource;
+    flexVolume: FlexVolumeSource;
+    flocker: FlockerSource;
+    gcePersistentDisk: GcePersistentDiskSource;
+    gitRepo: GitRepoSource;
+    glusterfs: GlusterFsSource;
+    hostPath: HostPathSource;
+    iscsi: IScsiSource;
+    local: LocalSource;
+    nfs: NetworkFsSource;
+    persistentVolumeClaim: PersistentVolumeClaimSource;
+    photonPersistentDisk: PhotonPersistentDiskSource;
+    portworxVolume: PortworxVolumeSource;
+    projected: ProjectedSource;
+    quobyte: QuobyteSource;
+    rbd: RadosBlockDeviceSource;
+    scaleIO: ScaleIoSource;
+    secret: SecretSource;
+    storageos: StorageOsSource;
+    vsphereVolume: VsphereVolumeSource;
+}
+/**
+ * The valid kinds of volume
+ */
+export declare type PodVolumeKind = keyof PodVolumeVariants;
+export declare type PodVolume = RequireExactlyOne<PodVolumeVariants> & {
+    name: string;
+};
 export declare class Pod extends WorkloadKubeObject {
     static kind: string;
     static namespaced: boolean;
     static apiBase: string;
     constructor(data: KubeJsonApiData);
     spec?: {
-        volumes?: {
-            name: string;
-            persistentVolumeClaim: {
-                claimName: string;
-            };
-            emptyDir: {
-                medium?: string;
-                sizeLimit?: string;
-            };
-            configMap: {
-                name: string;
-            };
-            secret: {
-                secretName: string;
-                defaultMode: number;
-            };
-        }[];
+        volumes?: PodVolume[];
         initContainers: IPodContainer[];
         containers: IPodContainer[];
         restartPolicy?: string;
@@ -195,9 +584,7 @@ export declare class Pod extends WorkloadKubeObject {
             [selector: string]: string;
         };
         securityContext?: {};
-        imagePullSecrets?: {
-            name: string;
-        }[];
+        imagePullSecrets?: LocalObjectReference[];
         hostNetwork?: boolean;
         hostPID?: boolean;
         hostIPC?: boolean;
@@ -255,23 +642,7 @@ export declare class Pod extends WorkloadKubeObject {
         lastProbeTime: number;
         lastTransitionTime: string;
     }[];
-    getVolumes(): {
-        name: string;
-        persistentVolumeClaim: {
-            claimName: string;
-        };
-        emptyDir: {
-            medium?: string;
-            sizeLimit?: string;
-        };
-        configMap: {
-            name: string;
-        };
-        secret: {
-            secretName: string;
-            defaultMode: number;
-        };
-    }[];
+    getVolumes(): PodVolume[];
     getSecrets(): string[];
     getNodeSelectors(): string[];
     getTolerations(): {

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

@@ -19,6 +19,10 @@ export interface ISecretRef {
     key?: string;
     name: string;
 }
+export interface SecretReference {
+    name: string;
+    namespace?: string;
+}
 export interface SecretData extends KubeJsonApiData {
     type: SecretType;
     data?: Record<string, string>;

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

@@ -11,6 +11,12 @@ export declare type KubeObjectConstructor<K extends KubeObject> = (new (data: Ku
     namespaced?: boolean;
     apiBase?: string;
 };
+/**
+ * A reference to an object in the same namespace
+ */
+export interface LocalObjectReference {
+    name: string;
+}
 export interface KubeObjectMetadata {
     uid: string;
     name: string;
@@ -83,6 +89,11 @@ export declare type LabelMatchExpression = {
      */
     values: string[];
 });
+export interface TypedLocalObjectReference {
+    apiGroup?: string;
+    kind: string;
+    name: string;
+}
 export interface LabelSelector {
     matchLabels?: Record<string, string | undefined>;
     matchExpressions?: LabelMatchExpression[];

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

@@ -3,7 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { KubeJsonApiData } from "./kube-json-api";
-export interface IKubeWatchEvent<T extends KubeJsonApiData> {
-    type: "ADDED" | "MODIFIED" | "DELETED" | "ERROR";
-    object?: T;
-}
+import type { KubeStatusData } from "./kube-object";
+export declare type IKubeWatchEvent<T extends KubeJsonApiData> = {
+    type: "ADDED" | "MODIFIED" | "DELETED";
+    object: T;
+} | {
+    type: "ERROR";
+    object: KubeStatusData;
+};

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

@@ -3,5 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import winston from "winston";
+export interface Logger {
+    info: (message: string, ...args: any) => void;
+    error: (message: string, ...args: any) => void;
+    debug: (message: string, ...args: any) => void;
+    warn: (message: string, ...args: any) => void;
+}
 declare const _default: winston.Logger;
 export default _default;

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

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { Logger } from "./logger";
+declare const loggerInjectable: import("@ogre-tools/injectable").Injectable<Logger, unknown, void>;
+export default loggerInjectable;

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

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+export declare type GetAbsolutePath = (...args: string[]) => string;
+declare const getAbsolutePathInjectable: import("@ogre-tools/injectable").Injectable<GetAbsolutePath, unknown, void>;
+export default getAbsolutePathInjectable;

package/dist/src/common/path/join-paths.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+export declare type JoinPaths = (...args: string[]) => string;
+declare const joinPathsInjectable: import("@ogre-tools/injectable").Injectable<JoinPaths, unknown, void>;
+export default joinPathsInjectable;

package/dist/src/{renderer/components/+helm/route.d.ts → common/test-utils/get-absolute-path-fake.d.ts}

@@ -2,7 +2,5 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import React from "react";
-export interface HelmRouteProps {
-}
-export declare const HelmRoute: React.FunctionComponent<HelmRouteProps>;
+import type { GetAbsolutePath } from "../path/get-absolute-path.injectable";
+export declare const getAbsolutePathFake: GetAbsolutePath;

package/dist/src/{renderer/components/+user-management/route.d.ts → common/test-utils/join-paths-fake.d.ts}

@@ -2,6 +2,5 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import "./user-management.scss";
-import React from "react";
-export declare const UserManagementRoute: React.FunctionComponent<{}>;
+import type { JoinPaths } from "../path/join-paths.injectable";
+export declare const joinPathsFake: JoinPaths;

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

@@ -7,5 +7,5 @@ export interface URLParams<P extends object = {}, Q extends object = {}> {
     query?: Q;
     fragment?: string;
 }
-export declare function buildURL<P extends object = {}, Q extends object = {}>(path: string | any): ({ params, query, fragment }?: URLParams<P, Q>) => string;
-export declare function buildURLPositional<P extends object = {}, Q extends object = {}>(path: string | any): (params?: P, query?: Q, fragment?: string) => string;
+export declare function buildURL<P extends object = {}, Q extends object = {}>(path: string, { params, query, fragment }?: URLParams<P, Q>): string;
+export declare function buildURLPositional<P extends object = {}, Q extends object = {}>(path: string): (params?: P, query?: Q, fragment?: string) => string;

package/dist/src/common/utils/is-allowed-resource.injectable.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="@ogre-tools/injectable" />
 import type { KubeResource } from "../rbac";
 export declare type IsAllowedResource = (resource: KubeResource) => boolean;
-declare const isAllowedResourceInjectable: import("@ogre-tools/injectable").Injectable<(resource: KubeResource) => boolean, unknown, void>;
+declare const isAllowedResourceInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<boolean>, unknown, KubeResource>;
 export default isAllowedResourceInjectable;

package/dist/src/common/vars/is-mac.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const isMacInjectable: import("@ogre-tools/injectable").Injectable<boolean, unknown, void>;
+export default isMacInjectable;

package/dist/src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-singleton-object-for-extension-api.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { Injectable } from "@ogre-tools/injectable";
+export declare const asLegacyGlobalSingletonForExtensionApi: <Instance, InstantiationParameter = void>(injectable: Injectable<Instance, unknown, InstantiationParameter>, instantiationParameter?: InstantiationParameter) => {
+    createInstance: () => Instance;
+    getInstance: () => Instance;
+    resetInstance: () => void;
+};

package/dist/src/extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api.d.ts

@@ -3,5 +3,10 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { DiContainer } from "@ogre-tools/injectable";
-export declare const setLegacyGlobalDiForExtensionApi: (di: DiContainer) => void;
+export declare enum Environments {
+    renderer = 0,
+    main = 1
+}
+export declare const setLegacyGlobalDiForExtensionApi: (di: DiContainer, environment: Environments) => void;
 export declare const getLegacyGlobalDiForExtensionApi: () => DiContainer;
+export declare const getEnvironmentSpecificLegacyGlobalDiForExtensionApi: (environment: Environments) => DiContainer;