/// <summary> /// Initializes a new instance of the /// Iok8sapinetworkingv1NetworkPolicyPeer class. /// </summary> /// <param name="ipBlock">IPBlock defines policy on a particular /// IPBlock</param> /// <param name="namespaceSelector">Selects Namespaces using cluster /// scoped-labels. This matches all pods in all namespaces selected by /// this label selector. This field follows standard label selector /// semantics. If present but empty, this selector selects all /// namespaces.</param> /// <param name="podSelector">This is a label selector which selects /// Pods in this namespace. This field follows standard label selector /// semantics. If present but empty, this selector selects all pods in /// this namespace.</param> public Iok8sapinetworkingv1NetworkPolicyPeer(Iok8sapinetworkingv1IPBlock ipBlock = default(Iok8sapinetworkingv1IPBlock), Iok8sapimachinerypkgapismetav1LabelSelector namespaceSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapimachinerypkgapismetav1LabelSelector podSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector)) { IpBlock = ipBlock; NamespaceSelector = namespaceSelector; PodSelector = podSelector; CustomInit(); }
/// <summary> /// Initializes a new instance of the Iok8sapicorev1PodAffinityTerm /// class. /// </summary> /// <param name="topologyKey">This pod should be co-located (affinity) /// or not co-located (anti-affinity) with the pods matching the /// labelSelector in the specified namespaces, where co-located is /// defined as running on a node whose value of the label with key /// topologyKey matches that of any node on which any of the selected /// pods is running. Empty topologyKey is not allowed.</param> /// <param name="labelSelector">A label query over a set of resources, /// in this case pods.</param> /// <param name="namespaces">namespaces specifies which namespaces the /// labelSelector applies to (matches against); null or empty list /// means "this pod's namespace"</param> public Iok8sapicorev1PodAffinityTerm(string topologyKey, Iok8sapimachinerypkgapismetav1LabelSelector labelSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), IList <string> namespaces = default(IList <string>)) { LabelSelector = labelSelector; Namespaces = namespaces; TopologyKey = topologyKey; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapipolicyv1beta1PodDisruptionBudgetSpec class. /// </summary> /// <param name="maxUnavailable">An eviction is allowed if at most /// "maxUnavailable" pods selected by "selector" are unavailable after /// the eviction, i.e. even in absence of the evicted pod. For example, /// one can prevent all voluntary evictions by specifying 0. This is a /// mutually exclusive setting with "minAvailable".</param> /// <param name="minAvailable">An eviction is allowed if at least /// "minAvailable" pods selected by "selector" will still be available /// after the eviction, i.e. even in the absence of the evicted pod. /// So for example you can prevent all voluntary evictions by /// specifying "100%".</param> /// <param name="selector">Label query over pods whose evictions are /// managed by the disruption budget.</param> public Iok8sapipolicyv1beta1PodDisruptionBudgetSpec(string maxUnavailable = default(string), string minAvailable = default(string), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector)) { MaxUnavailable = maxUnavailable; MinAvailable = minAvailable; Selector = selector; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapiautoscalingv2beta1ExternalMetricSource class. /// </summary> /// <param name="metricName">metricName is the name of the metric in /// question.</param> /// <param name="metricSelector">metricSelector is used to identify a /// specific time series within a given metric.</param> /// <param name="targetAverageValue">targetAverageValue is the target /// per-pod value of global metric (as a quantity). Mutually exclusive /// with TargetValue.</param> /// <param name="targetValue">targetValue is the target value of the /// metric (as a quantity). Mutually exclusive with /// TargetAverageValue.</param> public Iok8sapiautoscalingv2beta1ExternalMetricSource(string metricName, Iok8sapimachinerypkgapismetav1LabelSelector metricSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), string targetAverageValue = default(string), string targetValue = default(string)) { MetricName = metricName; MetricSelector = metricSelector; TargetAverageValue = targetAverageValue; TargetValue = targetValue; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapiextensionsv1beta1ReplicaSetSpec class. /// </summary> /// <param name="minReadySeconds">Minimum number of seconds for which a /// newly created pod should be ready without any of its container /// crashing, for it to be considered available. Defaults to 0 (pod /// will be considered available as soon as it is ready)</param> /// <param name="replicas">Replicas is the number of desired replicas. /// This is a pointer to distinguish between explicit zero and /// unspecified. Defaults to 1. More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller</param> /// <param name="selector">Selector is a label query over pods that /// should match the replica count. If the selector is empty, it is /// defaulted to the labels present on the pod template. Label keys and /// values that must match in order to be controlled by this replica /// set. More info: /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param> /// <param name="template">Template is the object that describes the /// pod that will be created if insufficient replicas are detected. /// More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template</param> public Iok8sapiextensionsv1beta1ReplicaSetSpec(int?minReadySeconds = default(int?), int?replicas = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapicorev1PodTemplateSpec template = default(Iok8sapicorev1PodTemplateSpec)) { MinReadySeconds = minReadySeconds; Replicas = replicas; Selector = selector; Template = template; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapiextensionsv1beta1NetworkPolicySpec class. /// </summary> /// <param name="podSelector">Selects the pods to which this /// NetworkPolicy object applies. The array of ingress rules is /// applied to any pods selected by this field. Multiple network /// policies can select the same set of pods. In this case, the /// ingress rules for each are combined additively. This field is NOT /// optional and follows standard label selector semantics. An empty /// podSelector matches all pods in this namespace.</param> /// <param name="egress">List of egress rules to be applied to the /// selected pods. Outgoing traffic is allowed if there are no /// NetworkPolicies selecting the pod (and cluster policy otherwise /// allows the traffic), OR if the traffic matches at least one egress /// rule across all of the NetworkPolicy objects whose podSelector /// matches the pod. If this field is empty then this NetworkPolicy /// limits all outgoing traffic (and serves solely to ensure that the /// pods it selects are isolated by default). This field is beta-level /// in 1.8</param> /// <param name="ingress">List of ingress rules to be applied to the /// selected pods. Traffic is allowed to a pod if there are no /// NetworkPolicies selecting the pod OR if the traffic source is the /// pod's local node, OR if the traffic matches at least one ingress /// rule across all of the NetworkPolicy objects whose podSelector /// matches the pod. If this field is empty then this NetworkPolicy /// does not allow any traffic (and serves solely to ensure that the /// pods it selects are isolated by default).</param> /// <param name="policyTypes">List of rule types that the NetworkPolicy /// relates to. Valid options are Ingress, Egress, or Ingress,Egress. /// If this field is not specified, it will default based on the /// existence of Ingress or Egress rules; policies that contain an /// Egress section are assumed to affect Egress, and all policies /// (whether or not they contain an Ingress section) are assumed to /// affect Ingress. If you want to write an egress-only policy, you /// must explicitly specify policyTypes [ "Egress" ]. Likewise, if you /// want to write a policy that specifies that no egress is allowed, /// you must specify a policyTypes value that include "Egress" (since /// such a policy would not include an Egress section and would /// otherwise default to just [ "Ingress" ]). This field is beta-level /// in 1.8</param> public Iok8sapiextensionsv1beta1NetworkPolicySpec(Iok8sapimachinerypkgapismetav1LabelSelector podSelector, IList <Iok8sapiextensionsv1beta1NetworkPolicyEgressRule> egress = default(IList <Iok8sapiextensionsv1beta1NetworkPolicyEgressRule>), IList <Iok8sapiextensionsv1beta1NetworkPolicyIngressRule> ingress = default(IList <Iok8sapiextensionsv1beta1NetworkPolicyIngressRule>), IList <string> policyTypes = default(IList <string>)) { Egress = egress; Ingress = ingress; PodSelector = podSelector; PolicyTypes = policyTypes; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapiautoscalingv2beta1ExternalMetricStatus class. /// </summary> /// <param name="currentValue">currentValue is the current value of the /// metric (as a quantity)</param> /// <param name="metricName">metricName is the name of a metric used /// for autoscaling in metric system.</param> /// <param name="currentAverageValue">currentAverageValue is the /// current value of metric averaged over autoscaled pods.</param> /// <param name="metricSelector">metricSelector is used to identify a /// specific time series within a given metric.</param> public Iok8sapiautoscalingv2beta1ExternalMetricStatus(string currentValue, string metricName, string currentAverageValue = default(string), Iok8sapimachinerypkgapismetav1LabelSelector metricSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector)) { CurrentAverageValue = currentAverageValue; CurrentValue = currentValue; MetricName = metricName; MetricSelector = metricSelector; CustomInit(); }
/// <summary> /// Initializes a new instance of the Iok8sapiappsv1beta2DaemonSetSpec /// class. /// </summary> /// <param name="selector">A label query over pods that are managed by /// the daemon set. Must match in order to be controlled. It must match /// the pod template's labels. More info: /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param> /// <param name="template">An object that describes the pod that will /// be created. The DaemonSet will create exactly one copy of this pod /// on every node that matches the template's node selector (or on /// every node if no node selector is specified). More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template</param> /// <param name="minReadySeconds">The minimum number of seconds for /// which a newly created DaemonSet pod should be ready without any of /// its container crashing, for it to be considered available. Defaults /// to 0 (pod will be considered available as soon as it is /// ready).</param> /// <param name="revisionHistoryLimit">The number of old history to /// retain to allow rollback. This is a pointer to distinguish between /// explicit zero and not specified. Defaults to 10.</param> /// <param name="updateStrategy">An update strategy to replace existing /// DaemonSet pods with new pods.</param> public Iok8sapiappsv1beta2DaemonSetSpec(Iok8sapimachinerypkgapismetav1LabelSelector selector, Iok8sapicorev1PodTemplateSpec template, int?minReadySeconds = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapiappsv1beta2DaemonSetUpdateStrategy updateStrategy = default(Iok8sapiappsv1beta2DaemonSetUpdateStrategy)) { MinReadySeconds = minReadySeconds; RevisionHistoryLimit = revisionHistoryLimit; Selector = selector; Template = template; UpdateStrategy = updateStrategy; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapiadmissionregistrationv1beta1Webhook class. /// </summary> /// <param name="clientConfig">ClientConfig defines how to communicate /// with the hook. Required</param> /// <param name="name">The name of the admission webhook. Name should /// be fully qualified, e.g., imagepolicy.kubernetes.io, where /// "imagepolicy" is the name of the webhook, and kubernetes.io is the /// name of the organization. Required.</param> /// <param name="failurePolicy">FailurePolicy defines how unrecognized /// errors from the admission endpoint are handled - allowed values are /// Ignore or Fail. Defaults to Ignore.</param> /// <param name="namespaceSelector">NamespaceSelector decides whether /// to run the webhook on an object based on whether the namespace for /// that object matches the selector. If the object itself is a /// namespace, the matching is performed on object.metadata.labels. If /// the object is another cluster scoped resource, it never skips the /// webhook. /// /// For example, to run the webhook on any objects whose namespace is /// not associated with "runlevel" of "0" or "1"; you will set the /// selector as follows: "namespaceSelector": { /// "matchExpressions": [ /// { /// "key": "runlevel", /// "operator": "NotIn", /// "values": [ /// "0", /// "1" /// ] /// } /// ] /// } /// /// If instead you want to only run the webhook on any objects whose /// namespace is associated with the "environment" of "prod" or /// "staging"; you will set the selector as follows: /// "namespaceSelector": { /// "matchExpressions": [ /// { /// "key": "environment", /// "operator": "In", /// "values": [ /// "prod", /// "staging" /// ] /// } /// ] /// } /// /// See /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ /// for more examples of label selectors. /// /// Default to the empty LabelSelector, which matches /// everything.</param> /// <param name="rules">Rules describes what operations on what /// resources/subresources the webhook cares about. The webhook cares /// about an operation if it matches _any_ Rule. However, in order to /// prevent ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks /// from putting the cluster in a state which cannot be recovered from /// without completely disabling the plugin, /// ValidatingAdmissionWebhooks and MutatingAdmissionWebhooks are never /// called on admission requests for ValidatingWebhookConfiguration and /// MutatingWebhookConfiguration objects.</param> public Iok8sapiadmissionregistrationv1beta1Webhook(Iok8sapiadmissionregistrationv1beta1WebhookClientConfig clientConfig, string name, string failurePolicy = default(string), Iok8sapimachinerypkgapismetav1LabelSelector namespaceSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), IList <Iok8sapiadmissionregistrationv1beta1RuleWithOperations> rules = default(IList <Iok8sapiadmissionregistrationv1beta1RuleWithOperations>)) { ClientConfig = clientConfig; FailurePolicy = failurePolicy; Name = name; NamespaceSelector = namespaceSelector; Rules = rules; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapisettingsv1alpha1PodPresetSpec class. /// </summary> /// <param name="env">Env defines the collection of EnvVar to inject /// into containers.</param> /// <param name="envFrom">EnvFrom defines the collection of /// EnvFromSource to inject into containers.</param> /// <param name="selector">Selector is a label query over a set of /// resources, in this case pods. Required.</param> /// <param name="volumeMounts">VolumeMounts defines the collection of /// VolumeMount to inject into containers.</param> /// <param name="volumes">Volumes defines the collection of Volume to /// inject into the pod.</param> public Iok8sapisettingsv1alpha1PodPresetSpec(IList <Iok8sapicorev1EnvVar> env = default(IList <Iok8sapicorev1EnvVar>), IList <Iok8sapicorev1EnvFromSource> envFrom = default(IList <Iok8sapicorev1EnvFromSource>), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), IList <Iok8sapicorev1VolumeMount> volumeMounts = default(IList <Iok8sapicorev1VolumeMount>), IList <Iok8sapicorev1Volume> volumes = default(IList <Iok8sapicorev1Volume>)) { Env = env; EnvFrom = envFrom; Selector = selector; VolumeMounts = volumeMounts; Volumes = volumes; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// Iok8sapicorev1PersistentVolumeClaimSpec class. /// </summary> /// <param name="accessModes">AccessModes contains the desired access /// modes the volume should have. More info: /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1</param> /// <param name="resources">Resources represents the minimum resources /// the volume should have. More info: /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources</param> /// <param name="selector">A label query over volumes to consider for /// binding.</param> /// <param name="storageClassName">Name of the StorageClass required by /// the claim. More info: /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1</param> /// <param name="volumeMode">volumeMode defines what type of volume is /// required by the claim. Value of Filesystem is implied when not /// included in claim spec. This is an alpha feature and may change in /// the future.</param> /// <param name="volumeName">VolumeName is the binding reference to the /// PersistentVolume backing this claim.</param> public Iok8sapicorev1PersistentVolumeClaimSpec(IList <string> accessModes = default(IList <string>), Iok8sapicorev1ResourceRequirements resources = default(Iok8sapicorev1ResourceRequirements), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), string storageClassName = default(string), string volumeMode = default(string), string volumeName = default(string)) { AccessModes = accessModes; Resources = resources; Selector = selector; StorageClassName = storageClassName; VolumeMode = volumeMode; VolumeName = volumeName; CustomInit(); }
/// <summary> /// Initializes a new instance of the Iok8sapibatchv1JobSpec class. /// </summary> /// <param name="template">Describes the pod that will be created when /// executing a job. More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param> /// <param name="activeDeadlineSeconds">Specifies the duration in /// seconds relative to the startTime that the job may be active before /// the system tries to terminate it; value must be positive /// integer</param> /// <param name="backoffLimit">Specifies the number of retries before /// marking this job failed. Defaults to 6</param> /// <param name="completions">Specifies the desired number of /// successfully finished pods the job should be run with. Setting to /// nil means that the success of any pod signals the success of all /// pods, and allows parallelism to have any positive value. Setting /// to 1 means that parallelism is limited to 1 and the success of that /// pod signals the success of the job. More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param> /// <param name="manualSelector">manualSelector controls generation of /// pod labels and pod selectors. Leave `manualSelector` unset unless /// you are certain what you are doing. When false or unset, the system /// pick labels unique to this job and appends those labels to the pod /// template. When true, the user is responsible for picking unique /// labels and specifying the selector. Failure to pick a unique label /// may cause this and other jobs to not function correctly. However, /// You may see `manualSelector=true` in jobs that were created with /// the old `extensions/v1beta1` API. More info: /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector</param> /// <param name="parallelism">Specifies the maximum desired number of /// pods the job should run at any given time. The actual number of /// pods running in steady state will be less than this number when /// ((.spec.completions - .status.successful) < .spec.parallelism), /// i.e. when the work left to do is less than max parallelism. More /// info: /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param> /// <param name="selector">A label query over pods that should match /// the pod count. Normally, the system sets this field for you. More /// info: /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param> public Iok8sapibatchv1JobSpec(Iok8sapicorev1PodTemplateSpec template, long?activeDeadlineSeconds = default(long?), int?backoffLimit = default(int?), int?completions = default(int?), bool?manualSelector = default(bool?), int?parallelism = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector)) { ActiveDeadlineSeconds = activeDeadlineSeconds; BackoffLimit = backoffLimit; Completions = completions; ManualSelector = manualSelector; Parallelism = parallelism; Selector = selector; Template = template; CustomInit(); }
/// <summary> /// Initializes a new instance of the Iok8sapiappsv1beta2DeploymentSpec /// class. /// </summary> /// <param name="selector">Label selector for pods. Existing /// ReplicaSets whose pods are selected by this will be the ones /// affected by this deployment. It must match the pod template's /// labels.</param> /// <param name="template">Template describes the pods that will be /// created.</param> /// <param name="minReadySeconds">Minimum number of seconds for which a /// newly created pod should be ready without any of its container /// crashing, for it to be considered available. Defaults to 0 (pod /// will be considered available as soon as it is ready)</param> /// <param name="paused">Indicates that the deployment is /// paused.</param> /// <param name="progressDeadlineSeconds">The maximum time in seconds /// for a deployment to make progress before it is considered to be /// failed. The deployment controller will continue to process failed /// deployments and a condition with a ProgressDeadlineExceeded reason /// will be surfaced in the deployment status. Note that progress will /// not be estimated during the time a deployment is paused. Defaults /// to 600s.</param> /// <param name="replicas">Number of desired pods. This is a pointer to /// distinguish between explicit zero and not specified. Defaults to /// 1.</param> /// <param name="revisionHistoryLimit">The number of old ReplicaSets to /// retain to allow rollback. This is a pointer to distinguish between /// explicit zero and not specified. Defaults to 10.</param> /// <param name="strategy">The deployment strategy to use to replace /// existing pods with new ones.</param> public Iok8sapiappsv1beta2DeploymentSpec(Iok8sapimachinerypkgapismetav1LabelSelector selector, Iok8sapicorev1PodTemplateSpec template, int?minReadySeconds = default(int?), bool?paused = default(bool?), int?progressDeadlineSeconds = default(int?), int?replicas = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapiappsv1beta2DeploymentStrategy strategy = default(Iok8sapiappsv1beta2DeploymentStrategy)) { MinReadySeconds = minReadySeconds; Paused = paused; ProgressDeadlineSeconds = progressDeadlineSeconds; Replicas = replicas; RevisionHistoryLimit = revisionHistoryLimit; Selector = selector; Strategy = strategy; Template = template; CustomInit(); }
/// <summary> /// Initializes a new instance of the Iok8sapiappsv1StatefulSetSpec /// class. /// </summary> /// <param name="selector">selector is a label query over pods that /// should match the replica count. It must match the pod template's /// labels. More info: /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param> /// <param name="serviceName">serviceName is the name of the service /// that governs this StatefulSet. This service must exist before the /// StatefulSet, and is responsible for the network identity of the /// set. Pods get DNS/hostnames that follow the pattern: /// pod-specific-string.serviceName.default.svc.cluster.local where /// "pod-specific-string" is managed by the StatefulSet /// controller.</param> /// <param name="template">template is the object that describes the /// pod that will be created if insufficient replicas are detected. /// Each pod stamped out by the StatefulSet will fulfill this Template, /// but have a unique identity from the rest of the /// StatefulSet.</param> /// <param name="podManagementPolicy">podManagementPolicy controls how /// pods are created during initial scale up, when replacing pods on /// nodes, or when scaling down. The default policy is `OrderedReady`, /// where pods are created in increasing order (pod-0, then pod-1, etc) /// and the controller will wait until each pod is ready before /// continuing. When scaling down, the pods are removed in the opposite /// order. The alternative policy is `Parallel` which will create pods /// in parallel to match the desired scale without waiting, and on /// scale down will delete all pods at once.</param> /// <param name="replicas">replicas is the desired number of replicas /// of the given Template. These are replicas in the sense that they /// are instantiations of the same Template, but individual replicas /// also have a consistent identity. If unspecified, defaults to /// 1.</param> /// <param name="revisionHistoryLimit">revisionHistoryLimit is the /// maximum number of revisions that will be maintained in the /// StatefulSet's revision history. The revision history consists of /// all revisions not represented by a currently applied /// StatefulSetSpec version. The default value is 10.</param> /// <param name="updateStrategy">updateStrategy indicates the /// StatefulSetUpdateStrategy that will be employed to update Pods in /// the StatefulSet when a revision is made to Template.</param> /// <param name="volumeClaimTemplates">volumeClaimTemplates is a list /// of claims that pods are allowed to reference. The StatefulSet /// controller is responsible for mapping network identities to claims /// in a way that maintains the identity of a pod. Every claim in this /// list must have at least one matching (by name) volumeMount in one /// container in the template. A claim in this list takes precedence /// over any volumes in the template, with the same name.</param> public Iok8sapiappsv1StatefulSetSpec(Iok8sapimachinerypkgapismetav1LabelSelector selector, string serviceName, Iok8sapicorev1PodTemplateSpec template, string podManagementPolicy = default(string), int?replicas = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapiappsv1StatefulSetUpdateStrategy updateStrategy = default(Iok8sapiappsv1StatefulSetUpdateStrategy), IList <Iok8sapicorev1PersistentVolumeClaim> volumeClaimTemplates = default(IList <Iok8sapicorev1PersistentVolumeClaim>)) { PodManagementPolicy = podManagementPolicy; Replicas = replicas; RevisionHistoryLimit = revisionHistoryLimit; Selector = selector; ServiceName = serviceName; Template = template; UpdateStrategy = updateStrategy; VolumeClaimTemplates = volumeClaimTemplates; CustomInit(); }