@cloudfleet/sdk 0.5.0 → 0.5.2

package/dist/services/kubernetes/types.d.ts

@@ -0,0 +1,1335 @@
+interface KubeOwnerReference {
+    /** API version of the referent. */
+    apiVersion: string;
+    /**
+     * If true, AND if the owner has the "foregroundDeletion" finalizer, then the owner cannot
+     * be deleted from the key-value store until this reference is removed.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion | foreground deletion}
+     * for how the garbage collector interacts with this field and enforces the foreground deletion.
+     *
+     * Defaults to false. To set this field, a user needs "delete" permission of the owner,
+     * otherwise 422 (Unprocessable Entity) will be returned.
+     *
+     */
+    blockOwnerDeletion: boolean;
+    /** If true, this reference points to the managing controller. */
+    controller: boolean;
+    /** Kind of the referent. */
+    kind: string;
+    /** Name of the referent. */
+    name: string;
+    /** UID of the referent. */
+    uid: string;
+}
+/**
+ * ManagedFieldsEntry is a workflow-id, a FieldSet and the group version of the
+ * resource that the fieldset applies to.
+ */
+interface KubeManagedFieldsEntry {
+    /**
+     * APIVersion defines the version of this resource that this field set applies to.
+     * The format is "group/version" just like the top-level APIVersion field.
+     * It is necessary to track the version of a field set because it cannot be
+     * automatically converted.
+     */
+    apiVersion: string;
+    /**
+     * FieldsType is the discriminator for the different fields format and version.
+     * There is currently only one possible value: "FieldsV1"
+     */
+    fieldsType: string;
+    /**
+     * FieldsV1 holds the first JSON version format as described in the "FieldsV1" type.
+     */
+    fieldsV1: object;
+    /**
+     * Manager is an identifier of the workflow managing these fields.
+     */
+    manager: string;
+    /**
+     * Operation is the type of operation which lead to this ManagedFieldsEntry being
+     * created. The only valid values for this field are 'Apply' and 'Update'.
+     */
+    operation: string;
+    /**
+     * Subresource is the name of the subresource used to update that object, or empty
+     * string if the object was updated through the main resource. The value of this
+     * field is used to distinguish between managers, even if they share the same name.
+     * For example, a status update will be distinct from a regular update using the
+     * same manager name. Note that the APIVersion field is not related to the
+     * Subresource field and it always corresponds to the version of the main resource.
+     */
+    subresource: string;
+    /**
+     * Time is the timestamp of when the ManagedFields entry was added.The timestamp
+     * will also be updated if a field is added, the manager changes any of the owned
+     * fields value or removes a field. The timestamp does not update when a field is
+     * removed from the entry because another manager took it over.
+     */
+    timestamp: string;
+}
+/**
+ * KubeMetadata contains the metadata that is common to all Kubernetes objects.
+ *
+ * @see {@link https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#metadata | Metadata} for more details.
+ */
+export interface KubeMetadata {
+    /**
+     * A map of string keys and values that can be used by external tooling to store and
+     * retrieve arbitrary metadata about this object
+     * @see {@link https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/ | annotations docs} for more details.
+     */
+    annotations?: Record<string, string>;
+    /**
+     * An RFC 3339 date of the date and time an object was created
+     */
+    creationTimestamp: string;
+    /**
+     * Number of seconds allowed for this object to gracefully terminate before it
+     * will be removed from the system. Only set when deletionTimestamp is also set.
+     * May only be shortened.
+     * Read-only.
+     */
+    deletionGracePeriodSeconds?: number;
+    /**
+     * An RFC 3339 date of the date and time after which this resource will be deleted.
+     * This field is set by the server when a graceful deletion is requested by the
+     * user, and is not directly settable by a client. The resource will be deleted
+     * (no longer visible from resource lists, and not reachable by name) after the
+     * time in this field except when the object has a finalizer set. In case the
+     * finalizer is set the deletion of the object is postponed at least until the
+     * finalizer is removed. Once the deletionTimestamp is set, this value may not
+     * be unset or be set further into the future, although it may be shortened or
+     * the resource may be deleted prior to this time.
+     */
+    deletionTimestamp?: string;
+    /**
+     * Must be empty before the object is deleted from the registry. Each entry is
+     * an identifier for the responsible component that will remove the entry from
+     * the list. If the deletionTimestamp of the object is non-nil, entries in this
+     * list can only be removed. Finalizers may be processed and removed in any order.
+     * Order is NOT enforced because it introduces significant risk of stuck finalizers.
+     * finalizers is a shared field, any actor with permission can reorder it.
+     * If the finalizer list is processed in order, then this can lead to a situation
+     * in which the component responsible for the first finalizer in the list is
+     * waiting for a signal (field value, external system, or other) produced by a
+     * component responsible for a finalizer later in the list, resulting in a deadlock.
+     * Without enforced ordering finalizers are free to order amongst themselves and
+     * are not vulnerable to ordering changes in the list.
+     *
+     * patch strategy: merge
+     */
+    finalizers?: string[];
+    /**
+     * GenerateName is an optional prefix, used by the server, to generate a unique
+     * name ONLY IF the Name field has not been provided. If this field is used,
+     * the name returned to the client will be different than the name passed.
+     * This value will also be combined with a unique suffix. The provided value
+     * has the same validation rules as the Name field, and may be truncated by
+     * the length of the suffix required to make the value unique on the server.
+     * If this field is specified and the generated name exists, the server will
+     * return a 409. Applied only if Name is not specified.
+     *
+     * @see {@link https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency | more info}
+     */
+    generateName?: string;
+    /**
+     * A sequence number representing a specific generation of the desired state.
+     * Populated by the system.
+     * Read-only.
+     */
+    generation?: number;
+    /**
+     * A map of string keys and values that can be used to organize and categorize objects
+     *
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
+     */
+    labels?: Record<string, string>;
+    /**
+     * Maps workflow-id and version to the set of fields that are managed by that workflow.
+     * This is mostly for internal housekeeping, and users typically shouldn't need to set
+     * or understand this field. A workflow can be the user's name, a controller's name, or
+     * the name of a specific apply path like "ci-cd". The set of fields is always in the
+     * version that the workflow used when modifying the object.
+     */
+    managedFields?: KubeManagedFieldsEntry[];
+    /**
+     * Uniquely identifies this object within the current namespace (see the identifiers docs).
+     * This value is used in the path when retrieving an individual object.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/overview/working-with-objects/names/ | Names docs} for more details.
+     */
+    name: string;
+    /**
+     * Namespace defines the space within which each name must be unique. An empty namespace is
+     * equivalent to the "default" namespace, but "default" is the canonical representation.
+     * Not all objects are required to be scoped to a namespace - the value of this field for
+     * those objects will be empty. Must be a DNS_LABEL. Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/ | Namespaces docs} for more details.
+     */
+    namespace?: string;
+    /**
+     * List of objects depended by this object. If ALL objects in the list have been deleted,
+     * this object will be garbage collected. If this object is managed by a controller,
+     * then an entry in this list will point to this controller, with the controller field
+     * set to true. There cannot be more than one managing controller.
+     */
+    ownerReferences?: KubeOwnerReference[];
+    /**
+     * Identifies the internal version of this object that can be used by clients to
+     * determine when objects have changed. This value MUST be treated as opaque by
+     * clients and passed unmodified back to the server. Clients should not assume
+     * that the resource version has meaning across namespaces, different kinds of
+     * resources, or different servers.
+     *
+     * @see {@link https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency | concurrency control docs} for more details
+     */
+    resourceVersion?: string;
+    /**
+     * Deprecated: selfLink is a legacy read-only field that is no longer populated by the system.
+     */
+    selfLink?: string;
+    /**
+     * UID is the unique in time and space value for this object. It is typically generated by
+     * the server on successful creation of a resource and is not allowed to change on PUT
+     * operations. Populated by the system. Read-only.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids | UIDs docs} for more details.
+     */
+    uid: string;
+}
+/**
+ *
+ * @link https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#container-v1-core
+ */
+export interface KubeContainer {
+    /**
+     * Arguments to the entrypoint. The container image's CMD is used if this is not provided.
+     * Variable references $(VAR_NAME) are expanded using the container's environment.
+     * If a variable cannot be resolved, the reference in the input string will be unchanged.
+     * Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME)
+     * syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
+     * Escaped references will never be expanded, regardless of whether the variable exists or not.
+     * Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell | more information}
+     */
+    args?: string[];
+    /**
+     * Entrypoint array. Not executed within a shell. The container image's ENTRYPOINT is used if
+     * this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment.
+     * If a variable cannot be resolved, the reference in the input string will be unchanged.
+     * Double $$ are reduced to a single $, which allows for escaping the $(VAR_NAME)
+     * syntax: i.e. "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
+     * Escaped references will never be expanded, regardless of whether the variable exists or not.
+     * Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell | more information}
+     */
+    command?: string[];
+    /** List of environment variables to set in the container. Cannot be updated. */
+    env?: {
+        /** Name of the environment variable. Must be a C_IDENTIFIER. */
+        name: string;
+        /**
+         * Variable references $(VAR_NAME) are expanded using the previously defined environment variables
+         * in the container and any service environment variables. If a variable cannot be resolved, the
+         * reference in the input string will be unchanged. Double $$ are reduced to a single $, which
+         * allows for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the
+         * string literal "$(VAR_NAME)". Escaped references will never be expanded, regardless of whether
+         * the variable exists or not. Defaults to "".
+         */
+        value?: string;
+        /** Source for the environment variable's value. Cannot be used if value is not empty. */
+        valueFrom?: {
+            /** Selects a key of a ConfigMap. */
+            configMapKeyRef?: {
+                /** The key to select. */
+                key: string;
+                /** Name of the referent. */
+                name: string;
+                /** Specify whether the ConfigMap or its key must be defined */
+                optional?: boolean;
+            };
+            /**
+             * Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`,
+             * `metadata.annotations['<KEY>']`, spec.nodeName, spec.serviceAccountName, status.hostIP,
+             * status.podIP, status.podIPs.
+             */
+            fieldRef?: {
+                /** Version of the schema the FieldPath is written in terms of, defaults to "v1". */
+                apiVersion: string;
+                /** Path of the field to select in the specified API version. */
+                fieldPath: string;
+            };
+            /**
+             * Selects a resource of the container: only resources limits and requests
+             * (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory
+             *  and requests.ephemeral-storage) are currently supported.
+             */
+            resourceFieldRef?: {
+                /** Container name: required for volumes, optional for env vars */
+                containerName?: string;
+                /**
+                 * Specifies the output format of the exposed resources, defaults to "1".
+                 *
+                 * @see {@link https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#quantity-resource-core | Quantity}
+                 */
+                divisor?: string;
+                /** Required: resource to select */
+                resource: string;
+            };
+            /** Selects a key of a secret in the pod's namespace */
+            secretKeyRef?: {
+                /** The key of the secret to select from. Must be a valid secret key. */
+                key: string;
+                /** Name of the referent. */
+                name: string;
+                /** Specify whether the Secret or its key must be defined */
+                optional?: boolean;
+            };
+        };
+    }[];
+    envFrom?: {
+        /** SecretEnvSource	The Secret to select from */
+        secretRef?: {
+            /** Name of the referent. */
+            name: string;
+            /** Specify whether the Secret must be defined */
+            optional?: boolean;
+        };
+        configMapRef?: {
+            /** Name of the referent. */
+            name: string;
+            /** Specify whether the ConfigMap must be defined */
+            optional?: boolean;
+        };
+        /** An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. */
+        prefix?: string;
+    }[];
+    /**
+     * Container image name. This field is optional to allow higher level config management to
+     * default or override container images in workload controllers like Deployments and StatefulSets.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/containers/images | more info}
+     */
+    image: string;
+    /**
+     * Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is
+     * specified, or IfNotPresent otherwise. Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/containers/images#updating-images | more info}
+     */
+    imagePullPolicy: string;
+    /**
+     * Periodic probe of container liveness. Container will be restarted if the probe fails.
+     * Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes | more info}
+     */
+    livenessProbe?: KubeContainerProbe;
+    /**
+     * Name of the container specified as a DNS_LABEL.
+     * Each container in a pod must have a unique name (DNS_LABEL).
+     *
+     * Cannot be updated.
+     */
+    name: string;
+    /**
+     * List of ports to expose from the container. Not specifying a port here DOES NOT prevent that
+     * port from being exposed. Any port which is listening on the default "0.0.0.0" address inside
+     * a container will be accessible from the network. Modifying this array with strategic merge
+     * patch may corrupt the data. For more information See https://github.com/kubernetes/kubernetes/issues/108255.
+     *
+     * Cannot be updated.
+     *
+     * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#containerport-v1-core
+     */
+    ports?: {
+        /** Number of port to expose on the pod's IP address. This must be a valid port number, 0 < x < 65536. */
+        containerPort: number;
+        /** What host IP to bind the external port to. */
+        hostIP?: string;
+        /**
+         * Number of port to expose on the host. If specified, this must be a valid port number, 0 < x < 65536.
+         * If HostNetwork is specified, this must match ContainerPort. Most containers do not need this.
+         */
+        hostPort?: number;
+        /** If specified, this must be an IANA_SVC_NAME and unique within the pod. Each named port in a pod must have a unique name. Name for the port that can be referred to by services. */
+        name?: string;
+        /** Protocol for port. Must be UDP, TCP, or SCTP. Defaults to "TCP". */
+        protocol?: string;
+    }[];
+    /**
+     * Periodic probe of container service readiness. Container will be removed from service endpoints
+     * if the probe fails.
+     *
+     * Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes | more info}
+     */
+    readinessProbe?: KubeContainerProbe;
+    /** Resources resize policy for the container. */
+    resizePolicy?: {
+        /**
+         * Name of the resource to which this resource resize policy applies.
+         * Supported values: cpu, memory.
+         */
+        resourceName: string;
+        /**
+         * Restart policy to apply when specified resource is resized.
+         * If not specified, it defaults to NotRequired.
+         */
+        restartPolicy?: string;
+    }[];
+    /**
+     * Compute Resources required by this container. Cannot be updated.
+     *
+     * @see {@link https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ | more info}
+     *
+     * https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#resourcerequirements-v1-core
+     */
+    resources?: {
+        claims?: {
+            /**
+             * Name must match the name of one entry in pod.spec.resourceClaims of the Pod where
+             * this field is used. It makes that resource available inside a container.
+             */
+            name: string;
+        };
+        /**
+         * Limits describes the maximum amount of compute resources allowed.
+         *
+         * @see {@link https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ | more info}
+         *
+         * Can also have hugpages like: "hugepages-2Mi": "100Mi" // Requesting 100 Mebibytes of 2 MiB HugePages
+         */
+        limits?: {
+            /** example "100m", 100 milliCPU (0.1 CPU core) */
+            cpu?: string;
+            /** example , "256Mi" 256 Mebibytes */
+            memory?: string;
+        };
+        requests?: {
+            /** example "500m", 500 milliCPU (0.5 CPU core) */
+            cpu?: string;
+            /** example , "1Gi" 1 Gibibyte */
+            memory?: string;
+        };
+    };
+    /**
+     * Path at which the file to which the container's termination message will be written is mounted
+     * into the container's filesystem. Message written is intended to be brief final status, such as
+     * an assertion failure message. Will be truncated by the node if greater than 4096 bytes.
+     * The total message length across all containers will be limited to 12kb.
+     * Defaults to /dev/termination-log.
+     *
+     * Cannot be updated.
+     */
+    terminationMessagePath?: string;
+    /**
+     * Indicate how the termination message should be populated. File will use the contents of
+     * terminationMessagePath to populate the container status message on both success and failure.
+     * FallbackToLogsOnError will use the last chunk of container log output if the termination message
+     * file is empty and the container exited with an error. The log output is limited to 2048 bytes or
+     * 80 lines, whichever is smaller. Defaults to File.
+     *
+     * Cannot be updated.
+     */
+    terminationMessagePolicy?: string;
+    volumeMounts?: {
+        name: string;
+        readOnly: boolean;
+        mountPath: string;
+    }[];
+    /**
+     * Whether this container should allocate a buffer for stdin in the container runtime.
+     * If this is not set, reads from stdin in the container will always result in EOF.
+     *
+     * Default is false.
+     */
+    stdin?: boolean;
+    /**
+     * Whether the container runtime should close the stdin channel after it has been opened
+     * by a single attach. When stdin is true the stdin stream will remain open across
+     * multiple attach sessions. If stdinOnce is set to true, stdin is opened on container start,
+     * is empty until the first client attaches to stdin, and then remains open and accepts data
+     * until the client disconnects, at which time stdin is closed and remains closed until the
+     * container is restarted. If this flag is false, a container processes that reads from stdin
+     * will never receive an EOF.
+     *
+     * Default is false
+     */
+    stdinOnce?: boolean;
+    /**
+     * Whether this container should allocate a TTY for itself, also requires
+     * 'stdin' to be true.
+     *
+     * Default is false.
+     */
+    tty?: boolean;
+    /**
+     * volumeDevices is the list of block devices to be used by the container.
+     *
+     * patch strategy: merge
+     * patch merge key: devicePath
+     */
+    volumeDevices?: {
+        /** devicePath is the path inside of the container that the device will be mapped to. */
+        devicePath: string;
+        /** name must match the name of a persistentVolumeClaim in the pod */
+        name: string;
+    }[];
+    /**
+     * Container's working directory. If not specified, the container runtime's default
+     * will be used, which might be configured in the container image.
+     * Cannot be updated.
+     */
+    workingDir?: string;
+}
+export interface KubeContainerProbe {
+    httpGet?: {
+        path?: string;
+        port: number;
+        scheme: string;
+        host?: string;
+    };
+    exec?: {
+        command: string[];
+    };
+    tcpSocket?: {
+        port: number;
+    };
+    initialDelaySeconds?: number;
+    timeoutSeconds?: number;
+    periodSeconds?: number;
+    successThreshold?: number;
+    failureThreshold?: number;
+}
+export interface LabelSelector {
+    matchExpressions?: {
+        key: string;
+        operator: string;
+        values: string[];
+    }[];
+    matchLabels?: Record<string, string>;
+}
+export interface KubePodSpec {
+    containers: KubeContainer[];
+    nodeName: string;
+    nodeSelector?: Record<string, string>;
+    initContainers?: KubeContainer[];
+    ephemeralContainers?: KubeContainer[];
+    readinessGates?: {
+        conditionType: string;
+    }[];
+    volumes?: KubeVolume[];
+}
+export interface KubeVolume {
+    name: string;
+    [volumeName: string]: any;
+}
+export type Time = number | string | null;
+export interface KubeCondition {
+    /** Last time we probed the condition. */
+    lastProbeTime: Time;
+    lastTransitionTime?: Time;
+    lastUpdateTime?: Time;
+    message?: string;
+    /** Unique, one-word, CamelCase reason for the condition's last transition. */
+    reason?: string;
+    /** Status of the condition, one of True, False, Unknown. */
+    status: string;
+    type: string;
+}
+/**
+ * This is the base interface for all Kubernetes resources, i.e. it contains fields
+ * that all Kubernetes resources have.
+ */
+export interface KubernetesObject {
+    /**
+     * Kind is a string value representing the REST resource this object represents.
+     * Servers may infer this from the endpoint the client submits requests to.
+     *
+     * In CamelCase.
+     *
+     * Cannot be updated.
+     *
+     * @see {@link https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds | more info}
+     */
+    kind: string;
+    apiVersion?: string;
+    metadata: KubeMetadata;
+    [prop: string]: any;
+}
+export interface Role extends KubernetesObject {
+    rules: {
+        apiGroups: string[];
+        nonResourceURLs: string[];
+        resourceNames: string[];
+        resources: string[];
+        verbs: string[];
+    };
+}
+export interface ClusterRole extends Role {
+}
+export interface RoleBinding extends KubernetesObject {
+    roleRef: {
+        apiGroup: string;
+        kind: string;
+        name: string;
+    };
+    subjects: {
+        apiGroup: string;
+        kind: string;
+        name: string;
+        namespace: string;
+    }[];
+}
+export interface ClusterRoleBinding extends RoleBinding {
+}
+export interface ConfigMap extends KubernetesObject {
+    data: Record<string, string>;
+}
+export interface CronJob extends KubernetesObject {
+    spec: {
+        suspend: boolean;
+        schedule: string;
+        startingDeadlineSeconds?: number;
+        successfulJobsHistoryLimit: number;
+        failedJobsHistoryLimit: number;
+        concurrencyPolicy: string;
+        jobTemplate: {
+            spec: {
+                metadata?: Partial<KubeMetadata>;
+                template: {
+                    spec: {
+                        metadata?: Partial<KubeMetadata>;
+                        containers: KubeContainer[];
+                    };
+                };
+            };
+        };
+        [otherProps: string]: any;
+    };
+    status: Record<string, any>;
+}
+export interface DaemonSet extends KubernetesObject {
+    spec: {
+        updateStrategy: {
+            type: string;
+            rollingUpdate: {
+                maxUnavailable: number;
+            };
+        };
+        selector: LabelSelector;
+        template: {
+            metadata: KubeMetadata;
+            spec: KubePodSpec;
+        };
+        [otherProps: string]: any;
+    };
+    status: Record<string, any>;
+}
+export interface Deployment extends KubernetesObject {
+    spec: {
+        selector?: LabelSelector;
+        strategy?: {
+            type: string;
+            [otherProps: string]: any;
+        };
+        template: {
+            metadata?: KubeMetadata;
+            spec: KubePodSpec;
+        };
+        [otherProps: string]: any;
+    };
+    status: Record<string, any>;
+}
+export interface Endpoint extends KubernetesObject {
+    subsets: KubeEndpointSubset[];
+}
+interface KubeEndpointPort {
+    name?: string;
+    appProtocol: string;
+    port: number;
+    protocol: string;
+}
+interface KubeEndpointAddress {
+    hostname: string;
+    ip: string;
+    nodeName?: string;
+    targetRef?: Pick<KubernetesObject, "apiVersion" | "kind"> & Pick<KubeMetadata, "name" | "namespace" | "resourceVersion" | "uid"> & {
+        fieldPath: string;
+    };
+}
+interface KubeEndpointSubset {
+    addresses?: KubeEndpointAddress[];
+    notReadyAddresses?: KubeEndpointAddress[];
+    ports?: KubeEndpointPort[];
+}
+export interface Event extends KubernetesObject {
+    type: string;
+    reason: string;
+    message: string;
+    involvedObject: {
+        kind: string;
+        namespace: string;
+        name: string;
+        uid: string;
+        apiVersion: string;
+        resourceVersion: string;
+        fieldPath: string;
+    };
+    [otherProps: string]: any;
+}
+export interface HPA extends KubernetesObject {
+    spec: HpaSpec;
+    status: HpaStatus;
+}
+type MetricType = "Utilization" | "Value" | "AverageValue";
+type MetricSourceType = "Resource" | "Pods" | "Object" | "External" | "ContainerResource";
+interface HpaSpec {
+    maxReplicas: number;
+    minReplicas: number;
+    targetCPUUtilizationPercentage?: number;
+    scaleTargetRef: CrossVersionObjectReference;
+    metrics: {
+        external?: {
+            metric: MetricIdentifier;
+            target: MetricTarget;
+        };
+        object?: {
+            metric: MetricIdentifier;
+            describedObject: CrossVersionObjectReference;
+            target: MetricTarget;
+        };
+        pods?: {
+            metric: MetricIdentifier;
+            target: MetricTarget;
+        };
+        resource?: {
+            name: string;
+            target: MetricTarget;
+        };
+        containerResource?: {
+            container: string;
+            name: string;
+            target: MetricTarget;
+        };
+        type: MetricSourceType;
+    }[];
+}
+interface MetricTarget {
+    type: MetricType;
+    averageUtilization?: number;
+    averageValue?: string;
+    value?: string;
+}
+interface CrossVersionObjectReference {
+    apiVersion: string;
+    kind: string;
+    name: string;
+}
+interface MetricIdentifier {
+    name: string;
+    selector: {
+        matchLabels: Record<string, string>;
+        matchExpressions: {
+            key: string;
+            operator: string;
+            values: string[];
+        };
+    };
+}
+interface MetricValueStatus {
+    averageUtilization?: number;
+    averageValue?: string;
+    value?: string;
+}
+interface HpaStatus {
+    currentCPUUtilizationPercentage?: number;
+    currentReplicas: number;
+    desiredReplicas: number;
+    lastScaleTime: string;
+    observedGeneration?: number;
+    currentMetrics: {
+        type: string;
+        external?: {
+            current: MetricValueStatus;
+            metric: MetricIdentifier;
+        };
+        object?: {
+            current: MetricValueStatus;
+            metric: MetricIdentifier;
+            desiredObject: CrossVersionObjectReference;
+        };
+        pods?: {
+            current: MetricValueStatus;
+            metric: MetricIdentifier;
+        };
+        resource?: {
+            name: string;
+            current: MetricValueStatus;
+        };
+        containerResource?: {
+            container: string;
+            name: string;
+            current: MetricValueStatus;
+        };
+    }[] | null;
+    conditions: {
+        type: string;
+        status: string;
+        lastTransitionTime: string;
+        reason: string;
+        message: string;
+    }[];
+}
+export interface Ingress extends KubernetesObject {
+    spec: {
+        ingressClassName?: string;
+        rules: IngressRule[] | LegacyIngressRule[];
+        tls?: {
+            hosts: string[];
+            secretName: string;
+        }[];
+        defaultBackend?: {
+            resource?: {
+                apiVersion: string;
+                kind: string;
+                name: string;
+            };
+            service?: {
+                name: string;
+                port: {
+                    name?: string;
+                    number?: number;
+                };
+            };
+        };
+        [key: string]: any;
+    };
+}
+interface LegacyIngressRule {
+    host: string;
+    http: {
+        paths: {
+            path: string;
+            backend: LegacyIngressBackend;
+        }[];
+    };
+}
+interface IngressRule {
+    host: string;
+    http: {
+        paths: {
+            path: string;
+            pathType?: string;
+            backend: IngressBackend;
+        }[];
+    };
+}
+interface LegacyIngressBackend {
+    serviceName: string;
+    servicePort: string;
+}
+interface IngressBackend {
+    service?: {
+        name: string;
+        port: {
+            number?: number;
+            name?: string;
+        };
+    };
+    resource?: {
+        apiVersion: string;
+        kind: string;
+        name: string;
+    };
+}
+export interface IngressClass extends KubernetesObject {
+    spec: {
+        controller: string;
+        [key: string]: any;
+    };
+}
+export interface Job extends KubernetesObject {
+    spec: {
+        selector: LabelSelector;
+        template: {
+            metadata?: KubeMetadata;
+            spec: KubePodSpec;
+        };
+        [otherProps: string]: any;
+    };
+    status: Record<string, any>;
+}
+export interface Lease extends KubernetesObject {
+    spec: LeaseSpec;
+}
+interface LeaseSpec {
+    holderIdentity: string;
+    leaseDurationSeconds: number;
+    leaseTransitions: number;
+    renewTime: string;
+}
+export interface LimitRange extends KubernetesObject {
+    spec: LimitRangeSpec;
+}
+interface LimitRangeSpec {
+    limits: {
+        default: {
+            cpu: string;
+            memory: string;
+        };
+        defaultRequest: {
+            cpu: string;
+            memory: string;
+        };
+        max: {
+            cpu: string;
+            memory: string;
+        };
+        min: {
+            cpu: string;
+            memory: string;
+        };
+        type: string;
+    }[];
+}
+export interface MutatingWebhookConfiguration extends KubernetesObject {
+    webhooks: {
+        admissionReviewVersions: string[];
+        clientConfig: KubeWebhookClientConfig;
+        failurePolicy?: string;
+        matchPolicy?: string;
+        name: string;
+        namespaceSelector?: {
+            matchExpressions: LabelSelector["matchExpressions"];
+            matchLabels: LabelSelector["matchLabels"];
+        };
+        objectSelector?: {
+            matchExpressions: LabelSelector["matchExpressions"];
+            matchLabels: LabelSelector["matchLabels"];
+        };
+        reinvocationPolicy?: string;
+        rules?: KubeRuleWithOperations[];
+        sideEffects?: string;
+        timeoutSeconds?: number;
+    }[];
+}
+export interface KubeRuleWithOperations {
+    apiGroups: string[];
+    apiVersions: string[];
+    operations: string[];
+    resources: string[];
+    scope?: string;
+}
+export interface KubeWebhookClientConfig {
+    caBundle: string;
+    url?: string;
+    service?: {
+        name: string;
+        namespace: string;
+        path?: string;
+        port?: number;
+    };
+}
+export interface Namespace extends KubernetesObject {
+    status: {
+        phase: string;
+    };
+}
+export interface NetworkPolicy extends KubernetesObject {
+    egress: NetworkPolicyEgressRule[];
+    ingress: NetworkPolicyIngressRule[];
+    podSelector: LabelSelector;
+    policyTypes: string[];
+}
+interface NetworkPolicyPort {
+    port?: string | number;
+    protocol?: string;
+    endPort?: number;
+}
+interface IPBlock {
+    cidr: string;
+    except: string[];
+}
+interface NetworkPolicyPeer {
+    ipBlock?: IPBlock;
+    namespaceSelector?: LabelSelector;
+    podSelector?: LabelSelector;
+}
+interface NetworkPolicyEgressRule {
+    ports: NetworkPolicyPort[];
+    to: NetworkPolicyPeer[];
+}
+interface NetworkPolicyIngressRule {
+    ports: NetworkPolicyPort[];
+    from: NetworkPolicyPeer[];
+}
+export interface Node extends KubernetesObject {
+    status: {
+        addresses: {
+            address: string;
+            type: string;
+        }[];
+        capacity: {
+            cpu: any;
+            memory: any;
+        };
+        conditions: (Omit<KubeCondition, "lastProbeTime" | "lastUpdateTime"> & {
+            lastHeartbeatTime: string;
+        })[];
+        nodeInfo: {
+            architecture: string;
+            bootID: string;
+            containerRuntimeVersion: string;
+            kernelVersion: string;
+            kubeProxyVersion: string;
+            kubeletVersion: string;
+            machineID: string;
+            operatingSystem: string;
+            osImage: string;
+            systemUUID: string;
+        };
+    };
+    spec: {
+        podCIDR: string;
+        [otherProps: string]: any;
+    };
+}
+export interface NodeClaim extends KubernetesObject {
+    status: {
+        conditions: KubeCondition[];
+    };
+}
+export interface PDB extends KubernetesObject {
+    spec: {
+        selector: {
+            matchLabels: Record<string, string>;
+            matchExpressions?: {
+                key: string;
+                operator: string;
+                values: string[];
+            };
+        };
+        minAvailable?: number;
+        maxUnavailable?: number;
+    };
+    status: {
+        currentHealthy: number;
+        desiredHealthy: number;
+        disruptionsAllowed: number;
+        expectedPods: number;
+        observedGeneration: number;
+        disruptedPods?: Record<string, string>;
+        conditions: {
+            type: string;
+            status: string;
+            reason: string;
+            observedGeneration: number;
+            message: string;
+            lastTransitionTime: string;
+        }[];
+    };
+}
+export interface PersistentVolume extends KubernetesObject {
+    spec: {
+        capacity: {
+            storage: string;
+        };
+        [other: string]: any;
+    };
+    status: {
+        message: string;
+        phase: string;
+        reason: string;
+    };
+}
+export interface PersistentVolumeClaim extends KubernetesObject {
+    spec?: {
+        accessModes?: string[];
+        resources?: {
+            limits?: object;
+            requests: {
+                storage?: string;
+                [other: string]: any;
+            };
+        };
+        storageClassName?: string;
+        volumeMode?: string;
+        volumeName?: string;
+        [other: string]: any;
+    };
+    status?: {
+        capacity?: {
+            storage?: string;
+        };
+        phase?: string;
+        accessModes?: string[];
+        [other: string]: any;
+    };
+}
+type PodPhase = "Pending" | "Running" | "Succeeded" | "Failed" | "Unknown";
+export interface Pod extends KubernetesObject {
+    spec: KubePodSpec;
+    status: {
+        conditions: KubeCondition[];
+        containerStatuses: KubeContainerStatus[];
+        initContainerStatuses?: KubeContainerStatus[];
+        ephemeralContainerStatuses?: KubeContainerStatus[];
+        hostIP: string;
+        message?: string;
+        phase: PodPhase;
+        qosClass?: string;
+        reason?: string;
+        startTime: Time;
+        [other: string]: any;
+    };
+}
+interface ContainerState {
+    running: {
+        startedAt: string;
+    };
+    terminated: {
+        containerID: string;
+        exitCode: number;
+        finishedAt: string;
+        message?: string;
+        reason: string;
+        signal?: number;
+        startedAt: string;
+    };
+    waiting: {
+        message?: string;
+        reason: string;
+    };
+}
+interface KubeContainerStatus {
+    containerID?: string;
+    image: string;
+    imageID: string;
+    name: string;
+    ready: boolean;
+    restartCount: number;
+    lastState: Partial<ContainerState>;
+    state: Partial<ContainerState>;
+    started?: boolean;
+}
+export interface PriorityClass extends KubernetesObject {
+    value: number;
+    preemptionPolicy: string;
+    globalDefault?: boolean;
+    description: string;
+}
+export interface ReplicaSet extends KubernetesObject {
+    spec: {
+        minReadySeconds: number;
+        replicas: number;
+        selector: LabelSelector;
+        template: {
+            metadata?: KubeMetadata;
+            spec: KubePodSpec;
+        };
+        [other: string]: any;
+    };
+    status: {
+        availableReplicas: number;
+        conditions: Omit<KubeCondition, "lastProbeTime" | "lastUpdateTime">[];
+        fullyLabeledReplicas: number;
+        observedGeneration: number;
+        readyReplicas: number;
+        replicas: number;
+    };
+}
+export interface ResourceQuota extends KubernetesObject {
+    spec: spec;
+    status: status;
+}
+interface spec {
+    hard: Record<string, string>;
+    scopes?: string[];
+    scopeSelector?: {
+        matchExpressions: {
+            operator: string;
+            scopeName: string;
+            values: string[];
+        }[];
+    };
+}
+interface status {
+    hard: Record<string, string>;
+    used: Record<string, string>;
+}
+export interface RuntimeClass extends KubernetesObject {
+    handler: string;
+}
+export interface Secret extends KubernetesObject {
+    data: Record<string, string>;
+    type: string;
+}
+export interface Service extends KubernetesObject {
+    spec: {
+        clusterIP: string;
+        ports: {
+            name: string;
+            nodePort: number;
+            port: number;
+            protocol: string;
+            targetPort: number | string;
+        }[];
+        type: string;
+        externalIPs: string[];
+        selector: Record<string, string>;
+        [otherProps: string]: any;
+    };
+    status: {
+        conditions?: KubeCondition[];
+        loadBalancer?: {
+            ingress: KubeLoadBalancerIngress[];
+        };
+    };
+}
+interface KubePortStatus {
+    error?: string;
+    port: number;
+    protocol: string;
+}
+interface KubeLoadBalancerIngress {
+    hostname?: string;
+    ip?: string;
+    ports?: KubePortStatus[];
+}
+export interface ServiceAccount extends KubernetesObject {
+    secrets: {
+        apiVersion: string;
+        fieldPath: string;
+        kind: string;
+        name: string;
+        namespace: string;
+        uid: string;
+    }[];
+}
+export interface StatefulSet extends KubernetesObject {
+    spec: {
+        selector: LabelSelector;
+        updateStrategy: {
+            rollingUpdate: {
+                partition: number;
+            };
+            type: string;
+        };
+        template: {
+            metadata: KubeMetadata;
+            spec: KubePodSpec;
+        };
+        [other: string]: any;
+    };
+    status: Record<string, any>;
+}
+export interface StorageClass extends KubernetesObject {
+    provisioner: string;
+    reclaimPolicy: string;
+    volumeBindingMode: string;
+}
+export interface Token extends KubernetesObject {
+    status: {
+        token: string;
+        expirationTimestamp: string;
+    };
+    spec: {
+        audiences: string[];
+        expirationSeconds: number;
+    };
+}
+export interface ValidatingWebhookConfiguration extends KubernetesObject {
+    webhooks: {
+        admissionReviewVersions: string[];
+        clientConfig: KubeWebhookClientConfig;
+        failurePolicy?: string;
+        matchPolicy?: string;
+        name: string;
+        namespaceSelector?: {
+            matchExpressions: LabelSelector["matchExpressions"];
+            matchLabels: LabelSelector["matchLabels"];
+        };
+        objectSelector?: {
+            matchExpressions: LabelSelector["matchExpressions"];
+            matchLabels: LabelSelector["matchLabels"];
+        };
+        rules?: KubeRuleWithOperations[];
+        sideEffects?: string;
+        timeoutSeconds?: number;
+    }[];
+}
+export interface VPA extends KubernetesObject {
+    spec: VpaSpec;
+    status: VpaStatus;
+}
+type ResourceName = "cpu" | "memory" | "storage" | "ephemeral-storage";
+type UpdateMode = "Off" | "Initial" | "Auto" | "Recreate";
+type EvictionChangeRequirement = "TargetHigherThanRequests" | "TargetLowerThanRequests";
+interface VpaSpec {
+    targetRef: {
+        apiVersion: string;
+        kind: string;
+        name: string;
+        namespace?: string;
+    };
+    updatePolicy?: {
+        updateMode: UpdateMode;
+        minReplicas?: number;
+        evictionRequirements?: {
+            resources: {
+                resourceName: ResourceName;
+            }[];
+            changeRequirement: EvictionChangeRequirement;
+        }[];
+    };
+    resourcePolicy?: {
+        containerPolicies: {
+            containerName: string;
+            mode?: UpdateMode;
+            minAllowed?: {};
+            maxAllowed?: {};
+            controlledResources?: ResourceName[];
+            controlledValues?: "RequestsAndLimits" | "RequestsOnly";
+        }[];
+    };
+    recommenders?: {
+        name: string;
+    }[];
+}
+interface VpaStatus {
+    conditions: VpaCondition[];
+    recommendation?: VpaRecommendation;
+}
+interface VpaCondition {
+    type: string;
+    status: string;
+    lastTransitionTime: string;
+    reason?: string;
+    message?: string;
+}
+interface RecommendationValue {
+    cpu?: string;
+    memory?: string;
+    storage?: string;
+    ephemeralStorage?: string;
+}
+interface VpaRecommendation {
+    containerRecommendations: {
+        containerName: string;
+        lowerBound: RecommendationValue;
+        target: RecommendationValue;
+        uncappedTarget: RecommendationValue;
+        upperBound: RecommendationValue;
+    }[];
+}
+export type Workload = DaemonSet | ReplicaSet | StatefulSet | Job | CronJob | Deployment;
+export {};
+//# sourceMappingURL=types.d.ts.map