cdktf-crd/dist/com/github/actions/autoscaling-runner-set/v1alpha1.d.ts

import { Manifest, type ManifestConfig } from "@cdktf/provider-kubernetes/lib/manifest";
import { Construct } from "constructs";
export declare class ActionsGithubComAutoscalingRunnerSetV1alpha1 extends Manifest {
    constructor(scope: Construct, id: string, config: ActionsGithubComAutoscalingRunnerSetV1alpha1Config);
}
export interface ActionsGithubComAutoscalingRunnerSetV1alpha1Config extends ManifestConfig {
    manifest: {
        apiVersion: "actions.github.com/v1alpha1";
        kind: "AutoscalingRunnerSet";
        metadata: {
            annotations?: {
                [key: string]: string;
            };
            labels?: {
                [key: string]: string;
            };
            name: string;
            namespace?: string;
        };
        /** @description AutoscalingRunnerSetSpec defines the desired state of AutoscalingRunnerSet */
        spec?: {
            /** @description Required */
            githubConfigSecret?: string;
            /** @description Required */
            githubConfigUrl?: string;
            githubServerTLS?: {
                /** @description Required */
                certificateFrom?: {
                    /** @description Required */
                    configMapKeyRef?: {
                        /** @description The key to select. */
                        key: string;
                        /** @description Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? */
                        name?: string;
                        /** @description Specify whether the ConfigMap or its key must be defined */
                        optional?: boolean;
                    };
                };
            };
            /** @description PodTemplateSpec describes the data a pod should have when created from a template */
            listenerTemplate?: {
                /** @description Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata */
                metadata?: {
                    annotations?: {
                        [key: string]: string;
                    };
                    finalizers?: string[];
                    labels?: {
                        [key: string]: string;
                    };
                    name?: string;
                    namespace?: string;
                };
                /** @description Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status */
                spec?: {
                    /**
                     * Format: int64
                     * @description Optional duration in seconds the pod may be active on the node relative to StartTime before the system will actively try to mark it failed and kill associated containers. Value must be a positive integer.
                     */
                    activeDeadlineSeconds?: number;
                    /** @description If specified, the pod's scheduling constraints */
                    affinity?: {
                        /** @description Describes node affinity scheduling rules for the pod. */
                        nodeAffinity?: {
                            /** @description The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred. */
                            preferredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description A node selector term, associated with the corresponding weight. */
                                preference: {
                                    /** @description A list of node selector requirements by node's labels. */
                                    matchExpressions?: {
                                        /** @description The label key that the selector applies to. */
                                        key: string;
                                        /** @description Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. */
                                        operator: string;
                                        /** @description An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description A list of node selector requirements by node's fields. */
                                    matchFields?: {
                                        /** @description The label key that the selector applies to. */
                                        key: string;
                                        /** @description Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. */
                                        operator: string;
                                        /** @description An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                };
                                /**
                                 * Format: int32
                                 * @description Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
                                 */
                                weight: number;
                            }[];
                            /** @description If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node. */
                            requiredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description Required. A list of node selector terms. The terms are ORed. */
                                nodeSelectorTerms: {
                                    /** @description A list of node selector requirements by node's labels. */
                                    matchExpressions?: {
                                        /** @description The label key that the selector applies to. */
                                        key: string;
                                        /** @description Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. */
                                        operator: string;
                                        /** @description An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description A list of node selector requirements by node's fields. */
                                    matchFields?: {
                                        /** @description The label key that the selector applies to. */
                                        key: string;
                                        /** @description Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt. */
                                        operator: string;
                                        /** @description An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                }[];
                            };
                        };
                        /** @description Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)). */
                        podAffinity?: {
                            /** @description The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. */
                            preferredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description Required. A pod affinity term, associated with the corresponding weight. */
                                podAffinityTerm: {
                                    /** @description A label query over a set of resources, in this case pods. */
                                    labelSelector?: {
                                        /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                        matchExpressions?: {
                                            /** @description key is the label key that the selector applies to. */
                                            key: string;
                                            /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                            operator: string;
                                            /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                            values?: string[];
                                        }[];
                                        /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                        matchLabels?: {
                                            [key: string]: string;
                                        };
                                    };
                                    /** @description A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. */
                                    namespaceSelector?: {
                                        /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                        matchExpressions?: {
                                            /** @description key is the label key that the selector applies to. */
                                            key: string;
                                            /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                            operator: string;
                                            /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                            values?: string[];
                                        }[];
                                        /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                        matchLabels?: {
                                            [key: string]: string;
                                        };
                                    };
                                    /** @description namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". */
                                    namespaces?: string[];
                                    /** @description This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. */
                                    topologyKey: string;
                                };
                                /**
                                 * Format: int32
                                 * @description weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                 */
                                weight: number;
                            }[];
                            /** @description If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. */
                            requiredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description A label query over a set of resources, in this case pods. */
                                labelSelector?: {
                                    /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                    matchExpressions?: {
                                        /** @description key is the label key that the selector applies to. */
                                        key: string;
                                        /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                        operator: string;
                                        /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                    matchLabels?: {
                                        [key: string]: string;
                                    };
                                };
                                /** @description A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. */
                                namespaceSelector?: {
                                    /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                    matchExpressions?: {
                                        /** @description key is the label key that the selector applies to. */
                                        key: string;
                                        /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                        operator: string;
                                        /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                    matchLabels?: {
                                        [key: string]: string;
                                    };
                                };
                                /** @description namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". */
                                namespaces?: string[];
                                /** @description This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. */
                                topologyKey: string;
                            }[];
                        };
                        /** @description Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)). */
                        podAntiAffinity?: {
                            /** @description The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred. */
                            preferredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description Required. A pod affinity term, associated with the corresponding weight. */
                                podAffinityTerm: {
                                    /** @description A label query over a set of resources, in this case pods. */
                                    labelSelector?: {
                                        /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                        matchExpressions?: {
                                            /** @description key is the label key that the selector applies to. */
                                            key: string;
                                            /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                            operator: string;
                                            /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                            values?: string[];
                                        }[];
                                        /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                        matchLabels?: {
                                            [key: string]: string;
                                        };
                                    };
                                    /** @description A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. */
                                    namespaceSelector?: {
                                        /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                        matchExpressions?: {
                                            /** @description key is the label key that the selector applies to. */
                                            key: string;
                                            /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                            operator: string;
                                            /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                            values?: string[];
                                        }[];
                                        /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                        matchLabels?: {
                                            [key: string]: string;
                                        };
                                    };
                                    /** @description namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". */
                                    namespaces?: string[];
                                    /** @description This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. */
                                    topologyKey: string;
                                };
                                /**
                                 * Format: int32
                                 * @description weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
                                 */
                                weight: number;
                            }[];
                            /** @description If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied. */
                            requiredDuringSchedulingIgnoredDuringExecution?: {
                                /** @description A label query over a set of resources, in this case pods. */
                                labelSelector?: {
                                    /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                    matchExpressions?: {
                                        /** @description key is the label key that the selector applies to. */
                                        key: string;
                                        /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                        operator: string;
                                        /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                    matchLabels?: {
                                        [key: string]: string;
                                    };
                                };
                                /** @description A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces. */
                                namespaceSelector?: {
                                    /** @description matchExpressions is a list of label selector requirements. The requirements are ANDed. */
                                    matchExpressions?: {
                                        /** @description key is the label key that the selector applies to. */
                                        key: string;
                                        /** @description operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
                                        operator: string;
                                        /** @description values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
                                        values?: string[];
                                    }[];
                                    /** @description matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
                                    matchLabels?: {
                                        [key: string]: string;
                                    };
                                };
                                /** @description namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace". */
                                namespaces?: string[];
                                /** @description This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed. */
                                topologyKey: string;
                            }[];
                        };
                    };
                    /** @description AutomountServiceAccountToken indicates whether a service account token should be automatically mounted. */
                    automountServiceAccountToken?: boolean;
                    /** @description List of containers belonging to the pod. Containers cannot currently be added or removed. There must be at least one container in a Pod. Cannot be updated. */
                    containers: {
                        /** @description 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. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell */
                        args?: string[];
                        /** @description 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. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell */
                        command?: string[];
                        /** @description List of environment variables to set in the container. Cannot be updated. */
                        env?: {
                            /** @description Name of the environment variable. Must be a C_IDENTIFIER. */
                            name: string;
                            /** @description 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;
                            /** @description Source for the environment variable's value. Cannot be used if value is not empty. */
                            valueFrom?: {
                                /** @description Selects a key of a ConfigMap. */
                                configMapKeyRef?: {
                                    /** @description The key to select. */
                                    key: string;
                                    /** @description Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? */
                                    name?: string;
                                    /** @description Specify whether the ConfigMap or its key must be defined */
                                    optional?: boolean;
                                };
                                /** @description 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?: {
                                    /** @description Version of the schema the FieldPath is written in terms of, defaults to "v1". */
                                    apiVersion?: string;
                                    /** @description Path of the field to select in the specified API version. */
                                    fieldPath: string;
                                };
                                /** @description 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?: {
                                    /** @description Container name: required for volumes, optional for env vars */
                                    containerName?: string;
                                    /** @description Specifies the output format of the exposed resources, defaults to "1" */
                                    divisor?: number | string;
                                    /** @description Required: resource to select */
                                    resource: string;
                                };
                                /** @description Selects a key of a secret in the pod's namespace */
                                secretKeyRef?: {
                                    /** @description The key of the secret to select from.  Must be a valid secret key. */
                                    key: string;
                                    /** @description Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? */
                                    name?: string;
                                    /** @description Specify whether the Secret or its key must be defined */
                                    optional?: boolean;
                                };
                            };
                        }[];
                        /** @description List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated. */
                        envFrom?: {
                            /** @description The ConfigMap to select from */
                            configMapRef?: {
                                /** @description Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? */
                                name?: string;
                                /** @description Specify whether the ConfigMap must be defined */
                                optional?: boolean;
                            };
                            /** @description An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER. */
                            prefix?: string;
                            /** @description The Secret to select from */
                            secretRef?: {
                                /** @description Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid? */
                                name?: string;
                                /** @description Specify whether the Secret must be defined */
                                optional?: boolean;
                            };
                        }[];
                        /** @description Container image name. More info: https://kubernetes.io/docs/concepts/containers/images This field is optional to allow higher level config management to default or override container images in workload controllers like Deployments and StatefulSets. */
                        image?: string;
                        /** @description Image pull policy. One of Always, Never, IfNotPresent. Defaults to Always if :latest tag is specified, or IfNotPresent otherwise. Cannot be updated. More info: https://kubernetes.io/docs/concepts/containers/images#updating-images */
                        imagePullPolicy?: string;
                        /** @description Actions that the management system should take in response to container lifecycle events. Cannot be updated. */
                        lifecycle?: {
                            /** @description PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks */
                            postStart?: {
                                /** @description Exec specifies the action to take. */
                                exec?: {
                                    /** @description Command is the command line to execute inside the container, the working directory for the command  is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. */
                                    command?: string[];
                                };
                                /** @description HTTPGet specifies the http request to perform. */
                                httpGet?: {
                                    /** @description Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. */
                                    host?: string;
                                    /** @description Custom headers to set in the request. HTTP allows repeated headers. */
                                    httpHeaders?: {
                                        /** @description The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header. */
                                        name: string;
                                        /** @description The header field value */
                                        value: string;
                                    }[];
                                    /** @description Path to access on the HTTP server. */
                                    path?: string;
                                    /** @description Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. */
                                    port: number | string;
                                    /** @description Scheme to use for connecting to the host. Defaults to HTTP. */
                                    scheme?: string;
                                };
                                /** @description Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. */
                                tcpSocket?: {
                                    /** @description Optional: Host name to connect to, defaults to the pod IP. */
                                    host?: string;
                                    /** @description Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. */
                                    port: number | string;
                                };
                            };
                            /** @description PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks */
                            preStop?: {
                                /** @description Exec specifies the action to take. */
                                exec?: {
                                    /** @description Command is the command line to execute inside the container, the working directory for the command  is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. */
                                    command?: string[];
                                };
                                /** @description HTTPGet specifies the http request to perform. */
                                httpGet?: {
                                    /** @description Host name to connect to, defaults to the pod IP. You probably want to set "Host" in httpHeaders instead. */
                                    host?: string;
                                    /** @description Custom headers to set in the request. HTTP allows repeated headers. */
                                    httpHeaders?: {
                                        /** @description The header field name. This will be canonicalized upon output, so case-variant names will be understood as the same header. */
                                        name: string;
                                        /** @description The header field value */
                                        value: string;
                                    }[];
                                    /** @description Path to access on the HTTP server. */
                                    path?: string;
                                    /** @description Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. */
                                    port: number | string;
                                    /** @description Scheme to use for connecting to the host. Defaults to HTTP. */
                                    scheme?: string;
                                };
                                /** @description Deprecated. TCPSocket is NOT supported as a LifecycleHandler and kept for the backward compatibility. There are no validation of this field and lifecycle hooks will fail in runtime when tcp handler is specified. */
                                tcpSocket?: {
                                    /** @description Optional: Host name to connect to, defaults to the pod IP. */
                                    host?: string;
                                    /** @description Number or name of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME. */
                                    port: number | string;
                                };
                            };
                        };
                        /** @description Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes */
                        livenessProbe?: {
                            /** @description Exec specifies the action to take. */
                            exec?: {
                                /** @description Command is the command line to execute inside the container, the working directory for the command  is root ('/') in the container's filesystem. The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy. */
                                command?: string[];
                            };
                            /**
                             * Format: int32
                             * @description Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
                             */
                            failureThreshold?: number;
                            /** @description GRPC specifies an action involving a GRPC port. This is a beta field and requires enabling GRPCContainerProbe feature gate. */
                            grpc?: {
                                /**
                                 * Format: int32
                                 * @description Port number of the gRPC service. Number must be in the range 1 to 65535.
                                 */
                                port: number;
                                /** @description Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
                                 *      If this is not specified, the default behavior is defined by gRPC. */