# coding=utf-8
# *** WARNING: this file was generated by pulumigen. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from ... import _utilities
from . import outputs
from ... import meta as _meta

__all__ = [
    'BasicSchedulingPolicy',
    'BasicSchedulingPolicyPatch',
    'GangSchedulingPolicy',
    'GangSchedulingPolicyPatch',
    'PodGroup',
    'PodGroupResourceClaim',
    'PodGroupResourceClaimPatch',
    'PodGroupResourceClaimStatus',
    'PodGroupResourceClaimStatusPatch',
    'PodGroupSchedulingConstraints',
    'PodGroupSchedulingConstraintsPatch',
    'PodGroupSchedulingPolicy',
    'PodGroupSchedulingPolicyPatch',
    'PodGroupSpec',
    'PodGroupSpecPatch',
    'PodGroupStatus',
    'PodGroupStatusPatch',
    'PodGroupTemplate',
    'PodGroupTemplatePatch',
    'PodGroupTemplateReference',
    'PodGroupTemplateReferencePatch',
    'TopologyConstraint',
    'TopologyConstraintPatch',
    'TypedLocalObjectReference',
    'TypedLocalObjectReferencePatch',
    'Workload',
    'WorkloadPodGroupTemplateReference',
    'WorkloadPodGroupTemplateReferencePatch',
    'WorkloadSpec',
    'WorkloadSpecPatch',
]

@pulumi.output_type
class BasicSchedulingPolicy(dict):
    """
    BasicSchedulingPolicy indicates that standard Kubernetes scheduling behavior should be used.
    """
    def __init__(__self__):
        """
        BasicSchedulingPolicy indicates that standard Kubernetes scheduling behavior should be used.
        """
        pass


@pulumi.output_type
class BasicSchedulingPolicyPatch(dict):
    """
    BasicSchedulingPolicy indicates that standard Kubernetes scheduling behavior should be used.
    """
    def __init__(__self__):
        """
        BasicSchedulingPolicy indicates that standard Kubernetes scheduling behavior should be used.
        """
        pass


@pulumi.output_type
class GangSchedulingPolicy(dict):
    """
    GangSchedulingPolicy defines the parameters for gang scheduling.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minCount":
            suggest = "min_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GangSchedulingPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GangSchedulingPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GangSchedulingPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 min_count: _builtins.int):
        """
        GangSchedulingPolicy defines the parameters for gang scheduling.

        :param _builtins.int min_count: MinCount is the minimum number of pods that must be schedulable or scheduled at the same time for the scheduler to admit the entire group. It must be a positive integer.
        """
        pulumi.set(__self__, "min_count", min_count)

    @_builtins.property
    @pulumi.getter(name="minCount")
    def min_count(self) -> _builtins.int:
        """
        MinCount is the minimum number of pods that must be schedulable or scheduled at the same time for the scheduler to admit the entire group. It must be a positive integer.
        """
        return pulumi.get(self, "min_count")


@pulumi.output_type
class GangSchedulingPolicyPatch(dict):
    """
    GangSchedulingPolicy defines the parameters for gang scheduling.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minCount":
            suggest = "min_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GangSchedulingPolicyPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GangSchedulingPolicyPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GangSchedulingPolicyPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 min_count: Optional[_builtins.int] = None):
        """
        GangSchedulingPolicy defines the parameters for gang scheduling.

        :param _builtins.int min_count: MinCount is the minimum number of pods that must be schedulable or scheduled at the same time for the scheduler to admit the entire group. It must be a positive integer.
        """
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)

    @_builtins.property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[_builtins.int]:
        """
        MinCount is the minimum number of pods that must be schedulable or scheduled at the same time for the scheduler to admit the entire group. It must be a positive integer.
        """
        return pulumi.get(self, "min_count")


@pulumi.output_type
class PodGroup(dict):
    """
    PodGroup represents a runtime instance of pods grouped together. PodGroups are created by workload controllers (Job, LWS, JobSet, etc...) from Workload.podGroupTemplates. PodGroup API enablement is toggled by the GenericWorkload feature gate.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 spec: 'outputs.PodGroupSpec',
                 api_version: Optional[_builtins.str] = None,
                 kind: Optional[_builtins.str] = None,
                 metadata: Optional['_meta.v1.outputs.ObjectMeta'] = None,
                 status: Optional['outputs.PodGroupStatus'] = None):
        """
        PodGroup represents a runtime instance of pods grouped together. PodGroups are created by workload controllers (Job, LWS, JobSet, etc...) from Workload.podGroupTemplates. PodGroup API enablement is toggled by the GenericWorkload feature gate.

        :param 'PodGroupSpecArgs' spec: Spec defines the desired state of the PodGroup.
        :param _builtins.str api_version: APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
        :param _builtins.str kind: Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
        :param '_meta.v1.ObjectMetaArgs' metadata: Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
        :param 'PodGroupStatusArgs' status: Status represents the current observed state of the PodGroup.
        """
        pulumi.set(__self__, "spec", spec)
        if api_version is not None:
            pulumi.set(__self__, "api_version", 'scheduling.k8s.io/v1alpha2')
        if kind is not None:
            pulumi.set(__self__, "kind", 'PodGroup')
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter
    def spec(self) -> 'outputs.PodGroupSpec':
        """
        Spec defines the desired state of the PodGroup.
        """
        return pulumi.get(self, "spec")

    @_builtins.property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[_builtins.str]:
        """
        APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
        """
        return pulumi.get(self, "api_version")

    @_builtins.property
    @pulumi.getter
    def kind(self) -> Optional[_builtins.str]:
        """
        Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
        """
        return pulumi.get(self, "kind")

    @_builtins.property
    @pulumi.getter
    def metadata(self) -> Optional['_meta.v1.outputs.ObjectMeta']:
        """
        Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
        """
        return pulumi.get(self, "metadata")

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional['outputs.PodGroupStatus']:
        """
        Status represents the current observed state of the PodGroup.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class PodGroupResourceClaim(dict):
    """
    PodGroupResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the PodGroup.

    It adds a name to it that uniquely identifies the ResourceClaim inside the PodGroup. Pods that need access to the ResourceClaim define a matching reference in its own Spec.ResourceClaims. The Pod's claim must match all fields of the PodGroup's claim exactly.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimName":
            suggest = "resource_claim_name"
        elif key == "resourceClaimTemplateName":
            suggest = "resource_claim_template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupResourceClaim. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupResourceClaim.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupResourceClaim.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: _builtins.str,
                 resource_claim_name: Optional[_builtins.str] = None,
                 resource_claim_template_name: Optional[_builtins.str] = None):
        """
        PodGroupResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the PodGroup.

        It adds a name to it that uniquely identifies the ResourceClaim inside the PodGroup. Pods that need access to the ResourceClaim define a matching reference in its own Spec.ResourceClaims. The Pod's claim must match all fields of the PodGroup's claim exactly.

        :param _builtins.str name: Name uniquely identifies this resource claim inside the PodGroup. This must be a DNS_LABEL.
        :param _builtins.str resource_claim_name: ResourceClaimName is the name of a ResourceClaim object in the same namespace as this PodGroup. The ResourceClaim will be reserved for the PodGroup instead of its individual pods.
               
               Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        :param _builtins.str resource_claim_template_name: ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this PodGroup.
               
               The template will be used to create a new ResourceClaim, which will be bound to this PodGroup. When this PodGroup is deleted, the ResourceClaim will also be deleted. The PodGroup name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in podgroup.status.resourceClaimStatuses.
               
               This field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.
               
               Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        pulumi.set(__self__, "name", name)
        if resource_claim_name is not None:
            pulumi.set(__self__, "resource_claim_name", resource_claim_name)
        if resource_claim_template_name is not None:
            pulumi.set(__self__, "resource_claim_template_name", resource_claim_template_name)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name uniquely identifies this resource claim inside the PodGroup. This must be a DNS_LABEL.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimName")
    def resource_claim_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimName is the name of a ResourceClaim object in the same namespace as this PodGroup. The ResourceClaim will be reserved for the PodGroup instead of its individual pods.

        Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        return pulumi.get(self, "resource_claim_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimTemplateName")
    def resource_claim_template_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this PodGroup.

        The template will be used to create a new ResourceClaim, which will be bound to this PodGroup. When this PodGroup is deleted, the ResourceClaim will also be deleted. The PodGroup name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in podgroup.status.resourceClaimStatuses.

        This field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.

        Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        return pulumi.get(self, "resource_claim_template_name")


@pulumi.output_type
class PodGroupResourceClaimPatch(dict):
    """
    PodGroupResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the PodGroup.

    It adds a name to it that uniquely identifies the ResourceClaim inside the PodGroup. Pods that need access to the ResourceClaim define a matching reference in its own Spec.ResourceClaims. The Pod's claim must match all fields of the PodGroup's claim exactly.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimName":
            suggest = "resource_claim_name"
        elif key == "resourceClaimTemplateName":
            suggest = "resource_claim_template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupResourceClaimPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupResourceClaimPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupResourceClaimPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 resource_claim_name: Optional[_builtins.str] = None,
                 resource_claim_template_name: Optional[_builtins.str] = None):
        """
        PodGroupResourceClaim references exactly one ResourceClaim, either directly or by naming a ResourceClaimTemplate which is then turned into a ResourceClaim for the PodGroup.

        It adds a name to it that uniquely identifies the ResourceClaim inside the PodGroup. Pods that need access to the ResourceClaim define a matching reference in its own Spec.ResourceClaims. The Pod's claim must match all fields of the PodGroup's claim exactly.

        :param _builtins.str name: Name uniquely identifies this resource claim inside the PodGroup. This must be a DNS_LABEL.
        :param _builtins.str resource_claim_name: ResourceClaimName is the name of a ResourceClaim object in the same namespace as this PodGroup. The ResourceClaim will be reserved for the PodGroup instead of its individual pods.
               
               Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        :param _builtins.str resource_claim_template_name: ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this PodGroup.
               
               The template will be used to create a new ResourceClaim, which will be bound to this PodGroup. When this PodGroup is deleted, the ResourceClaim will also be deleted. The PodGroup name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in podgroup.status.resourceClaimStatuses.
               
               This field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.
               
               Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if resource_claim_name is not None:
            pulumi.set(__self__, "resource_claim_name", resource_claim_name)
        if resource_claim_template_name is not None:
            pulumi.set(__self__, "resource_claim_template_name", resource_claim_template_name)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name uniquely identifies this resource claim inside the PodGroup. This must be a DNS_LABEL.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimName")
    def resource_claim_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimName is the name of a ResourceClaim object in the same namespace as this PodGroup. The ResourceClaim will be reserved for the PodGroup instead of its individual pods.

        Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        return pulumi.get(self, "resource_claim_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimTemplateName")
    def resource_claim_template_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimTemplateName is the name of a ResourceClaimTemplate object in the same namespace as this PodGroup.

        The template will be used to create a new ResourceClaim, which will be bound to this PodGroup. When this PodGroup is deleted, the ResourceClaim will also be deleted. The PodGroup name and resource name, along with a generated component, will be used to form a unique name for the ResourceClaim, which will be recorded in podgroup.status.resourceClaimStatuses.

        This field is immutable and no changes will be made to the corresponding ResourceClaim by the control plane after creating the ResourceClaim.

        Exactly one of ResourceClaimName and ResourceClaimTemplateName must be set.
        """
        return pulumi.get(self, "resource_claim_template_name")


@pulumi.output_type
class PodGroupResourceClaimStatus(dict):
    """
    PodGroupResourceClaimStatus is stored in the PodGroupStatus for each PodGroupResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimName":
            suggest = "resource_claim_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupResourceClaimStatus. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupResourceClaimStatus.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupResourceClaimStatus.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: _builtins.str,
                 resource_claim_name: Optional[_builtins.str] = None):
        """
        PodGroupResourceClaimStatus is stored in the PodGroupStatus for each PodGroupResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.

        :param _builtins.str name: Name uniquely identifies this resource claim inside the PodGroup. This must match the name of an entry in podgroup.spec.resourceClaims, which implies that the string must be a DNS_LABEL.
        :param _builtins.str resource_claim_name: ResourceClaimName is the name of the ResourceClaim that was generated for the PodGroup in the namespace of the PodGroup. If this is unset, then generating a ResourceClaim was not necessary. The podgroup.spec.resourceClaims entry can be ignored in this case.
        """
        pulumi.set(__self__, "name", name)
        if resource_claim_name is not None:
            pulumi.set(__self__, "resource_claim_name", resource_claim_name)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name uniquely identifies this resource claim inside the PodGroup. This must match the name of an entry in podgroup.spec.resourceClaims, which implies that the string must be a DNS_LABEL.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimName")
    def resource_claim_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimName is the name of the ResourceClaim that was generated for the PodGroup in the namespace of the PodGroup. If this is unset, then generating a ResourceClaim was not necessary. The podgroup.spec.resourceClaims entry can be ignored in this case.
        """
        return pulumi.get(self, "resource_claim_name")


@pulumi.output_type
class PodGroupResourceClaimStatusPatch(dict):
    """
    PodGroupResourceClaimStatus is stored in the PodGroupStatus for each PodGroupResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimName":
            suggest = "resource_claim_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupResourceClaimStatusPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupResourceClaimStatusPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupResourceClaimStatusPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None,
                 resource_claim_name: Optional[_builtins.str] = None):
        """
        PodGroupResourceClaimStatus is stored in the PodGroupStatus for each PodGroupResourceClaim which references a ResourceClaimTemplate. It stores the generated name for the corresponding ResourceClaim.

        :param _builtins.str name: Name uniquely identifies this resource claim inside the PodGroup. This must match the name of an entry in podgroup.spec.resourceClaims, which implies that the string must be a DNS_LABEL.
        :param _builtins.str resource_claim_name: ResourceClaimName is the name of the ResourceClaim that was generated for the PodGroup in the namespace of the PodGroup. If this is unset, then generating a ResourceClaim was not necessary. The podgroup.spec.resourceClaims entry can be ignored in this case.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if resource_claim_name is not None:
            pulumi.set(__self__, "resource_claim_name", resource_claim_name)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name uniquely identifies this resource claim inside the PodGroup. This must match the name of an entry in podgroup.spec.resourceClaims, which implies that the string must be a DNS_LABEL.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="resourceClaimName")
    def resource_claim_name(self) -> Optional[_builtins.str]:
        """
        ResourceClaimName is the name of the ResourceClaim that was generated for the PodGroup in the namespace of the PodGroup. If this is unset, then generating a ResourceClaim was not necessary. The podgroup.spec.resourceClaims entry can be ignored in this case.
        """
        return pulumi.get(self, "resource_claim_name")


@pulumi.output_type
class PodGroupSchedulingConstraints(dict):
    """
    PodGroupSchedulingConstraints defines scheduling constraints (e.g. topology) for a PodGroup.
    """
    def __init__(__self__, *,
                 topology: Optional[Sequence['outputs.TopologyConstraint']] = None):
        """
        PodGroupSchedulingConstraints defines scheduling constraints (e.g. topology) for a PodGroup.

        :param Sequence['TopologyConstraintArgs'] topology: Topology defines the topology constraints for the pod group. Currently only a single topology constraint can be specified. This may change in the future.
        """
        if topology is not None:
            pulumi.set(__self__, "topology", topology)

    @_builtins.property
    @pulumi.getter
    def topology(self) -> Optional[Sequence['outputs.TopologyConstraint']]:
        """
        Topology defines the topology constraints for the pod group. Currently only a single topology constraint can be specified. This may change in the future.
        """
        return pulumi.get(self, "topology")


@pulumi.output_type
class PodGroupSchedulingConstraintsPatch(dict):
    """
    PodGroupSchedulingConstraints defines scheduling constraints (e.g. topology) for a PodGroup.
    """
    def __init__(__self__, *,
                 topology: Optional[Sequence['outputs.TopologyConstraintPatch']] = None):
        """
        PodGroupSchedulingConstraints defines scheduling constraints (e.g. topology) for a PodGroup.

        :param Sequence['TopologyConstraintPatchArgs'] topology: Topology defines the topology constraints for the pod group. Currently only a single topology constraint can be specified. This may change in the future.
        """
        if topology is not None:
            pulumi.set(__self__, "topology", topology)

    @_builtins.property
    @pulumi.getter
    def topology(self) -> Optional[Sequence['outputs.TopologyConstraintPatch']]:
        """
        Topology defines the topology constraints for the pod group. Currently only a single topology constraint can be specified. This may change in the future.
        """
        return pulumi.get(self, "topology")


@pulumi.output_type
class PodGroupSchedulingPolicy(dict):
    """
    PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set.
    """
    def __init__(__self__, *,
                 basic: Optional['outputs.BasicSchedulingPolicy'] = None,
                 gang: Optional['outputs.GangSchedulingPolicy'] = None):
        """
        PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set.

        :param 'BasicSchedulingPolicyArgs' basic: Basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior.
        :param 'GangSchedulingPolicyArgs' gang: Gang specifies that the pods in this group should be scheduled using all-or-nothing semantics.
        """
        if basic is not None:
            pulumi.set(__self__, "basic", basic)
        if gang is not None:
            pulumi.set(__self__, "gang", gang)

    @_builtins.property
    @pulumi.getter
    def basic(self) -> Optional['outputs.BasicSchedulingPolicy']:
        """
        Basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior.
        """
        return pulumi.get(self, "basic")

    @_builtins.property
    @pulumi.getter
    def gang(self) -> Optional['outputs.GangSchedulingPolicy']:
        """
        Gang specifies that the pods in this group should be scheduled using all-or-nothing semantics.
        """
        return pulumi.get(self, "gang")


@pulumi.output_type
class PodGroupSchedulingPolicyPatch(dict):
    """
    PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set.
    """
    def __init__(__self__, *,
                 basic: Optional['outputs.BasicSchedulingPolicyPatch'] = None,
                 gang: Optional['outputs.GangSchedulingPolicyPatch'] = None):
        """
        PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set.

        :param 'BasicSchedulingPolicyPatchArgs' basic: Basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior.
        :param 'GangSchedulingPolicyPatchArgs' gang: Gang specifies that the pods in this group should be scheduled using all-or-nothing semantics.
        """
        if basic is not None:
            pulumi.set(__self__, "basic", basic)
        if gang is not None:
            pulumi.set(__self__, "gang", gang)

    @_builtins.property
    @pulumi.getter
    def basic(self) -> Optional['outputs.BasicSchedulingPolicyPatch']:
        """
        Basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior.
        """
        return pulumi.get(self, "basic")

    @_builtins.property
    @pulumi.getter
    def gang(self) -> Optional['outputs.GangSchedulingPolicyPatch']:
        """
        Gang specifies that the pods in this group should be scheduled using all-or-nothing semantics.
        """
        return pulumi.get(self, "gang")


@pulumi.output_type
class PodGroupSpec(dict):
    """
    PodGroupSpec defines the desired state of a PodGroup.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schedulingPolicy":
            suggest = "scheduling_policy"
        elif key == "disruptionMode":
            suggest = "disruption_mode"
        elif key == "podGroupTemplateRef":
            suggest = "pod_group_template_ref"
        elif key == "priorityClassName":
            suggest = "priority_class_name"
        elif key == "resourceClaims":
            suggest = "resource_claims"
        elif key == "schedulingConstraints":
            suggest = "scheduling_constraints"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 scheduling_policy: 'outputs.PodGroupSchedulingPolicy',
                 disruption_mode: Optional[_builtins.str] = None,
                 pod_group_template_ref: Optional['outputs.PodGroupTemplateReference'] = None,
                 priority: Optional[_builtins.int] = None,
                 priority_class_name: Optional[_builtins.str] = None,
                 resource_claims: Optional[Sequence['outputs.PodGroupResourceClaim']] = None,
                 scheduling_constraints: Optional['outputs.PodGroupSchedulingConstraints'] = None):
        """
        PodGroupSpec defines the desired state of a PodGroup.

        :param 'PodGroupSchedulingPolicyArgs' scheduling_policy: SchedulingPolicy defines the scheduling policy for this instance of the PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable.
        :param _builtins.str disruption_mode: DisruptionMode defines the mode in which a given PodGroup can be disrupted. Controllers are expected to fill this field by copying it from a PodGroupTemplate. One of Pod, PodGroup. Defaults to Pod if unset. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param 'PodGroupTemplateReferenceArgs' pod_group_template_ref: PodGroupTemplateRef references an optional PodGroup template within other object (e.g. Workload) that was used to create the PodGroup. This field is immutable.
        :param _builtins.int priority: Priority is the value of priority of this pod group. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.str priority_class_name: PriorityClassName defines the priority that should be considered when scheduling this pod group. Controllers are expected to fill this field by copying it from a PodGroupTemplate. Otherwise, it is validated and resolved similarly to the PriorityClassName on PodGroupTemplate (i.e. if no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, the pod group's priority will be zero). This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param Sequence['PodGroupResourceClaimArgs'] resource_claims: ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.
               
               This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.
               
               This field is immutable.
        :param 'PodGroupSchedulingConstraintsArgs' scheduling_constraints: SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        pulumi.set(__self__, "scheduling_policy", scheduling_policy)
        if disruption_mode is not None:
            pulumi.set(__self__, "disruption_mode", disruption_mode)
        if pod_group_template_ref is not None:
            pulumi.set(__self__, "pod_group_template_ref", pod_group_template_ref)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if priority_class_name is not None:
            pulumi.set(__self__, "priority_class_name", priority_class_name)
        if resource_claims is not None:
            pulumi.set(__self__, "resource_claims", resource_claims)
        if scheduling_constraints is not None:
            pulumi.set(__self__, "scheduling_constraints", scheduling_constraints)

    @_builtins.property
    @pulumi.getter(name="schedulingPolicy")
    def scheduling_policy(self) -> 'outputs.PodGroupSchedulingPolicy':
        """
        SchedulingPolicy defines the scheduling policy for this instance of the PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable.
        """
        return pulumi.get(self, "scheduling_policy")

    @_builtins.property
    @pulumi.getter(name="disruptionMode")
    def disruption_mode(self) -> Optional[_builtins.str]:
        """
        DisruptionMode defines the mode in which a given PodGroup can be disrupted. Controllers are expected to fill this field by copying it from a PodGroupTemplate. One of Pod, PodGroup. Defaults to Pod if unset. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "disruption_mode")

    @_builtins.property
    @pulumi.getter(name="podGroupTemplateRef")
    def pod_group_template_ref(self) -> Optional['outputs.PodGroupTemplateReference']:
        """
        PodGroupTemplateRef references an optional PodGroup template within other object (e.g. Workload) that was used to create the PodGroup. This field is immutable.
        """
        return pulumi.get(self, "pod_group_template_ref")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.int]:
        """
        Priority is the value of priority of this pod group. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority")

    @_builtins.property
    @pulumi.getter(name="priorityClassName")
    def priority_class_name(self) -> Optional[_builtins.str]:
        """
        PriorityClassName defines the priority that should be considered when scheduling this pod group. Controllers are expected to fill this field by copying it from a PodGroupTemplate. Otherwise, it is validated and resolved similarly to the PriorityClassName on PodGroupTemplate (i.e. if no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, the pod group's priority will be zero). This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority_class_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaims")
    def resource_claims(self) -> Optional[Sequence['outputs.PodGroupResourceClaim']]:
        """
        ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.

        This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.

        This field is immutable.
        """
        return pulumi.get(self, "resource_claims")

    @_builtins.property
    @pulumi.getter(name="schedulingConstraints")
    def scheduling_constraints(self) -> Optional['outputs.PodGroupSchedulingConstraints']:
        """
        SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        return pulumi.get(self, "scheduling_constraints")


@pulumi.output_type
class PodGroupSpecPatch(dict):
    """
    PodGroupSpec defines the desired state of a PodGroup.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disruptionMode":
            suggest = "disruption_mode"
        elif key == "podGroupTemplateRef":
            suggest = "pod_group_template_ref"
        elif key == "priorityClassName":
            suggest = "priority_class_name"
        elif key == "resourceClaims":
            suggest = "resource_claims"
        elif key == "schedulingConstraints":
            suggest = "scheduling_constraints"
        elif key == "schedulingPolicy":
            suggest = "scheduling_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupSpecPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupSpecPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupSpecPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disruption_mode: Optional[_builtins.str] = None,
                 pod_group_template_ref: Optional['outputs.PodGroupTemplateReferencePatch'] = None,
                 priority: Optional[_builtins.int] = None,
                 priority_class_name: Optional[_builtins.str] = None,
                 resource_claims: Optional[Sequence['outputs.PodGroupResourceClaimPatch']] = None,
                 scheduling_constraints: Optional['outputs.PodGroupSchedulingConstraintsPatch'] = None,
                 scheduling_policy: Optional['outputs.PodGroupSchedulingPolicyPatch'] = None):
        """
        PodGroupSpec defines the desired state of a PodGroup.

        :param _builtins.str disruption_mode: DisruptionMode defines the mode in which a given PodGroup can be disrupted. Controllers are expected to fill this field by copying it from a PodGroupTemplate. One of Pod, PodGroup. Defaults to Pod if unset. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param 'PodGroupTemplateReferencePatchArgs' pod_group_template_ref: PodGroupTemplateRef references an optional PodGroup template within other object (e.g. Workload) that was used to create the PodGroup. This field is immutable.
        :param _builtins.int priority: Priority is the value of priority of this pod group. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.str priority_class_name: PriorityClassName defines the priority that should be considered when scheduling this pod group. Controllers are expected to fill this field by copying it from a PodGroupTemplate. Otherwise, it is validated and resolved similarly to the PriorityClassName on PodGroupTemplate (i.e. if no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, the pod group's priority will be zero). This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param Sequence['PodGroupResourceClaimPatchArgs'] resource_claims: ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.
               
               This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.
               
               This field is immutable.
        :param 'PodGroupSchedulingConstraintsPatchArgs' scheduling_constraints: SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        :param 'PodGroupSchedulingPolicyPatchArgs' scheduling_policy: SchedulingPolicy defines the scheduling policy for this instance of the PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable.
        """
        if disruption_mode is not None:
            pulumi.set(__self__, "disruption_mode", disruption_mode)
        if pod_group_template_ref is not None:
            pulumi.set(__self__, "pod_group_template_ref", pod_group_template_ref)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if priority_class_name is not None:
            pulumi.set(__self__, "priority_class_name", priority_class_name)
        if resource_claims is not None:
            pulumi.set(__self__, "resource_claims", resource_claims)
        if scheduling_constraints is not None:
            pulumi.set(__self__, "scheduling_constraints", scheduling_constraints)
        if scheduling_policy is not None:
            pulumi.set(__self__, "scheduling_policy", scheduling_policy)

    @_builtins.property
    @pulumi.getter(name="disruptionMode")
    def disruption_mode(self) -> Optional[_builtins.str]:
        """
        DisruptionMode defines the mode in which a given PodGroup can be disrupted. Controllers are expected to fill this field by copying it from a PodGroupTemplate. One of Pod, PodGroup. Defaults to Pod if unset. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "disruption_mode")

    @_builtins.property
    @pulumi.getter(name="podGroupTemplateRef")
    def pod_group_template_ref(self) -> Optional['outputs.PodGroupTemplateReferencePatch']:
        """
        PodGroupTemplateRef references an optional PodGroup template within other object (e.g. Workload) that was used to create the PodGroup. This field is immutable.
        """
        return pulumi.get(self, "pod_group_template_ref")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.int]:
        """
        Priority is the value of priority of this pod group. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority")

    @_builtins.property
    @pulumi.getter(name="priorityClassName")
    def priority_class_name(self) -> Optional[_builtins.str]:
        """
        PriorityClassName defines the priority that should be considered when scheduling this pod group. Controllers are expected to fill this field by copying it from a PodGroupTemplate. Otherwise, it is validated and resolved similarly to the PriorityClassName on PodGroupTemplate (i.e. if no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, the pod group's priority will be zero). This field is immutable. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority_class_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaims")
    def resource_claims(self) -> Optional[Sequence['outputs.PodGroupResourceClaimPatch']]:
        """
        ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.

        This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.

        This field is immutable.
        """
        return pulumi.get(self, "resource_claims")

    @_builtins.property
    @pulumi.getter(name="schedulingConstraints")
    def scheduling_constraints(self) -> Optional['outputs.PodGroupSchedulingConstraintsPatch']:
        """
        SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        return pulumi.get(self, "scheduling_constraints")

    @_builtins.property
    @pulumi.getter(name="schedulingPolicy")
    def scheduling_policy(self) -> Optional['outputs.PodGroupSchedulingPolicyPatch']:
        """
        SchedulingPolicy defines the scheduling policy for this instance of the PodGroup. Controllers are expected to fill this field by copying it from a PodGroupTemplate. This field is immutable.
        """
        return pulumi.get(self, "scheduling_policy")


@pulumi.output_type
class PodGroupStatus(dict):
    """
    PodGroupStatus represents information about the status of a pod group.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimStatuses":
            suggest = "resource_claim_statuses"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupStatus. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupStatus.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupStatus.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 conditions: Optional[Sequence['_meta.v1.outputs.Condition']] = None,
                 resource_claim_statuses: Optional[Sequence['outputs.PodGroupResourceClaimStatus']] = None):
        """
        PodGroupStatus represents information about the status of a pod group.

        :param Sequence['_meta.v1.ConditionArgs'] conditions: Conditions represent the latest observations of the PodGroup's state.
               
               Known condition types: - "PodGroupScheduled": Indicates whether the scheduling requirement has been satisfied. - "DisruptionTarget": Indicates whether the PodGroup is about to be terminated
                 due to disruption such as preemption.
               
               Known reasons for the PodGroupScheduled condition: - "Unschedulable": The PodGroup cannot be scheduled due to resource constraints,
                 affinity/anti-affinity rules, or insufficient capacity for the gang.
               - "SchedulerError": The PodGroup cannot be scheduled due to some internal error
                 that happened during scheduling, for example due to nodeAffinity parsing errors.
               
               Known reasons for the DisruptionTarget condition: - "PreemptionByScheduler": The PodGroup was preempted by the scheduler to make room for
                 higher-priority PodGroups or Pods.
        :param Sequence['PodGroupResourceClaimStatusArgs'] resource_claim_statuses: Status of resource claims.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if resource_claim_statuses is not None:
            pulumi.set(__self__, "resource_claim_statuses", resource_claim_statuses)

    @_builtins.property
    @pulumi.getter
    def conditions(self) -> Optional[Sequence['_meta.v1.outputs.Condition']]:
        """
        Conditions represent the latest observations of the PodGroup's state.

        Known condition types: - "PodGroupScheduled": Indicates whether the scheduling requirement has been satisfied. - "DisruptionTarget": Indicates whether the PodGroup is about to be terminated
          due to disruption such as preemption.

        Known reasons for the PodGroupScheduled condition: - "Unschedulable": The PodGroup cannot be scheduled due to resource constraints,
          affinity/anti-affinity rules, or insufficient capacity for the gang.
        - "SchedulerError": The PodGroup cannot be scheduled due to some internal error
          that happened during scheduling, for example due to nodeAffinity parsing errors.

        Known reasons for the DisruptionTarget condition: - "PreemptionByScheduler": The PodGroup was preempted by the scheduler to make room for
          higher-priority PodGroups or Pods.
        """
        return pulumi.get(self, "conditions")

    @_builtins.property
    @pulumi.getter(name="resourceClaimStatuses")
    def resource_claim_statuses(self) -> Optional[Sequence['outputs.PodGroupResourceClaimStatus']]:
        """
        Status of resource claims.
        """
        return pulumi.get(self, "resource_claim_statuses")


@pulumi.output_type
class PodGroupStatusPatch(dict):
    """
    PodGroupStatus represents information about the status of a pod group.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceClaimStatuses":
            suggest = "resource_claim_statuses"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupStatusPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupStatusPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupStatusPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 conditions: Optional[Sequence['_meta.v1.outputs.ConditionPatch']] = None,
                 resource_claim_statuses: Optional[Sequence['outputs.PodGroupResourceClaimStatusPatch']] = None):
        """
        PodGroupStatus represents information about the status of a pod group.

        :param Sequence['_meta.v1.ConditionPatchArgs'] conditions: Conditions represent the latest observations of the PodGroup's state.
               
               Known condition types: - "PodGroupScheduled": Indicates whether the scheduling requirement has been satisfied. - "DisruptionTarget": Indicates whether the PodGroup is about to be terminated
                 due to disruption such as preemption.
               
               Known reasons for the PodGroupScheduled condition: - "Unschedulable": The PodGroup cannot be scheduled due to resource constraints,
                 affinity/anti-affinity rules, or insufficient capacity for the gang.
               - "SchedulerError": The PodGroup cannot be scheduled due to some internal error
                 that happened during scheduling, for example due to nodeAffinity parsing errors.
               
               Known reasons for the DisruptionTarget condition: - "PreemptionByScheduler": The PodGroup was preempted by the scheduler to make room for
                 higher-priority PodGroups or Pods.
        :param Sequence['PodGroupResourceClaimStatusPatchArgs'] resource_claim_statuses: Status of resource claims.
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if resource_claim_statuses is not None:
            pulumi.set(__self__, "resource_claim_statuses", resource_claim_statuses)

    @_builtins.property
    @pulumi.getter
    def conditions(self) -> Optional[Sequence['_meta.v1.outputs.ConditionPatch']]:
        """
        Conditions represent the latest observations of the PodGroup's state.

        Known condition types: - "PodGroupScheduled": Indicates whether the scheduling requirement has been satisfied. - "DisruptionTarget": Indicates whether the PodGroup is about to be terminated
          due to disruption such as preemption.

        Known reasons for the PodGroupScheduled condition: - "Unschedulable": The PodGroup cannot be scheduled due to resource constraints,
          affinity/anti-affinity rules, or insufficient capacity for the gang.
        - "SchedulerError": The PodGroup cannot be scheduled due to some internal error
          that happened during scheduling, for example due to nodeAffinity parsing errors.

        Known reasons for the DisruptionTarget condition: - "PreemptionByScheduler": The PodGroup was preempted by the scheduler to make room for
          higher-priority PodGroups or Pods.
        """
        return pulumi.get(self, "conditions")

    @_builtins.property
    @pulumi.getter(name="resourceClaimStatuses")
    def resource_claim_statuses(self) -> Optional[Sequence['outputs.PodGroupResourceClaimStatusPatch']]:
        """
        Status of resource claims.
        """
        return pulumi.get(self, "resource_claim_statuses")


@pulumi.output_type
class PodGroupTemplate(dict):
    """
    PodGroupTemplate represents a template for a set of pods with a scheduling policy.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schedulingPolicy":
            suggest = "scheduling_policy"
        elif key == "disruptionMode":
            suggest = "disruption_mode"
        elif key == "priorityClassName":
            suggest = "priority_class_name"
        elif key == "resourceClaims":
            suggest = "resource_claims"
        elif key == "schedulingConstraints":
            suggest = "scheduling_constraints"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: _builtins.str,
                 scheduling_policy: 'outputs.PodGroupSchedulingPolicy',
                 disruption_mode: Optional[_builtins.str] = None,
                 priority: Optional[_builtins.int] = None,
                 priority_class_name: Optional[_builtins.str] = None,
                 resource_claims: Optional[Sequence['outputs.PodGroupResourceClaim']] = None,
                 scheduling_constraints: Optional['outputs.PodGroupSchedulingConstraints'] = None):
        """
        PodGroupTemplate represents a template for a set of pods with a scheduling policy.

        :param _builtins.str name: Name is a unique identifier for the PodGroupTemplate within the Workload. It must be a DNS label. This field is immutable.
        :param 'PodGroupSchedulingPolicyArgs' scheduling_policy: SchedulingPolicy defines the scheduling policy for this PodGroupTemplate.
        :param _builtins.str disruption_mode: DisruptionMode defines the mode in which a given PodGroup can be disrupted. One of Pod, PodGroup. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.int priority: Priority is the value of priority of pod groups created from this template. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.str priority_class_name: PriorityClassName indicates the priority that should be considered when scheduling a pod group created from this template. If no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, pod groups created from this template will have the priority set to zero. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param Sequence['PodGroupResourceClaimArgs'] resource_claims: ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.
               
               This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.
               
               This field is immutable.
        :param 'PodGroupSchedulingConstraintsArgs' scheduling_constraints: SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroupTemplate. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "scheduling_policy", scheduling_policy)
        if disruption_mode is not None:
            pulumi.set(__self__, "disruption_mode", disruption_mode)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if priority_class_name is not None:
            pulumi.set(__self__, "priority_class_name", priority_class_name)
        if resource_claims is not None:
            pulumi.set(__self__, "resource_claims", resource_claims)
        if scheduling_constraints is not None:
            pulumi.set(__self__, "scheduling_constraints", scheduling_constraints)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name is a unique identifier for the PodGroupTemplate within the Workload. It must be a DNS label. This field is immutable.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="schedulingPolicy")
    def scheduling_policy(self) -> 'outputs.PodGroupSchedulingPolicy':
        """
        SchedulingPolicy defines the scheduling policy for this PodGroupTemplate.
        """
        return pulumi.get(self, "scheduling_policy")

    @_builtins.property
    @pulumi.getter(name="disruptionMode")
    def disruption_mode(self) -> Optional[_builtins.str]:
        """
        DisruptionMode defines the mode in which a given PodGroup can be disrupted. One of Pod, PodGroup. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "disruption_mode")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.int]:
        """
        Priority is the value of priority of pod groups created from this template. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority")

    @_builtins.property
    @pulumi.getter(name="priorityClassName")
    def priority_class_name(self) -> Optional[_builtins.str]:
        """
        PriorityClassName indicates the priority that should be considered when scheduling a pod group created from this template. If no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, pod groups created from this template will have the priority set to zero. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority_class_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaims")
    def resource_claims(self) -> Optional[Sequence['outputs.PodGroupResourceClaim']]:
        """
        ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.

        This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.

        This field is immutable.
        """
        return pulumi.get(self, "resource_claims")

    @_builtins.property
    @pulumi.getter(name="schedulingConstraints")
    def scheduling_constraints(self) -> Optional['outputs.PodGroupSchedulingConstraints']:
        """
        SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroupTemplate. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        return pulumi.get(self, "scheduling_constraints")


@pulumi.output_type
class PodGroupTemplatePatch(dict):
    """
    PodGroupTemplate represents a template for a set of pods with a scheduling policy.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disruptionMode":
            suggest = "disruption_mode"
        elif key == "priorityClassName":
            suggest = "priority_class_name"
        elif key == "resourceClaims":
            suggest = "resource_claims"
        elif key == "schedulingConstraints":
            suggest = "scheduling_constraints"
        elif key == "schedulingPolicy":
            suggest = "scheduling_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodGroupTemplatePatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodGroupTemplatePatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodGroupTemplatePatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disruption_mode: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 priority: Optional[_builtins.int] = None,
                 priority_class_name: Optional[_builtins.str] = None,
                 resource_claims: Optional[Sequence['outputs.PodGroupResourceClaimPatch']] = None,
                 scheduling_constraints: Optional['outputs.PodGroupSchedulingConstraintsPatch'] = None,
                 scheduling_policy: Optional['outputs.PodGroupSchedulingPolicyPatch'] = None):
        """
        PodGroupTemplate represents a template for a set of pods with a scheduling policy.

        :param _builtins.str disruption_mode: DisruptionMode defines the mode in which a given PodGroup can be disrupted. One of Pod, PodGroup. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.str name: Name is a unique identifier for the PodGroupTemplate within the Workload. It must be a DNS label. This field is immutable.
        :param _builtins.int priority: Priority is the value of priority of pod groups created from this template. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param _builtins.str priority_class_name: PriorityClassName indicates the priority that should be considered when scheduling a pod group created from this template. If no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, pod groups created from this template will have the priority set to zero. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        :param Sequence['PodGroupResourceClaimPatchArgs'] resource_claims: ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.
               
               This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.
               
               This field is immutable.
        :param 'PodGroupSchedulingConstraintsPatchArgs' scheduling_constraints: SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroupTemplate. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        :param 'PodGroupSchedulingPolicyPatchArgs' scheduling_policy: SchedulingPolicy defines the scheduling policy for this PodGroupTemplate.
        """
        if disruption_mode is not None:
            pulumi.set(__self__, "disruption_mode", disruption_mode)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if priority_class_name is not None:
            pulumi.set(__self__, "priority_class_name", priority_class_name)
        if resource_claims is not None:
            pulumi.set(__self__, "resource_claims", resource_claims)
        if scheduling_constraints is not None:
            pulumi.set(__self__, "scheduling_constraints", scheduling_constraints)
        if scheduling_policy is not None:
            pulumi.set(__self__, "scheduling_policy", scheduling_policy)

    @_builtins.property
    @pulumi.getter(name="disruptionMode")
    def disruption_mode(self) -> Optional[_builtins.str]:
        """
        DisruptionMode defines the mode in which a given PodGroup can be disrupted. One of Pod, PodGroup. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "disruption_mode")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name is a unique identifier for the PodGroupTemplate within the Workload. It must be a DNS label. This field is immutable.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter
    def priority(self) -> Optional[_builtins.int]:
        """
        Priority is the value of priority of pod groups created from this template. Various system components use this field to find the priority of the pod group. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority")

    @_builtins.property
    @pulumi.getter(name="priorityClassName")
    def priority_class_name(self) -> Optional[_builtins.str]:
        """
        PriorityClassName indicates the priority that should be considered when scheduling a pod group created from this template. If no priority class is specified, admission control can set this to the global default priority class if it exists. Otherwise, pod groups created from this template will have the priority set to zero. This field is available only when the WorkloadAwarePreemption feature gate is enabled.
        """
        return pulumi.get(self, "priority_class_name")

    @_builtins.property
    @pulumi.getter(name="resourceClaims")
    def resource_claims(self) -> Optional[Sequence['outputs.PodGroupResourceClaimPatch']]:
        """
        ResourceClaims defines which ResourceClaims may be shared among Pods in the group. Pods consume the devices allocated to a PodGroup's claim by defining a claim in its own Spec.ResourceClaims that matches the PodGroup's claim exactly. The claim must have the same name and refer to the same ResourceClaim or ResourceClaimTemplate.

        This is an alpha-level field and requires that the DRAWorkloadResourceClaims feature gate is enabled.

        This field is immutable.
        """
        return pulumi.get(self, "resource_claims")

    @_builtins.property
    @pulumi.getter(name="schedulingConstraints")
    def scheduling_constraints(self) -> Optional['outputs.PodGroupSchedulingConstraintsPatch']:
        """
        SchedulingConstraints defines optional scheduling constraints (e.g. topology) for this PodGroupTemplate. This field is only available when the TopologyAwareWorkloadScheduling feature gate is enabled.
        """
        return pulumi.get(self, "scheduling_constraints")

    @_builtins.property
    @pulumi.getter(name="schedulingPolicy")
    def scheduling_policy(self) -> Optional['outputs.PodGroupSchedulingPolicyPatch']:
        """
        SchedulingPolicy defines the scheduling policy for this PodGroupTemplate.
        """
        return pulumi.get(self, "scheduling_policy")


@pulumi.output_type
class PodGroupTemplateReference(dict):
    """
    PodGroupTemplateReference references a PodGroup template defined in some object (e.g. Workload). Exactly one reference must be set.
    """
    def __init__(__self__, *,
                 workload: Optional['outputs.WorkloadPodGroupTemplateReference'] = None):
        """
        PodGroupTemplateReference references a PodGroup template defined in some object (e.g. Workload). Exactly one reference must be set.

        :param 'WorkloadPodGroupTemplateReferenceArgs' workload: Workload references the PodGroupTemplate within the Workload object that was used to create the PodGroup.
        """
        if workload is not None:
            pulumi.set(__self__, "workload", workload)

    @_builtins.property
    @pulumi.getter
    def workload(self) -> Optional['outputs.WorkloadPodGroupTemplateReference']:
        """
        Workload references the PodGroupTemplate within the Workload object that was used to create the PodGroup.
        """
        return pulumi.get(self, "workload")


@pulumi.output_type
class PodGroupTemplateReferencePatch(dict):
    """
    PodGroupTemplateReference references a PodGroup template defined in some object (e.g. Workload). Exactly one reference must be set.
    """
    def __init__(__self__, *,
                 workload: Optional['outputs.WorkloadPodGroupTemplateReferencePatch'] = None):
        """
        PodGroupTemplateReference references a PodGroup template defined in some object (e.g. Workload). Exactly one reference must be set.

        :param 'WorkloadPodGroupTemplateReferencePatchArgs' workload: Workload references the PodGroupTemplate within the Workload object that was used to create the PodGroup.
        """
        if workload is not None:
            pulumi.set(__self__, "workload", workload)

    @_builtins.property
    @pulumi.getter
    def workload(self) -> Optional['outputs.WorkloadPodGroupTemplateReferencePatch']:
        """
        Workload references the PodGroupTemplate within the Workload object that was used to create the PodGroup.
        """
        return pulumi.get(self, "workload")


@pulumi.output_type
class TopologyConstraint(dict):
    """
    TopologyConstraint defines a topology constraint for a PodGroup.
    """
    def __init__(__self__, *,
                 key: _builtins.str):
        """
        TopologyConstraint defines a topology constraint for a PodGroup.

        :param _builtins.str key: Key specifies the key of the node label representing the topology domain. All pods within the PodGroup must be colocated within the same domain instance. Different PodGroups can land on different domain instances even if they derive from the same PodGroupTemplate. Examples: "topology.kubernetes.io/rack"
        """
        pulumi.set(__self__, "key", key)

    @_builtins.property
    @pulumi.getter
    def key(self) -> _builtins.str:
        """
        Key specifies the key of the node label representing the topology domain. All pods within the PodGroup must be colocated within the same domain instance. Different PodGroups can land on different domain instances even if they derive from the same PodGroupTemplate. Examples: "topology.kubernetes.io/rack"
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class TopologyConstraintPatch(dict):
    """
    TopologyConstraint defines a topology constraint for a PodGroup.
    """
    def __init__(__self__, *,
                 key: Optional[_builtins.str] = None):
        """
        TopologyConstraint defines a topology constraint for a PodGroup.

        :param _builtins.str key: Key specifies the key of the node label representing the topology domain. All pods within the PodGroup must be colocated within the same domain instance. Different PodGroups can land on different domain instances even if they derive from the same PodGroupTemplate. Examples: "topology.kubernetes.io/rack"
        """
        if key is not None:
            pulumi.set(__self__, "key", key)

    @_builtins.property
    @pulumi.getter
    def key(self) -> Optional[_builtins.str]:
        """
        Key specifies the key of the node label representing the topology domain. All pods within the PodGroup must be colocated within the same domain instance. Different PodGroups can land on different domain instances even if they derive from the same PodGroupTemplate. Examples: "topology.kubernetes.io/rack"
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class TypedLocalObjectReference(dict):
    """
    TypedLocalObjectReference allows to reference typed object inside the same namespace.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroup":
            suggest = "api_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TypedLocalObjectReference. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TypedLocalObjectReference.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TypedLocalObjectReference.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kind: _builtins.str,
                 name: _builtins.str,
                 api_group: Optional[_builtins.str] = None):
        """
        TypedLocalObjectReference allows to reference typed object inside the same namespace.

        :param _builtins.str kind: Kind is the type of resource being referenced. It must be a path segment name.
        :param _builtins.str name: Name is the name of resource being referenced. It must be a path segment name.
        :param _builtins.str api_group: APIGroup is the group for the resource being referenced. If APIGroup is empty, the specified Kind must be in the core API group. For any other third-party types, setting APIGroup is required. It must be a DNS subdomain.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "name", name)
        if api_group is not None:
            pulumi.set(__self__, "api_group", api_group)

    @_builtins.property
    @pulumi.getter
    def kind(self) -> _builtins.str:
        """
        Kind is the type of resource being referenced. It must be a path segment name.
        """
        return pulumi.get(self, "kind")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        Name is the name of resource being referenced. It must be a path segment name.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="apiGroup")
    def api_group(self) -> Optional[_builtins.str]:
        """
        APIGroup is the group for the resource being referenced. If APIGroup is empty, the specified Kind must be in the core API group. For any other third-party types, setting APIGroup is required. It must be a DNS subdomain.
        """
        return pulumi.get(self, "api_group")


@pulumi.output_type
class TypedLocalObjectReferencePatch(dict):
    """
    TypedLocalObjectReference allows to reference typed object inside the same namespace.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroup":
            suggest = "api_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TypedLocalObjectReferencePatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TypedLocalObjectReferencePatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TypedLocalObjectReferencePatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_group: Optional[_builtins.str] = None,
                 kind: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None):
        """
        TypedLocalObjectReference allows to reference typed object inside the same namespace.

        :param _builtins.str api_group: APIGroup is the group for the resource being referenced. If APIGroup is empty, the specified Kind must be in the core API group. For any other third-party types, setting APIGroup is required. It must be a DNS subdomain.
        :param _builtins.str kind: Kind is the type of resource being referenced. It must be a path segment name.
        :param _builtins.str name: Name is the name of resource being referenced. It must be a path segment name.
        """
        if api_group is not None:
            pulumi.set(__self__, "api_group", api_group)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="apiGroup")
    def api_group(self) -> Optional[_builtins.str]:
        """
        APIGroup is the group for the resource being referenced. If APIGroup is empty, the specified Kind must be in the core API group. For any other third-party types, setting APIGroup is required. It must be a DNS subdomain.
        """
        return pulumi.get(self, "api_group")

    @_builtins.property
    @pulumi.getter
    def kind(self) -> Optional[_builtins.str]:
        """
        Kind is the type of resource being referenced. It must be a path segment name.
        """
        return pulumi.get(self, "kind")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name is the name of resource being referenced. It must be a path segment name.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class Workload(dict):
    """
    Workload allows for expressing scheduling constraints that should be used when managing the lifecycle of workloads from the scheduling perspective, including scheduling, preemption, eviction and other phases. Workload API enablement is toggled by the GenericWorkload feature gate.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in Workload. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        Workload.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        Workload.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 spec: 'outputs.WorkloadSpec',
                 api_version: Optional[_builtins.str] = None,
                 kind: Optional[_builtins.str] = None,
                 metadata: Optional['_meta.v1.outputs.ObjectMeta'] = None):
        """
        Workload allows for expressing scheduling constraints that should be used when managing the lifecycle of workloads from the scheduling perspective, including scheduling, preemption, eviction and other phases. Workload API enablement is toggled by the GenericWorkload feature gate.

        :param 'WorkloadSpecArgs' spec: Spec defines the desired behavior of a Workload.
        :param _builtins.str api_version: APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
        :param _builtins.str kind: Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
        :param '_meta.v1.ObjectMetaArgs' metadata: Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
        """
        pulumi.set(__self__, "spec", spec)
        if api_version is not None:
            pulumi.set(__self__, "api_version", 'scheduling.k8s.io/v1alpha2')
        if kind is not None:
            pulumi.set(__self__, "kind", 'Workload')
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)

    @_builtins.property
    @pulumi.getter
    def spec(self) -> 'outputs.WorkloadSpec':
        """
        Spec defines the desired behavior of a Workload.
        """
        return pulumi.get(self, "spec")

    @_builtins.property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[_builtins.str]:
        """
        APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
        """
        return pulumi.get(self, "api_version")

    @_builtins.property
    @pulumi.getter
    def kind(self) -> Optional[_builtins.str]:
        """
        Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
        """
        return pulumi.get(self, "kind")

    @_builtins.property
    @pulumi.getter
    def metadata(self) -> Optional['_meta.v1.outputs.ObjectMeta']:
        """
        Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
        """
        return pulumi.get(self, "metadata")


@pulumi.output_type
class WorkloadPodGroupTemplateReference(dict):
    """
    WorkloadPodGroupTemplateReference references the PodGroupTemplate within the Workload object.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podGroupTemplateName":
            suggest = "pod_group_template_name"
        elif key == "workloadName":
            suggest = "workload_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkloadPodGroupTemplateReference. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkloadPodGroupTemplateReference.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkloadPodGroupTemplateReference.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_group_template_name: _builtins.str,
                 workload_name: _builtins.str):
        """
        WorkloadPodGroupTemplateReference references the PodGroupTemplate within the Workload object.

        :param _builtins.str pod_group_template_name: PodGroupTemplateName defines the PodGroupTemplate name within the Workload object.
        :param _builtins.str workload_name: WorkloadName defines the name of the Workload object.
        """
        pulumi.set(__self__, "pod_group_template_name", pod_group_template_name)
        pulumi.set(__self__, "workload_name", workload_name)

    @_builtins.property
    @pulumi.getter(name="podGroupTemplateName")
    def pod_group_template_name(self) -> _builtins.str:
        """
        PodGroupTemplateName defines the PodGroupTemplate name within the Workload object.
        """
        return pulumi.get(self, "pod_group_template_name")

    @_builtins.property
    @pulumi.getter(name="workloadName")
    def workload_name(self) -> _builtins.str:
        """
        WorkloadName defines the name of the Workload object.
        """
        return pulumi.get(self, "workload_name")


@pulumi.output_type
class WorkloadPodGroupTemplateReferencePatch(dict):
    """
    WorkloadPodGroupTemplateReference references the PodGroupTemplate within the Workload object.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podGroupTemplateName":
            suggest = "pod_group_template_name"
        elif key == "workloadName":
            suggest = "workload_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkloadPodGroupTemplateReferencePatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkloadPodGroupTemplateReferencePatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkloadPodGroupTemplateReferencePatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_group_template_name: Optional[_builtins.str] = None,
                 workload_name: Optional[_builtins.str] = None):
        """
        WorkloadPodGroupTemplateReference references the PodGroupTemplate within the Workload object.

        :param _builtins.str pod_group_template_name: PodGroupTemplateName defines the PodGroupTemplate name within the Workload object.
        :param _builtins.str workload_name: WorkloadName defines the name of the Workload object.
        """
        if pod_group_template_name is not None:
            pulumi.set(__self__, "pod_group_template_name", pod_group_template_name)
        if workload_name is not None:
            pulumi.set(__self__, "workload_name", workload_name)

    @_builtins.property
    @pulumi.getter(name="podGroupTemplateName")
    def pod_group_template_name(self) -> Optional[_builtins.str]:
        """
        PodGroupTemplateName defines the PodGroupTemplate name within the Workload object.
        """
        return pulumi.get(self, "pod_group_template_name")

    @_builtins.property
    @pulumi.getter(name="workloadName")
    def workload_name(self) -> Optional[_builtins.str]:
        """
        WorkloadName defines the name of the Workload object.
        """
        return pulumi.get(self, "workload_name")


@pulumi.output_type
class WorkloadSpec(dict):
    """
    WorkloadSpec defines the desired state of a Workload.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podGroupTemplates":
            suggest = "pod_group_templates"
        elif key == "controllerRef":
            suggest = "controller_ref"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkloadSpec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkloadSpec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkloadSpec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_group_templates: Sequence['outputs.PodGroupTemplate'],
                 controller_ref: Optional['outputs.TypedLocalObjectReference'] = None):
        """
        WorkloadSpec defines the desired state of a Workload.

        :param Sequence['PodGroupTemplateArgs'] pod_group_templates: PodGroupTemplates is the list of templates that make up the Workload. The maximum number of templates is 8. This field is immutable.
        :param 'TypedLocalObjectReferenceArgs' controller_ref: ControllerRef is an optional reference to the controlling object, such as a Deployment or Job. This field is intended for use by tools like CLIs to provide a link back to the original workload definition. This field is immutable.
        """
        pulumi.set(__self__, "pod_group_templates", pod_group_templates)
        if controller_ref is not None:
            pulumi.set(__self__, "controller_ref", controller_ref)

    @_builtins.property
    @pulumi.getter(name="podGroupTemplates")
    def pod_group_templates(self) -> Sequence['outputs.PodGroupTemplate']:
        """
        PodGroupTemplates is the list of templates that make up the Workload. The maximum number of templates is 8. This field is immutable.
        """
        return pulumi.get(self, "pod_group_templates")

    @_builtins.property
    @pulumi.getter(name="controllerRef")
    def controller_ref(self) -> Optional['outputs.TypedLocalObjectReference']:
        """
        ControllerRef is an optional reference to the controlling object, such as a Deployment or Job. This field is intended for use by tools like CLIs to provide a link back to the original workload definition. This field is immutable.
        """
        return pulumi.get(self, "controller_ref")


@pulumi.output_type
class WorkloadSpecPatch(dict):
    """
    WorkloadSpec defines the desired state of a Workload.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "controllerRef":
            suggest = "controller_ref"
        elif key == "podGroupTemplates":
            suggest = "pod_group_templates"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in WorkloadSpecPatch. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        WorkloadSpecPatch.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        WorkloadSpecPatch.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 controller_ref: Optional['outputs.TypedLocalObjectReferencePatch'] = None,
                 pod_group_templates: Optional[Sequence['outputs.PodGroupTemplatePatch']] = None):
        """
        WorkloadSpec defines the desired state of a Workload.

        :param 'TypedLocalObjectReferencePatchArgs' controller_ref: ControllerRef is an optional reference to the controlling object, such as a Deployment or Job. This field is intended for use by tools like CLIs to provide a link back to the original workload definition. This field is immutable.
        :param Sequence['PodGroupTemplatePatchArgs'] pod_group_templates: PodGroupTemplates is the list of templates that make up the Workload. The maximum number of templates is 8. This field is immutable.
        """
        if controller_ref is not None:
            pulumi.set(__self__, "controller_ref", controller_ref)
        if pod_group_templates is not None:
            pulumi.set(__self__, "pod_group_templates", pod_group_templates)

    @_builtins.property
    @pulumi.getter(name="controllerRef")
    def controller_ref(self) -> Optional['outputs.TypedLocalObjectReferencePatch']:
        """
        ControllerRef is an optional reference to the controlling object, such as a Deployment or Job. This field is intended for use by tools like CLIs to provide a link back to the original workload definition. This field is immutable.
        """
        return pulumi.get(self, "controller_ref")

    @_builtins.property
    @pulumi.getter(name="podGroupTemplates")
    def pod_group_templates(self) -> Optional[Sequence['outputs.PodGroupTemplatePatch']]:
        """
        PodGroupTemplates is the list of templates that make up the Workload. The maximum number of templates is 8. This field is immutable.
        """
        return pulumi.get(self, "pod_group_templates")


